about summary refs log tree commit diff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/Makefile.am1
-rw-r--r--src/nix-help.txt2
-rw-r--r--src/nix.cc15
-rw-r--r--src/normalise.cc20
-rw-r--r--src/normalise.hh10
5 files changed, 36 insertions, 12 deletions
diff --git a/src/Makefile.am b/src/Makefile.am
index 23e2429191ac..cc51eff36577 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -43,6 +43,7 @@ nix.o: nix-help.txt.hh
 install-data-local:
 	$(INSTALL) -d $(localstatedir)/nix
 	$(INSTALL) -d $(localstatedir)/nix/links
+	ln -sf $(localstatedir)/nix/links/current $(prefix)/current
 	$(INSTALL) -d $(localstatedir)/log/nix
 	$(INSTALL) -d $(prefix)/store
 	$(bindir)/nix --init
diff --git a/src/nix-help.txt b/src/nix-help.txt
index ecf9b5c16d25..0e54d162de05 100644
--- a/src/nix-help.txt
+++ b/src/nix-help.txt
@@ -26,7 +26,7 @@ Source selection for --install, --dump:
 Query flags:
 
   --list / -l: query the output paths (roots) of an fstate (default)
-  --refs / -r: query paths referenced by an fstate
+  --requisites / -r: print all paths necessary to realise expression
   --generators / -g: find expressions producing a subset of given ids
   --expansion / -e: print a path containing id
   --graph: print a dot graph rooted at given ids
diff --git a/src/nix.cc b/src/nix.cc
index a7bcf7268413..68d01f2f87a3 100644
--- a/src/nix.cc
+++ b/src/nix.cc
@@ -95,18 +95,22 @@ FSId maybeNormalise(const FSId & id, bool normalise)
 /* Perform various sorts of queries. */
 static void opQuery(Strings opFlags, Strings opArgs)
 {
-    enum { qList, qRefs, qGenerators, qExpansion, qGraph 
+    enum { qList, qRequisites, qGenerators, qExpansion, qGraph 
     } query = qList;
     bool normalise = false;
+    bool includeExprs = true;
+    bool includeSuccessors = false;
 
     for (Strings::iterator i = opFlags.begin();
          i != opFlags.end(); i++)
         if (*i == "--list" || *i == "-l") query = qList;
-        else if (*i == "--refs" || *i == "-r") query = qRefs;
+        else if (*i == "--requisites" || *i == "-r") query = qRequisites;
         else if (*i == "--generators" || *i == "-g") query = qGenerators;
         else if (*i == "--expansion" || *i == "-e") query = qExpansion;
         else if (*i == "--graph") query = qGraph;
         else if (*i == "--normalise" || *i == "-n") normalise = true;
+        else if (*i == "--exclude-exprs") includeExprs = false;
+        else if (*i == "--include-successors") includeSuccessors = true;
         else throw UsageError(format("unknown flag `%1%'") % *i);
 
     switch (query) {
@@ -126,13 +130,14 @@ static void opQuery(Strings opFlags, Strings opArgs)
             break;
         }
 
-        case qRefs: {
+        case qRequisites: {
             StringSet paths;
             for (Strings::iterator i = opArgs.begin();
                  i != opArgs.end(); i++)
             {
-                Strings paths2 = fstateRefs(
-                    maybeNormalise(argToId(*i), normalise));
+                Strings paths2 = fstateRequisites(
+                    maybeNormalise(argToId(*i), normalise),
+                    includeExprs, includeSuccessors);
                 paths.insert(paths2.begin(), paths2.end());
             }
             for (StringSet::iterator i = paths.begin(); 
diff --git a/src/normalise.cc b/src/normalise.cc
index eefb790b6f98..5ef4d82ac139 100644
--- a/src/normalise.cc
+++ b/src/normalise.cc
@@ -244,7 +244,8 @@ Strings fstatePaths(const FSId & id)
 }
 
 
-static void fstateRefsSet(const FSId & id, StringSet & paths)
+static void fstateRequisitesSet(const FSId & id, 
+    bool includeExprs, bool includeSuccessors, StringSet & paths)
 {
     FState fs = parseFState(termFromId(id));
 
@@ -257,17 +258,28 @@ static void fstateRefsSet(const FSId & id, StringSet & paths)
     else if (fs.type == FState::fsDerive) {
         for (FSIds::iterator i = fs.derive.inputs.begin();
              i != fs.derive.inputs.end(); i++)
-            fstateRefsSet(*i, paths);
+            fstateRequisitesSet(*i,
+                includeExprs, includeSuccessors, paths);
     }
 
     else abort();
+
+    if (includeExprs) 
+        paths.insert(expandId(id));
+
+    string idSucc;
+    if (includeSuccessors &&
+        queryDB(nixDB, dbSuccessors, id, idSucc))
+        fstateRequisitesSet(parseHash(idSucc), 
+            includeExprs, includeSuccessors, paths);
 }
 
 
-Strings fstateRefs(const FSId & id)
+Strings fstateRequisites(const FSId & id,
+    bool includeExprs, bool includeSuccessors)
 {
     StringSet paths;
-    fstateRefsSet(id, paths);
+    fstateRequisitesSet(id, includeExprs, includeSuccessors, paths);
     return Strings(paths.begin(), paths.end());
 }
 
diff --git a/src/normalise.hh b/src/normalise.hh
index a5b45c861926..98f58783e5b8 100644
--- a/src/normalise.hh
+++ b/src/normalise.hh
@@ -15,8 +15,14 @@ void realiseSlice(const FSId & id, FSIdSet pending = FSIdSet());
    fstate-expression. */
 Strings fstatePaths(const FSId & id);
 
-/* Get the list of paths referenced by the given fstate-expression. */
-Strings fstateRefs(const FSId & id);
+/* Get the list of paths that are required to realise the given
+   expression.  For a derive expression, this is the union of
+   requisites of the inputs; for a slice expression, it is the path of
+   each element in the slice.  If `includeExprs' is true, include the
+   paths of the Nix expressions themselves.  If `includeSuccessors' is
+   true, include the requisites of successors. */
+Strings fstateRequisites(const FSId & id,
+    bool includeExprs, bool includeSuccessors);
 
 /* Return the list of the ids of all known fstate-expressions whose
    output ids are completely contained in `ids'. */