* Get rid of identifiers since they are redundant now. This greatly

  simplifies stuff.

* The format of Nix expressions and the database schema changed
  because of this, so it's best to delete old Nix installations.

1 files changed, 18 insertions, 11 deletions

diff --git a/src/normalise.hh b/src/normalise.hh
index 9b827468195c..4b4db4ee2a07 100644
--- a/src/normalise.hh
+++ b/src/normalise.hh
@@ -4,15 +4,22 @@
 #include "expr.hh"
 
 
-/* Normalise a Nix expression, that is, return an equivalent
-   closure.  (For the meaning of `pending', see expandId()). */
-FSId normaliseNixExpr(FSId id, FSIdSet pending = FSIdSet());
+/* Normalise a Nix 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());
 
-/* Realise a Closure in the file system. */
-void realiseClosure(const FSId & id, FSIdSet pending = FSIdSet());
+/* Realise a closure 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
+   (since when we build the substitute, we would first try to realise
+   its output paths through substitutes... kaboom!). */
+void realiseClosure(const Path & nePath, PathSet pending = PathSet());
 
 /* Get the list of root (output) paths of the given Nix expression. */
-Strings nixExprPaths(const FSId & id);
+PathSet nixExprRoots(const Path & nePath);
 
 /* Get the list of paths that are required to realise the given
    expression.  For a derive expression, this is the union of
@@ -20,16 +27,16 @@ Strings nixExprPaths(const FSId & id);
    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. */
-Strings nixExprRequisites(const FSId & id,
+PathSet nixExprRequisites(const Path & nePath,
     bool includeExprs, bool includeSuccessors);
 
-/* Return the list of the ids of all known Nix expressions whose
-   output ids are completely contained in `ids'. */
-FSIds findGenerators(const FSIds & ids);
+/* Return the list of the paths of all known Nix expressions whose
+   output paths are completely contained in the set `outputs'. */
+PathSet findGenerators(const PathSet & outputs);
 
 /* Register a successor. */
 void registerSuccessor(const Transaction & txn,
-    const FSId & id1, const FSId & id2);
+    const Path & path1, const Path & path2);
 
 
 #endif /* !__NORMALISE_H */