aboutsummaryrefslogtreecommitdiff
path: root/src/normalise.cc
diff options
context:
space:
mode:
Diffstat (limited to 'src/normalise.cc')
-rw-r--r--src/normalise.cc181
1 files changed, 91 insertions, 90 deletions
diff --git a/src/normalise.cc b/src/normalise.cc
index 39867bfe5..994a07df1 100644
--- a/src/normalise.cc
+++ b/src/normalise.cc
@@ -26,40 +26,41 @@ static FSId useSuccessor(const FSId & id)
}
-Strings pathsFromOutputs(const DeriveOutputs & ps)
+Strings pathsFromOutputs(const DerivationOutputs & ps)
{
Strings ss;
- for (DeriveOutputs::const_iterator i = ps.begin();
+ for (DerivationOutputs::const_iterator i = ps.begin();
i != ps.end(); i++)
ss.push_back(i->first);
return ss;
}
-FSId normaliseFState(FSId id, FSIdSet pending)
+FSId normaliseNixExpr(FSId id, FSIdSet pending)
{
- Nest nest(lvlTalkative, format("normalising fstate %1%") % (string) id);
+ Nest nest(lvlTalkative,
+ format("normalising nix expression %1%") % (string) id);
/* Try to substitute $id$ by any known successors in order to
speed up the rewrite process. */
id = useSuccessor(id);
- /* Get the fstate expression. */
- FState fs = parseFState(termFromId(id));
+ /* Get the Nix expression. */
+ NixExpr ne = parseNixExpr(termFromId(id));
- /* If this is a normal form (i.e., a slice) we are done. */
- if (fs.type == FState::fsSlice) return id;
- if (fs.type != FState::fsDerive) abort();
+ /* If this is a normal form (i.e., a closure) we are done. */
+ if (ne.type == NixExpr::neClosure) return id;
+ if (ne.type != NixExpr::neDerivation) abort();
- /* Otherwise, it's a derive expression, and we have to build it to
+ /* Otherwise, it's a derivation expression, and we have to build it to
determine its normal form. */
/* Some variables. */
- /* Input paths, with their slice elements. */
- SliceElems inSlices;
+ /* Input paths, with their closure elements. */
+ ClosureElems inClosures;
/* Referencable paths (i.e., input and output paths). */
StringSet allPaths;
@@ -68,13 +69,13 @@ FSId normaliseFState(FSId id, FSIdSet pending)
Environment env;
/* The result. */
- FState nfFS;
- nfFS.type = FState::fsSlice;
+ NixExpr nf;
+ nf.type = NixExpr::neClosure;
/* Parse the outputs. */
- for (DeriveOutputs::iterator i = fs.derive.outputs.begin();
- i != fs.derive.outputs.end(); i++)
+ for (DerivationOutputs::iterator i = ne.derivation.outputs.begin();
+ i != ne.derivation.outputs.end(); i++)
{
debug(format("building %1% in `%2%'") % (string) i->second % i->first);
allPaths.insert(i->first);
@@ -82,7 +83,7 @@ FSId normaliseFState(FSId id, FSIdSet pending)
/* Obtain locks on all output paths. The locks are automatically
released when we exit this function or Nix crashes. */
- PathLocks outputLocks(pathsFromOutputs(fs.derive.outputs));
+ PathLocks outputLocks(pathsFromOutputs(ne.derivation.outputs));
/* Now check again whether there is a successor. This is because
another process may have started building in parallel. After
@@ -95,33 +96,33 @@ FSId normaliseFState(FSId id, FSIdSet pending)
{
FSId id2 = useSuccessor(id);
if (id2 != id) {
- FState fs = parseFState(termFromId(id2));
+ NixExpr ne = parseNixExpr(termFromId(id2));
debug(format("skipping build of %1%, someone beat us to it")
% (string) id);
- if (fs.type != FState::fsSlice) abort();
+ if (ne.type != NixExpr::neClosure) abort();
return id2;
}
}
/* Right platform? */
- if (fs.derive.platform != thisSystem)
+ if (ne.derivation.platform != thisSystem)
throw Error(format("a `%1%' is required, but I am a `%2%'")
- % fs.derive.platform % thisSystem);
+ % ne.derivation.platform % thisSystem);
/* Realise inputs (and remember all input paths). */
- for (FSIdSet::iterator i = fs.derive.inputs.begin();
- i != fs.derive.inputs.end(); i++)
+ for (FSIdSet::iterator i = ne.derivation.inputs.begin();
+ i != ne.derivation.inputs.end(); i++)
{
- FSId nf = normaliseFState(*i, pending);
- realiseSlice(nf, pending);
+ FSId nf = normaliseNixExpr(*i, pending);
+ realiseClosure(nf, pending);
/* !!! nf should be a root of the garbage collector while we
are building */
- FState fs = parseFState(termFromId(nf));
- if (fs.type != FState::fsSlice) abort();
- for (SliceElems::iterator j = fs.slice.elems.begin();
- j != fs.slice.elems.end(); j++)
+ NixExpr ne = parseNixExpr(termFromId(nf));
+ if (ne.type != NixExpr::neClosure) abort();
+ for (ClosureElems::iterator j = ne.closure.elems.begin();
+ j != ne.closure.elems.end(); j++)
{
- inSlices[j->first] = j->second;
+ inClosures[j->first] = j->second;
allPaths.insert(j->first);
}
}
@@ -140,15 +141,15 @@ FSId normaliseFState(FSId id, FSIdSet pending)
env["HOME"] = "/homeless-shelter";
/* Build the environment. */
- for (StringPairs::iterator i = fs.derive.env.begin();
- i != fs.derive.env.end(); i++)
+ for (StringPairs::iterator i = ne.derivation.env.begin();
+ i != ne.derivation.env.end(); i++)
env[i->first] = i->second;
/* We can skip running the builder if we can expand all output
paths from their ids. */
bool fastBuild = true;
- for (DeriveOutputs::iterator i = fs.derive.outputs.begin();
- i != fs.derive.outputs.end(); i++)
+ for (DerivationOutputs::iterator i = ne.derivation.outputs.begin();
+ i != ne.derivation.outputs.end(); i++)
{
try {
expandId(i->second, i->first, "/", pending);
@@ -164,8 +165,8 @@ FSId normaliseFState(FSId id, FSIdSet pending)
/* If any of the outputs already exist but are not registered,
delete them. */
- for (DeriveOutputs::iterator i = fs.derive.outputs.begin();
- i != fs.derive.outputs.end(); i++)
+ for (DerivationOutputs::iterator i = ne.derivation.outputs.begin();
+ i != ne.derivation.outputs.end(); i++)
{
string path = i->first;
FSId id;
@@ -179,7 +180,7 @@ FSId normaliseFState(FSId id, FSIdSet pending)
/* Run the builder. */
msg(lvlChatty, format("building..."));
- runProgram(fs.derive.builder, fs.derive.args, env);
+ runProgram(ne.derivation.builder, ne.derivation.args, env);
msg(lvlChatty, format("build completed"));
} else
@@ -189,13 +190,13 @@ FSId normaliseFState(FSId id, FSIdSet pending)
output path to determine what other paths it references. Also make all
output paths read-only. */
StringSet usedPaths;
- for (DeriveOutputs::iterator i = fs.derive.outputs.begin();
- i != fs.derive.outputs.end(); i++)
+ for (DerivationOutputs::iterator i = ne.derivation.outputs.begin();
+ i != ne.derivation.outputs.end(); i++)
{
string path = i->first;
if (!pathExists(path))
throw Error(format("path `%1%' does not exist") % path);
- nfFS.slice.roots.insert(path);
+ nf.closure.roots.insert(path);
makePathReadOnly(path);
@@ -204,28 +205,28 @@ FSId normaliseFState(FSId id, FSIdSet pending)
Strings refPaths = filterReferences(path,
Strings(allPaths.begin(), allPaths.end()));
- /* Construct a slice element for this output path. */
- SliceElem elem;
+ /* Construct a closure element for this output path. */
+ ClosureElem elem;
elem.id = i->second;
/* For each path referenced by this output path, add its id to the
- slice element and add the id to the `usedPaths' set (so that the
- elements referenced by *its* slice are added below). */
+ closure element and add the id to the `usedPaths' set (so that the
+ elements referenced by *its* closure are added below). */
for (Strings::iterator j = refPaths.begin();
j != refPaths.end(); j++)
{
string path = *j;
elem.refs.insert(path);
- if (inSlices.find(path) != inSlices.end())
+ if (inClosures.find(path) != inClosures.end())
usedPaths.insert(path);
- else if (fs.derive.outputs.find(path) == fs.derive.outputs.end())
+ else if (ne.derivation.outputs.find(path) == ne.derivation.outputs.end())
abort();
}
- nfFS.slice.elems[path] = elem;
+ nf.closure.elems[path] = elem;
}
- /* Close the slice. That is, for any referenced path, add the paths
+ /* Close the closure. That is, for any referenced path, add the paths
referenced by it. */
StringSet donePaths;
@@ -237,10 +238,10 @@ FSId normaliseFState(FSId id, FSIdSet pending)
if (donePaths.find(path) != donePaths.end()) continue;
donePaths.insert(path);
- SliceElems::iterator j = inSlices.find(path);
- if (j == inSlices.end()) abort();
+ ClosureElems::iterator j = inClosures.find(path);
+ if (j == inClosures.end()) abort();
- nfFS.slice.elems[path] = j->second;
+ nf.closure.elems[path] = j->second;
for (StringSet::iterator k = j->second.refs.begin();
k != j->second.refs.end(); k++)
@@ -248,8 +249,8 @@ FSId normaliseFState(FSId id, FSIdSet pending)
}
/* For debugging, print out the referenced and unreferenced paths. */
- for (SliceElems::iterator i = inSlices.begin();
- i != inSlices.end(); i++)
+ for (ClosureElems::iterator i = inClosures.begin();
+ i != inClosures.end(); i++)
{
StringSet::iterator j = donePaths.find(i->first);
if (j == donePaths.end())
@@ -260,9 +261,9 @@ FSId normaliseFState(FSId id, FSIdSet pending)
/* Write the normal form. This does not have to occur in the
transaction below because writing terms is idem-potent. */
- ATerm nf = unparseFState(nfFS);
- msg(lvlVomit, format("normal form: %1%") % printTerm(nf));
- FSId idNF = writeTerm(nf, "-s-" + (string) id);
+ ATerm nfTerm = unparseNixExpr(nf);
+ msg(lvlVomit, format("normal form: %1%") % printTerm(nfTerm));
+ FSId idNF = writeTerm(nfTerm, "-s-" + (string) id);
/* Register each outpat path, and register the normal form. This
is wrapped in one database transaction to ensure that if we
@@ -271,8 +272,8 @@ FSId normaliseFState(FSId id, FSIdSet pending)
deleted arbitrarily, while registered paths can only be deleted
by running the garbage collector. */
Transaction txn(nixDB);
- for (DeriveOutputs::iterator i = fs.derive.outputs.begin();
- i != fs.derive.outputs.end(); i++)
+ for (DerivationOutputs::iterator i = ne.derivation.outputs.begin();
+ i != ne.derivation.outputs.end(); i++)
registerPath(txn, i->first, i->second);
registerSuccessor(txn, id, idNF);
txn.commit();
@@ -281,36 +282,36 @@ FSId normaliseFState(FSId id, FSIdSet pending)
}
-void realiseSlice(const FSId & id, FSIdSet pending)
+void realiseClosure(const FSId & id, FSIdSet pending)
{
Nest nest(lvlDebug,
- format("realising slice %1%") % (string) id);
+ format("realising closure %1%") % (string) id);
- FState fs = parseFState(termFromId(id));
- if (fs.type != FState::fsSlice)
- throw Error(format("expected slice in %1%") % (string) id);
+ NixExpr ne = parseNixExpr(termFromId(id));
+ if (ne.type != NixExpr::neClosure)
+ throw Error(format("expected closure in %1%") % (string) id);
- for (SliceElems::const_iterator i = fs.slice.elems.begin();
- i != fs.slice.elems.end(); i++)
+ for (ClosureElems::const_iterator i = ne.closure.elems.begin();
+ i != ne.closure.elems.end(); i++)
expandId(i->second.id, i->first, "/", pending);
}
-Strings fstatePaths(const FSId & id)
+Strings nixExprPaths(const FSId & id)
{
Strings paths;
- FState fs = parseFState(termFromId(id));
+ NixExpr ne = parseNixExpr(termFromId(id));
- if (fs.type == FState::fsSlice) {
- for (StringSet::const_iterator i = fs.slice.roots.begin();
- i != fs.slice.roots.end(); i++)
+ if (ne.type == NixExpr::neClosure) {
+ for (StringSet::const_iterator i = ne.closure.roots.begin();
+ i != ne.closure.roots.end(); i++)
paths.push_back(*i);
}
- else if (fs.type == FState::fsDerive) {
- for (DeriveOutputs::iterator i = fs.derive.outputs.begin();
- i != fs.derive.outputs.end(); i++)
+ else if (ne.type == NixExpr::neDerivation) {
+ for (DerivationOutputs::iterator i = ne.derivation.outputs.begin();
+ i != ne.derivation.outputs.end(); i++)
paths.push_back(i->first);
}
@@ -320,24 +321,24 @@ Strings fstatePaths(const FSId & id)
}
-static void fstateRequisitesSet(const FSId & id,
+static void nixExprRequisitesSet(const FSId & id,
bool includeExprs, bool includeSuccessors, StringSet & paths,
FSIdSet & doneSet)
{
if (doneSet.find(id) != doneSet.end()) return;
doneSet.insert(id);
- FState fs = parseFState(termFromId(id));
+ NixExpr ne = parseNixExpr(termFromId(id));
- if (fs.type == FState::fsSlice)
- for (SliceElems::iterator i = fs.slice.elems.begin();
- i != fs.slice.elems.end(); i++)
+ if (ne.type == NixExpr::neClosure)
+ for (ClosureElems::iterator i = ne.closure.elems.begin();
+ i != ne.closure.elems.end(); i++)
paths.insert(i->first);
- else if (fs.type == FState::fsDerive)
- for (FSIdSet::iterator i = fs.derive.inputs.begin();
- i != fs.derive.inputs.end(); i++)
- fstateRequisitesSet(*i,
+ else if (ne.type == NixExpr::neDerivation)
+ for (FSIdSet::iterator i = ne.derivation.inputs.begin();
+ i != ne.derivation.inputs.end(); i++)
+ nixExprRequisitesSet(*i,
includeExprs, includeSuccessors, paths, doneSet);
else abort();
@@ -348,17 +349,17 @@ static void fstateRequisitesSet(const FSId & id,
string idSucc;
if (includeSuccessors &&
nixDB.queryString(noTxn, dbSuccessors, id, idSucc))
- fstateRequisitesSet(parseHash(idSucc),
+ nixExprRequisitesSet(parseHash(idSucc),
includeExprs, includeSuccessors, paths, doneSet);
}
-Strings fstateRequisites(const FSId & id,
+Strings nixExprRequisites(const FSId & id,
bool includeExprs, bool includeSuccessors)
{
StringSet paths;
FSIdSet doneSet;
- fstateRequisitesSet(id, includeExprs, includeSuccessors, paths, doneSet);
+ nixExprRequisitesSet(id, includeExprs, includeSuccessors, paths, doneSet);
return Strings(paths.begin(), paths.end());
}
@@ -381,19 +382,19 @@ FSIds findGenerators(const FSIds & _ids)
if (!nixDB.queryString(noTxn, dbSuccessors, *i, s)) continue;
FSId id = parseHash(s);
- FState fs;
+ NixExpr ne;
try {
/* !!! should substitutes be used? */
- fs = parseFState(termFromId(id));
+ ne = parseNixExpr(termFromId(id));
} catch (...) { /* !!! only catch parse errors */
continue;
}
- if (fs.type != FState::fsSlice) continue;
+ if (ne.type != NixExpr::neClosure) continue;
bool okay = true;
- for (SliceElems::const_iterator i = fs.slice.elems.begin();
- i != fs.slice.elems.end(); i++)
+ for (ClosureElems::const_iterator i = ne.closure.elems.begin();
+ i != ne.closure.elems.end(); i++)
if (ids.find(i->second.id) == ids.end()) {
okay = false;
break;
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-23 22:29:05 +0000