* "Nix expression" -> "store expression".

* More refactoring.

1 files changed, 17 insertions, 15 deletions

diff --git a/src/libstore/normalise.hh b/src/libstore/normalise.hh
index bbe846404cc0..1003858cbea7 100644
--- a/src/libstore/normalise.hh
+++ b/src/libstore/normalise.hh
@@ -1,16 +1,16 @@
 #ifndef __NORMALISE_H
 #define __NORMALISE_H
 
-#include "expr.hh"
+#include "storeexpr.hh"
 
 
-/* Normalise a Nix expression.  That is, if the expression is a
+/* Normalise a store expression.  That is, if the expression is a
    derivation, a path containing an equivalent closure expression is
    returned.  This requires that the derivation is performed, unless a
    successor is known. */
-Path normaliseNixExpr(const Path & nePath, PathSet pending = PathSet());
+Path normaliseStoreExpr(const Path & nePath, PathSet pending = PathSet());
 
-/* Realise a closure expression in the file system. 
+/* Realise a closure store expression in the file system. 
 
    The pending paths are those that are already being realised.  This
    prevents infinite recursion for paths realised through a substitute
@@ -22,23 +22,25 @@ void realiseClosure(const Path & nePath, PathSet pending = PathSet());
    realising a substitute. */
 void ensurePath(const Path & path, PathSet pending = PathSet());
 
-/* Read a Nix expression, after ensuring its existence through
+/* Read a store expression, after ensuring its existence through
    ensurePath(). */
-NixExpr exprFromPath(const Path & path, PathSet pending = PathSet());
+StoreExpr storeExprFromPath(const Path & path, PathSet pending = PathSet());
 
-/* Get the list of root (output) paths of the given Nix expression. */
-PathSet nixExprRoots(const Path & nePath);
+/* Get the list of root (output) paths of the given store
+   expression. */
+PathSet storeExprRoots(const Path & nePath);
 
-/* Get the list of paths that are required to realise the given
+/* Get the list of paths that are required to realise the given store
    expression.  For a derive expression, this is the union of
-   requisites of the inputs; for a closure expression, it is the path of
-   each element in the closure.  If `includeExprs' is true, include the
-   paths of the Nix expressions themselves.  If `includeSuccessors' is
-   true, include the requisites of successors. */
-PathSet nixExprRequisites(const Path & nePath,
+   requisites of the inputs; for a closure expression, it is the path
+   of each element in the closure.  If `includeExprs' is true, include
+   the paths of the store expressions themselves.  If
+   `includeSuccessors' is true, include the requisites of
+   successors. */
+PathSet storeExprRequisites(const Path & nePath,
     bool includeExprs, bool includeSuccessors);
 
-/* Return the list of the paths of all known Nix expressions whose
+/* Return the list of the paths of all known store expressions whose
    output paths are completely contained in the set `outputs'. */
 PathSet findGenerators(const PathSet & outputs);