lix-project/lix
20
58
Fork 31
Code Issues 355 Code Review (Gerrit) Projects 3 Releases Wiki Activity

libexpr: associate memory with EvalContext

Browse source 
Change-Id: I791ae16cd42a674972c782a869b7d790880313ff
This commit is contained in:
eldritch horrors 2024-12-03 20:38:41 +01:00
parent 5db5eed43d
commit 1f37fc85ac
14 changed files with 109 additions and 109 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
lix/legacy/nix-env.cc
View file

@ -174,7 +174,7 @@ static void loadSourceExpr(EvalState & state, const SourcePath & path, Value & v
~/.nix-defexpr directory that includes some system-wide ~/.nix-defexpr directory that includes some system-wide
directory). */ directory). */
else if (st.type == InputAccessor::tDirectory) { else if (st.type == InputAccessor::tDirectory) {
auto attrs = state.buildBindings(maxAttrs); auto attrs = state.ctx.buildBindings(maxAttrs);
attrs.alloc("_combineChannels").mkList(0); attrs.alloc("_combineChannels").mkList(0);
StringSet seen; StringSet seen;
getAllExprs(state, path, seen, attrs); getAllExprs(state, path, seen, attrs);
@ -700,7 +700,7 @@ static void opUpgrade(Globals & globals, Strings opFlags, Strings opArgs)
static void setMetaFlag(EvalState & state, DrvInfo & drv, static void setMetaFlag(EvalState & state, DrvInfo & drv,
const std::string & name, const std::string & value) const std::string & name, const std::string & value)
{ {
auto v = state.mem.allocValue(); auto v = state.ctx.mem.allocValue();
v->mkString(value); v->mkString(value);
drv.setMeta(state, name, v); drv.setMeta(state, name, v);
} }

16
lix/legacy/user-env.cc
View file

@ -34,7 +34,7 @@ bool createUserEnv(EvalState & state, DrvInfos & elems,
/* Construct the whole top level derivation. */ /* Construct the whole top level derivation. */
StorePathSet references; StorePathSet references;
Value manifest = state.mem.newList(elems.size()); Value manifest = state.ctx.mem.newList(elems.size());
size_t n = 0; size_t n = 0;
for (auto & i : elems) { for (auto & i : elems) {
/* Create a pseudo-derivation containing the name, system, /* Create a pseudo-derivation containing the name, system,
@ -44,7 +44,7 @@ bool createUserEnv(EvalState & state, DrvInfos & elems,
DrvInfo::Outputs outputs = i.queryOutputs(state, true, true); DrvInfo::Outputs outputs = i.queryOutputs(state, true, true);
StringSet metaNames = i.queryMetaNames(state); StringSet metaNames = i.queryMetaNames(state);
auto attrs = state.buildBindings(7 + outputs.size()); auto attrs = state.ctx.buildBindings(7 + outputs.size());
attrs.alloc(state.ctx.s.type).mkString("derivation"); attrs.alloc(state.ctx.s.type).mkString("derivation");
attrs.alloc(state.ctx.s.name).mkString(i.queryName(state)); attrs.alloc(state.ctx.s.name).mkString(i.queryName(state));
@ -57,10 +57,10 @@ bool createUserEnv(EvalState & state, DrvInfos & elems,
// Copy each output meant for installation. // Copy each output meant for installation.
auto & vOutputs = attrs.alloc(state.ctx.s.outputs); auto & vOutputs = attrs.alloc(state.ctx.s.outputs);
vOutputs = state.mem.newList(outputs.size()); vOutputs = state.ctx.mem.newList(outputs.size());
for (const auto & [m, j] : enumerate(outputs)) { for (const auto & [m, j] : enumerate(outputs)) {
(vOutputs.listElems()[m] = state.mem.allocValue())->mkString(j.first); (vOutputs.listElems()[m] = state.ctx.mem.allocValue())->mkString(j.first);
auto outputAttrs = state.buildBindings(2); auto outputAttrs = state.ctx.buildBindings(2);
outputAttrs.alloc(state.ctx.s.outPath).mkString(state.ctx.store->printStorePath(*j.second)); outputAttrs.alloc(state.ctx.s.outPath).mkString(state.ctx.store->printStorePath(*j.second));
attrs.alloc(j.first).mkAttrs(outputAttrs); attrs.alloc(j.first).mkAttrs(outputAttrs);
@ -73,7 +73,7 @@ bool createUserEnv(EvalState & state, DrvInfos & elems,
} }
// Copy the meta attributes. // Copy the meta attributes.
auto meta = state.buildBindings(metaNames.size()); auto meta = state.ctx.buildBindings(metaNames.size());
for (auto & j : metaNames) { for (auto & j : metaNames) {
Value * v = i.queryMeta(state, j); Value * v = i.queryMeta(state, j);
if (!v) continue; if (!v) continue;
@ -82,7 +82,7 @@ bool createUserEnv(EvalState & state, DrvInfos & elems,
attrs.alloc(state.ctx.s.meta).mkAttrs(meta); attrs.alloc(state.ctx.s.meta).mkAttrs(meta);
(manifest.listElems()[n++] = state.mem.allocValue())->mkAttrs(attrs); (manifest.listElems()[n++] = state.ctx.mem.allocValue())->mkAttrs(attrs);
if (drvPath) references.insert(*drvPath); if (drvPath) references.insert(*drvPath);
} }
@ -103,7 +103,7 @@ bool createUserEnv(EvalState & state, DrvInfos & elems,
/* Construct a Nix expression that calls the user environment /* Construct a Nix expression that calls the user environment
builder with the manifest as argument. */ builder with the manifest as argument. */
auto attrs = state.buildBindings(3); auto attrs = state.ctx.buildBindings(3);
state.paths.mkStorePathString(manifestFile, attrs.alloc("manifest")); state.paths.mkStorePathString(manifestFile, attrs.alloc("manifest"));
attrs.insert(state.ctx.symbols.create("derivations"), &manifest); attrs.insert(state.ctx.symbols.create("derivations"), &manifest);
Value args; Value args;

2
lix/libcmd/cmd-profiles.cc
View file

@ -21,7 +21,7 @@ DrvInfos queryInstalled(EvalState & state, const Path & userEnv)
if (pathExists(manifestFile)) { if (pathExists(manifestFile)) {
Value v; Value v;
state.evalFile(CanonPath(manifestFile), v); state.evalFile(CanonPath(manifestFile), v);
Bindings & bindings(*state.mem.allocBindings(0)); Bindings & bindings(*state.ctx.mem.allocBindings(0));
getDerivations(state, v, "", bindings, elems, false); getDerivations(state, v, "", bindings, elems, false);
} }
return elems; return elems;

2
lix/libcmd/installables.cc
View file

@ -405,7 +405,7 @@ ref<eval_cache::EvalCache> openEvalCache(
if (getEnv("NIX_ALLOW_EVAL").value_or("1") == "0") if (getEnv("NIX_ALLOW_EVAL").value_or("1") == "0")
throw Error("not everything is cached, but evaluation is not allowed"); throw Error("not everything is cached, but evaluation is not allowed");
auto vFlake = state.mem.allocValue(); auto vFlake = state.ctx.mem.allocValue();
flake::callFlake(state, *lockedFlake, *vFlake); flake::callFlake(state, *lockedFlake, *vFlake);
state.forceAttrs(*vFlake, noPos, "while parsing cached flake data"); state.forceAttrs(*vFlake, noPos, "while parsing cached flake data");

4
lix/libexpr/attr-path.cc
View file

@ -45,7 +45,7 @@ std::pair<Value *, PosIdx> findAlongAttrPath(EvalState & state, const std::strin
auto attrIndex = string2Int<unsigned int>(attr); auto attrIndex = string2Int<unsigned int>(attr);
/* Evaluate the expression. */ /* Evaluate the expression. */
Value * vNew = state.mem.allocValue(); Value * vNew = state.ctx.mem.allocValue();
state.autoCallFunction(autoArgs, *v, *vNew); state.autoCallFunction(autoArgs, *v, *vNew);
v = vNew; v = vNew;
state.forceValue(*v, noPos); state.forceValue(*v, noPos);
@ -100,7 +100,7 @@ std::pair<SourcePath, uint32_t> findPackageFilename(EvalState & state, Value & v
{ {
Value * v2; Value * v2;
try { try {
auto dummyArgs = state.mem.allocBindings(0); auto dummyArgs = state.ctx.mem.allocBindings(0);
v2 = findAlongAttrPath(state, "meta.position", *dummyArgs, v).first; v2 = findAlongAttrPath(state, "meta.position", *dummyArgs, v).first;
} catch (Error &) { } catch (Error &) {
throw NoPositionInfo("package '%s' has no source location information", what); throw NoPositionInfo("package '%s' has no source location information", what);

36
lix/libexpr/eval.cc
View file

@ -799,7 +799,7 @@ void EvalState::mkPos(Value & v, PosIdx p)
{ {
auto origin = ctx.positions.originOf(p); auto origin = ctx.positions.originOf(p);
if (auto path = std::get_if<SourcePath>(&origin)) { if (auto path = std::get_if<SourcePath>(&origin)) {
auto attrs = buildBindings(3); auto attrs = ctx.buildBindings(3);
attrs.alloc(ctx.s.file).mkString(path->path.abs()); attrs.alloc(ctx.s.file).mkString(path->path.abs());
makePositionThunks(*this, p, attrs.alloc(ctx.s.line), attrs.alloc(ctx.s.column)); makePositionThunks(*this, p, attrs.alloc(ctx.s.line), attrs.alloc(ctx.s.column));
v.mkAttrs(attrs); v.mkAttrs(attrs);
@ -889,7 +889,7 @@ void EvalState::mkSingleDerivedPathString(
of thunks allocated. */ of thunks allocated. */
Value * Expr::maybeThunk(EvalState & state, Env & env) Value * Expr::maybeThunk(EvalState & state, Env & env)
{ {
Value * v = state.mem.allocValue(); Value * v = state.ctx.mem.allocValue();
v->mkThunk(&env, *this); v->mkThunk(&env, *this);
state.stats.nrThunks++; state.stats.nrThunks++;
return v; return v;
@ -1056,7 +1056,7 @@ void ExprPath::eval(EvalState & state, Env & env, Value & v)
Env * ExprAttrs::buildInheritFromEnv(EvalState & state, Env & up) Env * ExprAttrs::buildInheritFromEnv(EvalState & state, Env & up)
{ {
Env & inheritEnv = state.mem.allocEnv(inheritFromExprs->size()); Env & inheritEnv = state.ctx.mem.allocEnv(inheritFromExprs->size());
inheritEnv.up = &up; inheritEnv.up = &up;
Displacement displ = 0; Displacement displ = 0;
@ -1068,13 +1068,13 @@ Env * ExprAttrs::buildInheritFromEnv(EvalState & state, Env & up)
void ExprAttrs::eval(EvalState & state, Env & env, Value & v) void ExprAttrs::eval(EvalState & state, Env & env, Value & v)
{ {
v.mkAttrs(state.buildBindings(attrs.size() + dynamicAttrs.size()).finish()); v.mkAttrs(state.ctx.buildBindings(attrs.size() + dynamicAttrs.size()).finish());
auto dynamicEnv = &env; auto dynamicEnv = &env;
if (recursive) { if (recursive) {
/* Create a new environment that contains the attributes in /* Create a new environment that contains the attributes in
this `rec'. */ this `rec'. */
Env & env2(state.mem.allocEnv(attrs.size())); Env & env2(state.ctx.mem.allocEnv(attrs.size()));
env2.up = &env; env2.up = &env;
dynamicEnv = &env2; dynamicEnv = &env2;
Env * inheritEnv = inheritFromExprs ? buildInheritFromEnv(state, env2) : nullptr; Env * inheritEnv = inheritFromExprs ? buildInheritFromEnv(state, env2) : nullptr;
@ -1089,7 +1089,7 @@ void ExprAttrs::eval(EvalState & state, Env & env, Value & v)
for (auto & i : attrs) { for (auto & i : attrs) {
Value * vAttr; Value * vAttr;
if (hasOverrides && i.second.kind != AttrDef::Kind::Inherited) { if (hasOverrides && i.second.kind != AttrDef::Kind::Inherited) {
vAttr = state.mem.allocValue(); vAttr = state.ctx.mem.allocValue();
vAttr->mkThunk(i.second.chooseByKind(&env2, &env, inheritEnv), *i.second.e); vAttr->mkThunk(i.second.chooseByKind(&env2, &env, inheritEnv), *i.second.e);
state.stats.nrThunks++; state.stats.nrThunks++;
} else } else
@ -1109,7 +1109,7 @@ void ExprAttrs::eval(EvalState & state, Env & env, Value & v)
if (hasOverrides) { if (hasOverrides) {
Value * vOverrides = (*v.attrs)[overrides->second.displ].value; Value * vOverrides = (*v.attrs)[overrides->second.displ].value;
state.forceAttrs(*vOverrides, vOverrides->determinePos(noPos), "while evaluating the `__overrides` attribute"); state.forceAttrs(*vOverrides, vOverrides->determinePos(noPos), "while evaluating the `__overrides` attribute");
Bindings * newBnds = state.mem.allocBindings(v.attrs->capacity() + vOverrides->attrs->size()); Bindings * newBnds = state.ctx.mem.allocBindings(v.attrs->capacity() + vOverrides->attrs->size());
for (auto & i : *v.attrs) for (auto & i : *v.attrs)
newBnds->push_back(i); newBnds->push_back(i);
for (auto & i : *vOverrides->attrs) { for (auto & i : *vOverrides->attrs) {
@ -1162,7 +1162,7 @@ void ExprLet::eval(EvalState & state, Env & env, Value & v)
{ {
/* Create a new environment that contains the attributes in this /* Create a new environment that contains the attributes in this
`let'. */ `let'. */
Env & env2(state.mem.allocEnv(attrs->attrs.size())); Env & env2(state.ctx.mem.allocEnv(attrs->attrs.size()));
env2.up = &env; env2.up = &env;
Env * inheritEnv = attrs->inheritFromExprs ? attrs->buildInheritFromEnv(state, env2) : nullptr; Env * inheritEnv = attrs->inheritFromExprs ? attrs->buildInheritFromEnv(state, env2) : nullptr;
@ -1196,7 +1196,7 @@ void ExprLet::eval(EvalState & state, Env & env, Value & v)
void ExprList::eval(EvalState & state, Env & env, Value & v) void ExprList::eval(EvalState & state, Env & env, Value & v)
{ {
v = state.mem.newList(elems.size()); v = state.ctx.mem.newList(elems.size());
for (auto [n, v2] : enumerate(v.listItems())) for (auto [n, v2] : enumerate(v.listItems()))
const_cast<Value * &>(v2) = elems[n]->maybeThunk(state, env); const_cast<Value * &>(v2) = elems[n]->maybeThunk(state, env);
} }
@ -1499,7 +1499,7 @@ void EvalState::callFunction(Value & fun, size_t nrArgs, Value * * args, Value &
{ {
vRes = vCur; vRes = vCur;
for (size_t i = 0; i < nrArgs; ++i) { for (size_t i = 0; i < nrArgs; ++i) {
auto fun2 = mem.allocValue(); auto fun2 = ctx.mem.allocValue();
*fun2 = vRes; *fun2 = vRes;
vRes.mkPrimOpApp(fun2, args[i]); vRes.mkPrimOpApp(fun2, args[i]);
} }
@ -1516,7 +1516,7 @@ void EvalState::callFunction(Value & fun, size_t nrArgs, Value * * args, Value &
auto size = auto size =
(!lambda.arg ? 0 : 1) + (!lambda.arg ? 0 : 1) +
(lambda.hasFormals() ? lambda.formals->formals.size() : 0); (lambda.hasFormals() ? lambda.formals->formals.size() : 0);
Env & env2(mem.allocEnv(size)); Env & env2(ctx.mem.allocEnv(size));
env2.up = vCur.lambda.env; env2.up = vCur.lambda.env;
Displacement displ = 0; Displacement displ = 0;
@ -1687,7 +1687,7 @@ void EvalState::callFunction(Value & fun, size_t nrArgs, Value * * args, Value &
/* 'vCur' may be allocated on the stack of the calling /* 'vCur' may be allocated on the stack of the calling
function, but for functors we may keep a reference, so function, but for functors we may keep a reference, so
heap-allocate a copy and use that instead. */ heap-allocate a copy and use that instead. */
Value * args2[] = {mem.allocValue(), args[0]}; Value * args2[] = {ctx.mem.allocValue(), args[0]};
*args2[0] = vCur; *args2[0] = vCur;
try { try {
callFunction(*functor->value, 2, args2, vCur, functor->pos); callFunction(*functor->value, 2, args2, vCur, functor->pos);
@ -1760,7 +1760,7 @@ void EvalState::autoCallFunction(Bindings & args, Value & fun, Value & res)
if (fun.type() == nAttrs) { if (fun.type() == nAttrs) {
auto found = fun.attrs->find(ctx.s.functor); auto found = fun.attrs->find(ctx.s.functor);
if (found != fun.attrs->end()) { if (found != fun.attrs->end()) {
Value * v = mem.allocValue(); Value * v = ctx.mem.allocValue();
callFunction(*found->value, fun, *v, pos); callFunction(*found->value, fun, *v, pos);
forceValue(*v, pos); forceValue(*v, pos);
return autoCallFunction(args, *v, res); return autoCallFunction(args, *v, res);
@ -1772,7 +1772,7 @@ void EvalState::autoCallFunction(Bindings & args, Value & fun, Value & res)
return; return;
} }
auto attrs = buildBindings(std::max(static_cast<uint32_t>(fun.lambda.fun->formals->formals.size()), args.size())); auto attrs = ctx.buildBindings(std::max(static_cast<uint32_t>(fun.lambda.fun->formals->formals.size()), args.size()));
if (fun.lambda.fun->formals->ellipsis) { if (fun.lambda.fun->formals->ellipsis) {
// If the formals have an ellipsis (eg the function accepts extra args) pass // If the formals have an ellipsis (eg the function accepts extra args) pass
@ -1797,13 +1797,13 @@ https://docs.lix.systems/manual/lix/stable/language/constructs.html#functions)",
} }
} }
callFunction(fun, mem.allocValue()->mkAttrs(attrs), res, pos); callFunction(fun, ctx.mem.allocValue()->mkAttrs(attrs), res, pos);
} }
void ExprWith::eval(EvalState & state, Env & env, Value & v) void ExprWith::eval(EvalState & state, Env & env, Value & v)
{ {
Env & env2(state.mem.allocEnv(1)); Env & env2(state.ctx.mem.allocEnv(1));
env2.up = &env; env2.up = &env;
env2.values[0] = attrs->maybeThunk(state, env); env2.values[0] = attrs->maybeThunk(state, env);
@ -1880,7 +1880,7 @@ void ExprOpUpdate::eval(EvalState & state, Env & env, Value & v)
if (v1.attrs->size() == 0) { v = v2; return; } if (v1.attrs->size() == 0) { v = v2; return; }
if (v2.attrs->size() == 0) { v = v1; return; } if (v2.attrs->size() == 0) { v = v1; return; }
auto attrs = state.buildBindings(v1.attrs->size() + v2.attrs->size()); auto attrs = state.ctx.buildBindings(v1.attrs->size() + v2.attrs->size());
/* Merge the sets, preferring values from the second set. Make /* Merge the sets, preferring values from the second set. Make
sure to keep the resulting vector in sorted order. */ sure to keep the resulting vector in sorted order. */
@ -1934,7 +1934,7 @@ void EvalState::concatLists(Value & v, size_t nrLists, Value * * lists, const Po
return; return;
} }
v = mem.newList(len); v = ctx.mem.newList(len);
auto out = v.listElems(); auto out = v.listElems();
for (size_t n = 0, pos = 0; n < nrLists; ++n) { for (size_t n = 0, pos = 0; n < nrLists; ++n) {
auto l = lists[n]->listSize(); auto l = lists[n]->listSize();

2
lix/libexpr/eval.hh
View file

@ -730,7 +730,7 @@ public:
BindingsBuilder buildBindings(size_t capacity) BindingsBuilder buildBindings(size_t capacity)
{ {
return mem.buildBindings(ctx.symbols, capacity); return ctx.mem.buildBindings(ctx.symbols, capacity);
} }
void mkPos(Value & v, PosIdx pos); void mkPos(Value & v, PosIdx pos);

14
lix/libexpr/flake/flake.cc
View file

@ -773,11 +773,11 @@ void callFlake(EvalState & state,
const LockedFlake & lockedFlake, const LockedFlake & lockedFlake,
Value & vRes) Value & vRes)
{ {
auto vLocks = state.mem.allocValue(); auto vLocks = state.ctx.mem.allocValue();
auto vRootSrc = state.mem.allocValue(); auto vRootSrc = state.ctx.mem.allocValue();
auto vRootSubdir = state.mem.allocValue(); auto vRootSubdir = state.ctx.mem.allocValue();
auto vTmp1 = state.mem.allocValue(); auto vTmp1 = state.ctx.mem.allocValue();
auto vTmp2 = state.mem.allocValue(); auto vTmp2 = state.ctx.mem.allocValue();
vLocks->mkString(lockedFlake.lockFile.to_string()); vLocks->mkString(lockedFlake.lockFile.to_string());
@ -792,7 +792,7 @@ void callFlake(EvalState & state,
vRootSubdir->mkString(lockedFlake.flake.lockedRef.subdir); vRootSubdir->mkString(lockedFlake.flake.lockedRef.subdir);
if (!state.caches.vCallFlake) { if (!state.caches.vCallFlake) {
state.caches.vCallFlake = allocRootValue(state.mem.allocValue()); state.caches.vCallFlake = allocRootValue(state.ctx.mem.allocValue());
state.eval(state.parseExprFromString( state.eval(state.parseExprFromString(
#include "call-flake.nix.gen.hh" #include "call-flake.nix.gen.hh"
, CanonPath::root), **state.caches.vCallFlake); , CanonPath::root), **state.caches.vCallFlake);
@ -830,7 +830,7 @@ void prim_parseFlakeRef(
std::string flakeRefS(state.forceStringNoCtx(*args[0], pos, std::string flakeRefS(state.forceStringNoCtx(*args[0], pos,
"while evaluating the argument passed to builtins.parseFlakeRef")); "while evaluating the argument passed to builtins.parseFlakeRef"));
auto attrs = parseFlakeRef(flakeRefS, {}, true).toAttrs(); auto attrs = parseFlakeRef(flakeRefS, {}, true).toAttrs();
auto binds = state.buildBindings(attrs.size()); auto binds = state.ctx.buildBindings(attrs.size());
for (const auto & [key, value] : attrs) { for (const auto & [key, value] : attrs) {
auto s = state.ctx.symbols.create(key); auto s = state.ctx.symbols.create(key);
auto & vv = binds.alloc(s); auto & vv = binds.alloc(s);

2
lix/libexpr/get-drvs.cc
View file

@ -334,7 +334,7 @@ bool DrvInfo::queryMetaBool(EvalState & state, const std::string & name, bool de
void DrvInfo::setMeta(EvalState & state, const std::string & name, Value * v) void DrvInfo::setMeta(EvalState & state, const std::string & name, Value * v)
{ {
getMeta(state); getMeta(state);
auto attrs = state.buildBindings(1 + (meta ? meta->size() : 0)); auto attrs = state.ctx.buildBindings(1 + (meta ? meta->size() : 0));
auto sym = state.ctx.symbols.create(name); auto sym = state.ctx.symbols.create(name);
if (meta) if (meta)
for (auto i : *meta) for (auto i : *meta)

6
lix/libexpr/json-to-value.cc
View file

@ -28,7 +28,7 @@ class JSONSax : nlohmann::json_sax<json> {
Value & value(EvalState & state) Value & value(EvalState & state)
{ {
if (!v) if (!v)
v = allocRootValue(state.mem.allocValue()); v = allocRootValue(state.ctx.mem.allocValue());
return **v; return **v;
} }
virtual ~JSONState() {} virtual ~JSONState() {}
@ -40,7 +40,7 @@ class JSONSax : nlohmann::json_sax<json> {
ValueMap attrs; ValueMap attrs;
std::unique_ptr<JSONState> resolve(EvalState & state) override std::unique_ptr<JSONState> resolve(EvalState & state) override
{ {
auto attrs2 = state.buildBindings(attrs.size()); auto attrs2 = state.ctx.buildBindings(attrs.size());
for (auto & i : attrs) for (auto & i : attrs)
attrs2.insert(i.first, i.second); attrs2.insert(i.first, i.second);
parent->value(state).mkAttrs(attrs2.alreadySorted()); parent->value(state).mkAttrs(attrs2.alreadySorted());
@ -59,7 +59,7 @@ class JSONSax : nlohmann::json_sax<json> {
std::unique_ptr<JSONState> resolve(EvalState & state) override std::unique_ptr<JSONState> resolve(EvalState & state) override
{ {
Value & v = parent->value(state); Value & v = parent->value(state);
v = state.mem.newList(values.size()); v = state.ctx.mem.newList(values.size());
for (size_t n = 0; n < values.size(); ++n) { for (size_t n = 0; n < values.size(); ++n) {
v.listElems()[n] = values[n]; v.listElems()[n] = values[n];
} }

112
lix/libexpr/primops.cc
View file

@ -190,24 +190,24 @@ static void import(EvalState & state, const PosIdx pos, Value & vPath, Value * v
if (auto storePath = isValidDerivationInStore()) { if (auto storePath = isValidDerivationInStore()) {
Derivation drv = state.ctx.store->readDerivation(*storePath); Derivation drv = state.ctx.store->readDerivation(*storePath);
auto attrs = state.buildBindings(3 + drv.outputs.size()); auto attrs = state.ctx.buildBindings(3 + drv.outputs.size());
attrs.alloc(state.ctx.s.drvPath).mkString(path2, { attrs.alloc(state.ctx.s.drvPath).mkString(path2, {
NixStringContextElem::DrvDeep { .drvPath = *storePath }, NixStringContextElem::DrvDeep { .drvPath = *storePath },
}); });
attrs.alloc(state.ctx.s.name).mkString(drv.env["name"]); attrs.alloc(state.ctx.s.name).mkString(drv.env["name"]);
auto & outputsVal = attrs.alloc(state.ctx.s.outputs); auto & outputsVal = attrs.alloc(state.ctx.s.outputs);
outputsVal = state.mem.newList(drv.outputs.size()); outputsVal = state.ctx.mem.newList(drv.outputs.size());
for (const auto & [i, o] : enumerate(drv.outputs)) { for (const auto & [i, o] : enumerate(drv.outputs)) {
mkOutputString(state, attrs, *storePath, o); mkOutputString(state, attrs, *storePath, o);
(outputsVal.listElems()[i] = state.mem.allocValue())->mkString(o.first); (outputsVal.listElems()[i] = state.ctx.mem.allocValue())->mkString(o.first);
} }
auto w = state.mem.allocValue(); auto w = state.ctx.mem.allocValue();
w->mkAttrs(attrs); w->mkAttrs(attrs);
if (!state.caches.vImportedDrvToDerivation) { if (!state.caches.vImportedDrvToDerivation) {
state.caches.vImportedDrvToDerivation = allocRootValue(state.mem.allocValue()); state.caches.vImportedDrvToDerivation = allocRootValue(state.ctx.mem.allocValue());
state.eval(state.parseExprFromString( state.eval(state.parseExprFromString(
#include "imported-drv-to-derivation.nix.gen.hh" #include "imported-drv-to-derivation.nix.gen.hh"
, CanonPath::root), **state.caches.vImportedDrvToDerivation); , CanonPath::root), **state.caches.vImportedDrvToDerivation);
@ -234,7 +234,7 @@ static void import(EvalState & state, const PosIdx pos, Value & vPath, Value * v
else { else {
state.forceAttrs(*vScope, pos, "while evaluating the first argument passed to builtins.scopedImport"); state.forceAttrs(*vScope, pos, "while evaluating the first argument passed to builtins.scopedImport");
Env * env = &state.mem.allocEnv(vScope->attrs->size()); Env * env = &state.ctx.mem.allocEnv(vScope->attrs->size());
env->up = &state.builtins.env; env->up = &state.builtins.env;
auto staticEnv = std::make_shared<StaticEnv>( auto staticEnv = std::make_shared<StaticEnv>(
@ -563,7 +563,7 @@ static void prim_genericClosure(EvalState & state, const PosIdx pos, Value * * a
} }
/* Create the result list. */ /* Create the result list. */
v = state.mem.newList(res.size()); v = state.ctx.mem.newList(res.size());
unsigned int n = 0; unsigned int n = 0;
for (auto & i : res) for (auto & i : res)
v.listElems()[n++] = i; v.listElems()[n++] = i;
@ -640,7 +640,7 @@ static void prim_floor(EvalState & state, const PosIdx pos, Value * * args, Valu
* else => {success=false; value=false;} */ * else => {success=false; value=false;} */
static void prim_tryEval(EvalState & state, const PosIdx pos, Value * * args, Value & v) static void prim_tryEval(EvalState & state, const PosIdx pos, Value * * args, Value & v)
{ {
auto attrs = state.buildBindings(2); auto attrs = state.ctx.buildBindings(2);
std::optional<MaintainCount<int>> trylevel; std::optional<MaintainCount<int>> trylevel;
std::unique_ptr<DebugState> savedDebug; std::unique_ptr<DebugState> savedDebug;
@ -1114,7 +1114,7 @@ drvName, Bindings * attrs, Value & v)
drvHashes.lock()->insert_or_assign(drvPath, h); drvHashes.lock()->insert_or_assign(drvPath, h);
} }
auto result = state.buildBindings(1 + drv.outputs.size()); auto result = state.ctx.buildBindings(1 + drv.outputs.size());
result.alloc(state.ctx.s.drvPath).mkString(drvPathS, { result.alloc(state.ctx.s.drvPath).mkString(drvPathS, {
NixStringContextElem::DrvDeep { .drvPath = drvPath }, NixStringContextElem::DrvDeep { .drvPath = drvPath },
}); });
@ -1365,7 +1365,7 @@ static void prim_readDir(EvalState & state, const PosIdx pos, Value * * args, Va
// This is similar to `getFileType` but is optimized to reduce system calls // This is similar to `getFileType` but is optimized to reduce system calls
// on many systems. // on many systems.
auto entries = path.readDirectory(); auto entries = path.readDirectory();
auto attrs = state.buildBindings(entries.size()); auto attrs = state.ctx.buildBindings(entries.size());
// If we hit unknown directory entry types we may need to fallback to // If we hit unknown directory entry types we may need to fallback to
// using `getFileType` on some systems. // using `getFileType` on some systems.
@ -1379,7 +1379,7 @@ static void prim_readDir(EvalState & state, const PosIdx pos, Value * * args, Va
// Some filesystems or operating systems may not be able to return // Some filesystems or operating systems may not be able to return
// detailed node info quickly in this case we produce a thunk to // detailed node info quickly in this case we produce a thunk to
// query the file type lazily. // query the file type lazily.
auto epath = state.mem.allocValue(); auto epath = state.ctx.mem.allocValue();
epath->mkPath(path + name); epath->mkPath(path + name);
if (!readFileType) if (!readFileType)
readFileType = &state.builtins.get("readFileType"); readFileType = &state.builtins.get("readFileType");
@ -1623,11 +1623,11 @@ static void prim_attrNames(EvalState & state, const PosIdx pos, Value * * args,
{ {
state.forceAttrs(*args[0], pos, "while evaluating the argument passed to builtins.attrNames"); state.forceAttrs(*args[0], pos, "while evaluating the argument passed to builtins.attrNames");
v = state.mem.newList(args[0]->attrs->size()); v = state.ctx.mem.newList(args[0]->attrs->size());
size_t n = 0; size_t n = 0;
for (auto & i : *args[0]->attrs) for (auto & i : *args[0]->attrs)
(v.listElems()[n++] = state.mem.allocValue())->mkString(state.ctx.symbols[i.name]); (v.listElems()[n++] = state.ctx.mem.allocValue())->mkString(state.ctx.symbols[i.name]);
std::sort(v.listElems(), v.listElems() + n, std::sort(v.listElems(), v.listElems() + n,
[](Value * v1, Value * v2) { return strcmp(v1->string.s, v2->string.s) < 0; }); [](Value * v1, Value * v2) { return strcmp(v1->string.s, v2->string.s) < 0; });
@ -1639,7 +1639,7 @@ static void prim_attrValues(EvalState & state, const PosIdx pos, Value * * args,
{ {
state.forceAttrs(*args[0], pos, "while evaluating the argument passed to builtins.attrValues"); state.forceAttrs(*args[0], pos, "while evaluating the argument passed to builtins.attrValues");
v = state.mem.newList(args[0]->attrs->size()); v = state.ctx.mem.newList(args[0]->attrs->size());
// FIXME: this is incredibly evil, *why* // FIXME: this is incredibly evil, *why*
// NOLINTBEGIN(cppcoreguidelines-pro-type-cstyle-cast) // NOLINTBEGIN(cppcoreguidelines-pro-type-cstyle-cast)
@ -1730,7 +1730,7 @@ static struct LazyPosAcessors {
void operator()(EvalState & state, const PosIdx pos, Value & line, Value & column) void operator()(EvalState & state, const PosIdx pos, Value & line, Value & column)
{ {
Value * posV = state.mem.allocValue(); Value * posV = state.ctx.mem.allocValue();
posV->mkInt(pos.id); posV->mkInt(pos.id);
line.mkApp(&lineOfPos, posV); line.mkApp(&lineOfPos, posV);
column.mkApp(&columnOfPos, posV); column.mkApp(&columnOfPos, posV);
@ -1777,7 +1777,7 @@ static void prim_removeAttrs(EvalState & state, const PosIdx pos, Value * * args
/* Copy all attributes not in that set. Note that we don't need /* 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 to sort v.attrs because it's a subset of an already sorted
vector. */ vector. */
auto attrs = state.buildBindings(args[0]->attrs->size()); auto attrs = state.ctx.buildBindings(args[0]->attrs->size());
std::set_difference( std::set_difference(
args[0]->attrs->begin(), args[0]->attrs->end(), args[0]->attrs->begin(), args[0]->attrs->end(),
names.begin(), names.end(), names.begin(), names.end(),
@ -1794,7 +1794,7 @@ static void prim_listToAttrs(EvalState & state, const PosIdx pos, Value * * args
{ {
state.forceList(*args[0], pos, "while evaluating the argument passed to builtins.listToAttrs"); state.forceList(*args[0], pos, "while evaluating the argument passed to builtins.listToAttrs");
auto attrs = state.buildBindings(args[0]->listSize()); auto attrs = state.ctx.buildBindings(args[0]->listSize());
std::set<Symbol> seen; std::set<Symbol> seen;
@ -1823,7 +1823,7 @@ static void prim_intersectAttrs(EvalState & state, const PosIdx pos, Value * * a
Bindings &left = *args[0]->attrs; Bindings &left = *args[0]->attrs;
Bindings &right = *args[1]->attrs; Bindings &right = *args[1]->attrs;
auto attrs = state.buildBindings(std::min(left.size(), right.size())); auto attrs = state.ctx.buildBindings(std::min(left.size(), right.size()));
// The current implementation has good asymptotic complexity and is reasonably // The current implementation has good asymptotic complexity and is reasonably
// simple. Further optimization may be possible, but does not seem productive, // simple. Further optimization may be possible, but does not seem productive,
@ -1896,7 +1896,7 @@ static void prim_catAttrs(EvalState & state, const PosIdx pos, Value * * args, V
res[found++] = i->value; res[found++] = i->value;
} }
v = state.mem.newList(found); v = state.ctx.mem.newList(found);
for (unsigned int n = 0; n < found; ++n) for (unsigned int n = 0; n < found; ++n)
v.listElems()[n] = res[n]; v.listElems()[n] = res[n];
} }
@ -1916,7 +1916,7 @@ static void prim_functionArgs(EvalState & state, const PosIdx pos, Value * * arg
return; return;
} }
auto attrs = state.buildBindings(args[0]->lambda.fun->formals->formals.size()); auto attrs = state.ctx.buildBindings(args[0]->lambda.fun->formals->formals.size());
for (auto & i : args[0]->lambda.fun->formals->formals) for (auto & i : args[0]->lambda.fun->formals->formals)
// !!! should optimise booleans (allocate only once) // !!! should optimise booleans (allocate only once)
attrs.alloc(i.name, i.pos).mkBool(i.def != nullptr); attrs.alloc(i.name, i.pos).mkBool(i.def != nullptr);
@ -1928,11 +1928,11 @@ static void prim_mapAttrs(EvalState & state, const PosIdx pos, Value * * args, V
{ {
state.forceAttrs(*args[1], pos, "while evaluating the second argument passed to builtins.mapAttrs"); state.forceAttrs(*args[1], pos, "while evaluating the second argument passed to builtins.mapAttrs");
auto attrs = state.buildBindings(args[1]->attrs->size()); auto attrs = state.ctx.buildBindings(args[1]->attrs->size());
for (auto & i : *args[1]->attrs) { for (auto & i : *args[1]->attrs) {
Value * vName = state.mem.allocValue(); Value * vName = state.ctx.mem.allocValue();
Value * vFun2 = state.mem.allocValue(); Value * vFun2 = state.ctx.mem.allocValue();
vName->mkString(state.ctx.symbols[i.name]); vName->mkString(state.ctx.symbols[i.name]);
vFun2->mkApp(args[0], vName); vFun2->mkApp(args[0], vName);
attrs.alloc(i.name).mkApp(vFun2, i.value); attrs.alloc(i.name).mkApp(vFun2, i.value);
@ -1964,10 +1964,10 @@ static void prim_zipAttrsWith(EvalState & state, const PosIdx pos, Value * * arg
attrsSeen[attr.name].first++; attrsSeen[attr.name].first++;
} }
auto attrs = state.buildBindings(attrsSeen.size()); auto attrs = state.ctx.buildBindings(attrsSeen.size());
for (auto & [sym, elem] : attrsSeen) { for (auto & [sym, elem] : attrsSeen) {
auto & list = attrs.alloc(sym); auto & list = attrs.alloc(sym);
list = state.mem.newList(elem.first); list = state.ctx.mem.newList(elem.first);
elem.second = list.listElems(); elem.second = list.listElems();
} }
v.mkAttrs(attrs.alreadySorted()); v.mkAttrs(attrs.alreadySorted());
@ -1979,11 +1979,11 @@ static void prim_zipAttrsWith(EvalState & state, const PosIdx pos, Value * * arg
} }
for (auto & attr : *v.attrs) { for (auto & attr : *v.attrs) {
auto name = state.mem.allocValue(); auto name = state.ctx.mem.allocValue();
name->mkString(state.ctx.symbols[attr.name]); name->mkString(state.ctx.symbols[attr.name]);
auto call1 = state.mem.allocValue(); auto call1 = state.ctx.mem.allocValue();
call1->mkApp(args[0], name); call1->mkApp(args[0], name);
auto call2 = state.mem.allocValue(); auto call2 = state.ctx.mem.allocValue();
call2->mkApp(call1, attr.value); call2->mkApp(call1, attr.value);
attr.value = call2; attr.value = call2;
} }
@ -2036,7 +2036,7 @@ static void prim_tail(EvalState & state, const PosIdx pos, Value * * args, Value
if (args[0]->listSize() == 0) if (args[0]->listSize() == 0)
state.ctx.errors.make<EvalError>("'tail' called on an empty list").atPos(pos).debugThrow(); state.ctx.errors.make<EvalError>("'tail' called on an empty list").atPos(pos).debugThrow();
v = state.mem.newList(args[0]->listSize() - 1); v = state.ctx.mem.newList(args[0]->listSize() - 1);
for (unsigned int n = 0; n < v.listSize(); ++n) for (unsigned int n = 0; n < v.listSize(); ++n)
v.listElems()[n] = args[0]->listElems()[n + 1]; v.listElems()[n] = args[0]->listElems()[n + 1];
} }
@ -2053,9 +2053,9 @@ static void prim_map(EvalState & state, const PosIdx pos, Value * * args, Value
state.forceFunction(*args[0], pos, "while evaluating the first argument passed to builtins.map"); state.forceFunction(*args[0], pos, "while evaluating the first argument passed to builtins.map");
v = state.mem.newList(args[1]->listSize()); v = state.ctx.mem.newList(args[1]->listSize());
for (unsigned int n = 0; n < v.listSize(); ++n) for (unsigned int n = 0; n < v.listSize(); ++n)
(v.listElems()[n] = state.mem.allocValue())->mkApp( (v.listElems()[n] = state.ctx.mem.allocValue())->mkApp(
args[0], args[1]->listElems()[n]); args[0], args[1]->listElems()[n]);
} }
@ -2089,7 +2089,7 @@ static void prim_filter(EvalState & state, const PosIdx pos, Value * * args, Val
if (same) if (same)
v = *args[1]; v = *args[1];
else { else {
v = state.mem.newList(k); v = state.ctx.mem.newList(k);
for (unsigned int n = 0; n < k; ++n) v.listElems()[n] = vs[n]; for (unsigned int n = 0; n < k; ++n) v.listElems()[n] = vs[n];
} }
} }
@ -2133,7 +2133,7 @@ static void prim_foldlStrict(EvalState & state, const PosIdx pos, Value * * args
for (auto [n, elem] : enumerate(args[2]->listItems())) { for (auto [n, elem] : enumerate(args[2]->listItems())) {
Value * vs []{vCur, elem}; Value * vs []{vCur, elem};
vCur = n == args[2]->listSize() - 1 ? &v : state.mem.allocValue(); vCur = n == args[2]->listSize() - 1 ? &v : state.ctx.mem.allocValue();
state.callFunction(*args[0], 2, vs, *vCur, pos); state.callFunction(*args[0], 2, vs, *vCur, pos);
} }
state.forceValue(v, pos); state.forceValue(v, pos);
@ -2189,11 +2189,11 @@ static void prim_genList(EvalState & state, const PosIdx pos, Value * * args, Va
// as evaluating map without accessing any values makes little sense. // as evaluating map without accessing any values makes little sense.
state.forceFunction(*args[0], noPos, "while evaluating the first argument passed to builtins.genList"); state.forceFunction(*args[0], noPos, "while evaluating the first argument passed to builtins.genList");
v = state.mem.newList(len); v = state.ctx.mem.newList(len);
for (size_t n = 0; n < len; ++n) { for (size_t n = 0; n < len; ++n) {
auto arg = state.mem.allocValue(); auto arg = state.ctx.mem.allocValue();
arg->mkInt(n); arg->mkInt(n);
(v.listElems()[n] = state.mem.allocValue())->mkApp(args[0], arg); (v.listElems()[n] = state.ctx.mem.allocValue())->mkApp(args[0], arg);
} }
} }
@ -2212,7 +2212,7 @@ static void prim_sort(EvalState & state, const PosIdx pos, Value * * args, Value
state.forceFunction(*args[0], pos, "while evaluating the first argument passed to builtins.sort"); state.forceFunction(*args[0], pos, "while evaluating the first argument passed to builtins.sort");
v = state.mem.newList(len); v = state.ctx.mem.newList(len);
for (unsigned int n = 0; n < len; ++n) { for (unsigned int n = 0; n < len; ++n) {
state.forceValue(*args[1]->listElems()[n], pos); state.forceValue(*args[1]->listElems()[n], pos);
v.listElems()[n] = args[1]->listElems()[n]; v.listElems()[n] = args[1]->listElems()[n];
@ -2261,17 +2261,17 @@ static void prim_partition(EvalState & state, const PosIdx pos, Value * * args,
wrong.push_back(vElem); wrong.push_back(vElem);
} }
auto attrs = state.buildBindings(2); auto attrs = state.ctx.buildBindings(2);
auto & vRight = attrs.alloc(state.ctx.s.right); auto & vRight = attrs.alloc(state.ctx.s.right);
auto rsize = right.size(); auto rsize = right.size();
vRight = state.mem.newList(rsize); vRight = state.ctx.mem.newList(rsize);
if (rsize) if (rsize)
memcpy(vRight.listElems(), right.data(), sizeof(Value *) * rsize); memcpy(vRight.listElems(), right.data(), sizeof(Value *) * rsize);
auto & vWrong = attrs.alloc(state.ctx.s.wrong); auto & vWrong = attrs.alloc(state.ctx.s.wrong);
auto wsize = wrong.size(); auto wsize = wrong.size();
vWrong = state.mem.newList(wsize); vWrong = state.ctx.mem.newList(wsize);
if (wsize) if (wsize)
memcpy(vWrong.listElems(), wrong.data(), sizeof(Value *) * wsize); memcpy(vWrong.listElems(), wrong.data(), sizeof(Value *) * wsize);
@ -2294,12 +2294,12 @@ static void prim_groupBy(EvalState & state, const PosIdx pos, Value * * args, Va
vector->second.push_back(vElem); vector->second.push_back(vElem);
} }
auto attrs2 = state.buildBindings(attrs.size()); auto attrs2 = state.ctx.buildBindings(attrs.size());
for (auto & i : attrs) { for (auto & i : attrs) {
auto & list = attrs2.alloc(i.first); auto & list = attrs2.alloc(i.first);
auto size = i.second.size(); auto size = i.second.size();
list = state.mem.newList(size); list = state.ctx.mem.newList(size);
memcpy(list.listElems(), i.second.data(), sizeof(Value *) * size); memcpy(list.listElems(), i.second.data(), sizeof(Value *) * size);
} }
@ -2323,7 +2323,7 @@ static void prim_concatMap(EvalState & state, const PosIdx pos, Value * * args,
len += lists[n].listSize(); len += lists[n].listSize();
} }
v = state.mem.newList(len); v = state.ctx.mem.newList(len);
auto out = v.listElems(); auto out = v.listElems();
for (unsigned int n = 0, pos = 0; n < nrLists; ++n) { for (unsigned int n = 0, pos = 0; n < nrLists; ++n) {
auto l = lists[n].listSize(); auto l = lists[n].listSize();
@ -2575,12 +2575,12 @@ void prim_match(EvalState & state, const PosIdx pos, Value * * args, Value & v)
// the first match is the whole string // the first match is the whole string
const size_t len = match.size() - 1; const size_t len = match.size() - 1;
v = state.mem.newList(len); v = state.ctx.mem.newList(len);
for (size_t i = 0; i < len; ++i) { for (size_t i = 0; i < len; ++i) {
if (!match[i+1].matched) if (!match[i+1].matched)
(v.listElems()[i] = state.mem.allocValue())->mkNull(); (v.listElems()[i] = state.ctx.mem.allocValue())->mkNull();
else else
(v.listElems()[i] = state.mem.allocValue())->mkString(match[i + 1].str()); (v.listElems()[i] = state.ctx.mem.allocValue())->mkString(match[i + 1].str());
} }
} catch (std::regex_error & e) { } catch (std::regex_error & e) {
@ -2614,7 +2614,7 @@ void prim_split(EvalState & state, const PosIdx pos, Value * * args, Value & v)
// Any matches results are surrounded by non-matching results. // Any matches results are surrounded by non-matching results.
const size_t len = std::distance(begin, end); const size_t len = std::distance(begin, end);
v = state.mem.newList(2 * len + 1); v = state.ctx.mem.newList(2 * len + 1);
size_t idx = 0; size_t idx = 0;
if (len == 0) { if (len == 0) {
@ -2627,24 +2627,24 @@ void prim_split(EvalState & state, const PosIdx pos, Value * * args, Value & v)
auto match = *i; auto match = *i;
// Add a string for non-matched characters. // Add a string for non-matched characters.
(v.listElems()[idx++] = state.mem.allocValue())->mkString(match.prefix().str()); (v.listElems()[idx++] = state.ctx.mem.allocValue())->mkString(match.prefix().str());
// Add a list for matched substrings. // Add a list for matched substrings.
const size_t slen = match.size() - 1; const size_t slen = match.size() - 1;
auto elem = v.listElems()[idx++] = state.mem.allocValue(); auto elem = v.listElems()[idx++] = state.ctx.mem.allocValue();
// Start at 1, beacause the first match is the whole string. // Start at 1, beacause the first match is the whole string.
*elem = state.mem.newList(slen); *elem = state.ctx.mem.newList(slen);
for (size_t si = 0; si < slen; ++si) { for (size_t si = 0; si < slen; ++si) {
if (!match[si + 1].matched) if (!match[si + 1].matched)
(elem->listElems()[si] = state.mem.allocValue())->mkNull(); (elem->listElems()[si] = state.ctx.mem.allocValue())->mkNull();
else else
(elem->listElems()[si] = state.mem.allocValue())->mkString(match[si + 1].str()); (elem->listElems()[si] = state.ctx.mem.allocValue())->mkString(match[si + 1].str());
} }
// Add a string for non-matched suffix characters. // Add a string for non-matched suffix characters.
if (idx == 2 * len) if (idx == 2 * len)
(v.listElems()[idx++] = state.mem.allocValue())->mkString(match.suffix().str()); (v.listElems()[idx++] = state.ctx.mem.allocValue())->mkString(match.suffix().str());
} }
assert(idx == 2 * len + 1); assert(idx == 2 * len + 1);
@ -2749,7 +2749,7 @@ static void prim_parseDrvName(EvalState & state, const PosIdx pos, Value * * arg
{ {
auto name = state.forceStringNoCtx(*args[0], pos, "while evaluating the first argument passed to builtins.parseDrvName"); auto name = state.forceStringNoCtx(*args[0], pos, "while evaluating the first argument passed to builtins.parseDrvName");
DrvName parsed(name); DrvName parsed(name);
auto attrs = state.buildBindings(2); auto attrs = state.ctx.buildBindings(2);
attrs.alloc(state.ctx.s.name).mkString(parsed.name); attrs.alloc(state.ctx.s.name).mkString(parsed.name);
attrs.alloc("version").mkString(parsed.version); attrs.alloc("version").mkString(parsed.version);
v.mkAttrs(attrs); v.mkAttrs(attrs);
@ -2774,9 +2774,9 @@ static void prim_splitVersion(EvalState & state, const PosIdx pos, Value * * arg
break; break;
components.emplace_back(component); components.emplace_back(component);
} }
v = state.mem.newList(components.size()); v = state.ctx.mem.newList(components.size());
for (const auto & [n, component] : enumerate(components)) for (const auto & [n, component] : enumerate(components))
(v.listElems()[n] = state.mem.allocValue())->mkString(std::move(component)); (v.listElems()[n] = state.ctx.mem.allocValue())->mkString(std::move(component));
} }

8
lix/libexpr/primops/context.cc
View file

@ -138,20 +138,20 @@ void prim_getContext(EvalState & state, const PosIdx pos, Value * * args, Value
}, ((NixStringContextElem &&) i).raw); }, ((NixStringContextElem &&) i).raw);
} }
auto attrs = state.buildBindings(contextInfos.size()); auto attrs = state.ctx.buildBindings(contextInfos.size());
auto sAllOutputs = state.ctx.symbols.create("allOutputs"); auto sAllOutputs = state.ctx.symbols.create("allOutputs");
for (const auto & info : contextInfos) { for (const auto & info : contextInfos) {
auto infoAttrs = state.buildBindings(3); auto infoAttrs = state.ctx.buildBindings(3);
if (info.second.path) if (info.second.path)
infoAttrs.alloc(state.ctx.s.path).mkBool(true); infoAttrs.alloc(state.ctx.s.path).mkBool(true);
if (info.second.allOutputs) if (info.second.allOutputs)
infoAttrs.alloc(sAllOutputs).mkBool(true); infoAttrs.alloc(sAllOutputs).mkBool(true);
if (!info.second.outputs.empty()) { if (!info.second.outputs.empty()) {
auto & outputsVal = infoAttrs.alloc(state.ctx.s.outputs); auto & outputsVal = infoAttrs.alloc(state.ctx.s.outputs);
outputsVal = state.mem.newList(info.second.outputs.size()); outputsVal = state.ctx.mem.newList(info.second.outputs.size());
for (const auto & [i, output] : enumerate(info.second.outputs)) for (const auto & [i, output] : enumerate(info.second.outputs))
(outputsVal.listElems()[i] = state.mem.allocValue())->mkString(output); (outputsVal.listElems()[i] = state.ctx.mem.allocValue())->mkString(output);
} }
attrs.alloc(state.ctx.store->printStorePath(info.first)).mkAttrs(infoAttrs); attrs.alloc(state.ctx.store->printStorePath(info.first)).mkAttrs(infoAttrs);
} }

2
lix/libexpr/primops/fetchMercurial.cc
View file

@ -67,7 +67,7 @@ static void prim_fetchMercurial(EvalState & state, const PosIdx pos, Value * * a
// FIXME: use name // FIXME: use name
auto [tree, input2] = input.fetch(state.ctx.store); auto [tree, input2] = input.fetch(state.ctx.store);
auto attrs2 = state.buildBindings(8); auto attrs2 = state.ctx.buildBindings(8);
state.paths.mkStorePathString(tree.storePath, attrs2.alloc(state.ctx.s.outPath)); state.paths.mkStorePathString(tree.storePath, attrs2.alloc(state.ctx.s.outPath));
if (input2.getRef()) if (input2.getRef())
attrs2.alloc("branch").mkString(*input2.getRef()); attrs2.alloc("branch").mkString(*input2.getRef());

8
lix/libexpr/primops/fromTOML.cc
View file

@ -26,7 +26,7 @@ void prim_fromTOML(EvalState & state, const PosIdx pos, Value * * args, Value &
size_t size = 0; size_t size = 0;
for (auto & i : table) { (void) i; size++; } for (auto & i : table) { (void) i; size++; }
auto attrs = state.buildBindings(size); auto attrs = state.ctx.buildBindings(size);
for(auto & elem : table) for(auto & elem : table)
visit(attrs.alloc(elem.first), elem.second); visit(attrs.alloc(elem.first), elem.second);
@ -39,9 +39,9 @@ void prim_fromTOML(EvalState & state, const PosIdx pos, Value * * args, Value &
auto array = toml::get<std::vector<toml::value>>(t); auto array = toml::get<std::vector<toml::value>>(t);
size_t size = array.size(); size_t size = array.size();
v = state.mem.newList(size); v = state.ctx.mem.newList(size);
for (size_t i = 0; i < size; ++i) for (size_t i = 0; i < size; ++i)
visit(*(v.listElems()[i] = state.mem.allocValue()), array[i]); visit(*(v.listElems()[i] = state.ctx.mem.allocValue()), array[i]);
} }
break;; break;;
case toml::value_t::boolean: case toml::value_t::boolean:
@ -62,7 +62,7 @@ void prim_fromTOML(EvalState & state, const PosIdx pos, Value * * args, Value &
case toml::value_t::local_time: case toml::value_t::local_time:
{ {
if (experimentalFeatureSettings.isEnabled(Xp::ParseTomlTimestamps)) { if (experimentalFeatureSettings.isEnabled(Xp::ParseTomlTimestamps)) {
auto attrs = state.buildBindings(2); auto attrs = state.ctx.buildBindings(2);
attrs.alloc("_type").mkString("timestamp"); attrs.alloc("_type").mkString("timestamp");
std::ostringstream s; std::ostringstream s;
s << t; s << t;