* Change `referer' to `referrer' throughout. In particular, the

  nix-store query options `--referer' and `--referer-closure' have
  been changed to `--referrer' and `--referrer-closure' (but the old
  ones are still accepted for compatibility).

5 files changed, 40 insertions, 39 deletions

diff --git a/src/libstore/build.hh b/src/libstore/build.hh
index 45997ebb24d0..9e3d365e989a 100644
--- a/src/libstore/build.hh
+++ b/src/libstore/build.hh
@@ -23,8 +23,9 @@ Derivation derivationFromPath(const Path & drvPath);
    closure of `storePath'; that is, all paths than can be directly or
    indirectly reached from it.  `paths' is not cleared.  If
    `flipDirection' is true, the set of paths that can reach
-   `storePath' is returned; that is, the closures under the `referers'
-   relation instead of the `references' relation is returned. */
+   `storePath' is returned; that is, the closures under the
+   `referrers' relation instead of the `references' relation is
+   returned. */
 void computeFSClosure(const Path & storePath,
     PathSet & paths, bool flipDirection = false);
 
diff --git a/src/libstore/gc.cc b/src/libstore/gc.cc
index 634c610263b0..bdaf2946ca58 100644
--- a/src/libstore/gc.cc
+++ b/src/libstore/gc.cc
@@ -401,8 +401,8 @@ void collectGarbage(GCAction action, PathSet & result)
     for (Paths::iterator i = storePaths.begin(); i != storePaths.end(); ++i)
         storePaths2.insert(canonPath(nixStore + "/" + *i));
 
-    /* Topologically sort them under the `referers' relation.  That
-       is, a < b iff a is in referers(b).  This gives us the order in
+    /* Topologically sort them under the `referrers' relation.  That
+       is, a < b iff a is in referrers(b).  This gives us the order in
        which things can be deleted safely. */
     /* !!! when we have multiple output paths per derivation, this
        will not work anymore because we get cycles. */
diff --git a/src/libstore/misc.cc b/src/libstore/misc.cc
index f3cc98bf4e2a..33efe8bebc98 100644
--- a/src/libstore/misc.cc
+++ b/src/libstore/misc.cc
@@ -19,7 +19,7 @@ void computeFSClosure(const Path & storePath,
 
     PathSet references;
     if (flipDirection)
-        queryReferers(noTxn, storePath, references);
+        queryReferrers(noTxn, storePath, references);
     else
         queryReferences(noTxn, storePath, references);
 
diff --git a/src/libstore/store.cc b/src/libstore/store.cc
index db12ba2d537b..48f09fefe144 100644
--- a/src/libstore/store.cc
+++ b/src/libstore/store.cc
@@ -309,7 +309,7 @@ static string stripPrefix(const string & prefix, const string & s)
 }
 
 
-static PathSet getReferers(const Transaction & txn, const Path & storePath)
+static PathSet getReferrers(const Transaction & txn, const Path & storePath)
 {
     PathSet referrers;
     Strings keys;
@@ -338,13 +338,13 @@ void setReferences(const Transaction & txn, const Path & storePath,
     nixDB.setStrings(txn, dbReferences, storePath,
         Paths(references.begin(), references.end()));
 
-    /* Update the referers mappings of all new referenced paths. */
+    /* Update the referrers mappings of all new referenced paths. */
     for (PathSet::const_iterator i = references.begin();
          i != references.end(); ++i)
         if (oldReferences2.find(*i) == oldReferences2.end())
             nixDB.setString(txn, dbReferrers, addPrefix(*i, storePath), "");
 
-    /* Remove referer mappings from paths that are no longer
+    /* Remove referrer mappings from paths that are no longer
        references. */
     for (Paths::iterator i = oldReferences.begin();
          i != oldReferences.end(); ++i)
@@ -364,13 +364,13 @@ void queryReferences(const Transaction & txn,
 }
 
 
-void queryReferers(const Transaction & txn,
-    const Path & storePath, PathSet & referers)
+void queryReferrers(const Transaction & txn,
+    const Path & storePath, PathSet & referrers)
 {
     if (!isRealisablePath(txn, storePath))
         throw Error(format("path `%1%' is not valid") % storePath);
-    PathSet referers2 = getReferers(txn, storePath);
-    referers.insert(referers2.begin(), referers2.end());
+    PathSet referrers2 = getReferrers(txn, storePath);
+    referrers.insert(referrers2.begin(), referrers2.end());
 }
 
 
@@ -499,9 +499,9 @@ void clearSubstitutes()
             invalidatePath(txn, *i);
     }
 
-    /* !!! there should be no referers to any of the invalid
+    /* !!! there should be no referrers to any of the invalid
        substitutable paths.  This should be the case by construction
-       (the only referers can be other invalid substitutable paths,
+       (the only referrers can be other invalid substitutable paths,
        which have all been removed now). */
     
     txn.commit();
@@ -587,13 +587,13 @@ void registerValidPaths(const Transaction & txn,
 
 
 /* Invalidate a path.  The caller is responsible for checking that
-   there are no referers. */
+   there are no referrers. */
 static void invalidatePath(Transaction & txn, const Path & path)
 {
     debug(format("unregistering path `%1%'") % path);
 
     /* Clear the `references' entry for this path, as well as the
-       inverse `referers' entries, and the `derivers' entry; but only
+       inverse `referrers' entries, and the `derivers' entry; but only
        if there are no substitutes for this path.  This maintains the
        cleanup invariant. */
     if (querySubstitutes(txn, path).size() == 0) {
@@ -754,9 +754,9 @@ void deleteFromStore(const Path & _path)
 
     Transaction txn(nixDB);
     if (isValidPathTxn(txn, path)) {
-        PathSet referers = getReferers(txn, path);
-        for (PathSet::iterator i = referers.begin();
-             i != referers.end(); ++i)
+        PathSet referrers = getReferrers(txn, path);
+        for (PathSet::iterator i = referrers.begin();
+             i != referrers.end(); ++i)
             if (*i != path && isValidPathTxn(txn, *i))
                 throw Error(format("cannot delete path `%1%' because it is in use by path `%2%'") % path % *i);
         invalidatePath(txn, path);
@@ -817,7 +817,7 @@ void verifyStore(bool checkContents)
     }
 
     /* Check the cleanup invariant: only usable paths can have
-       `references', `referers', or `derivers' entries. */
+       `references', `referrers', or `derivers' entries. */
 
     /* Check the `derivers' table. */
     Paths deriversKeys;
@@ -860,7 +860,7 @@ void verifyStore(bool checkContents)
             {
                 string dummy;
                 if (!nixDB.queryString(txn, dbReferrers, addPrefix(*j, *i), dummy)) {
-                    printMsg(lvlError, format("missing referer mapping from `%1%' to `%2%'")
+                    printMsg(lvlError, format("missing referrer mapping from `%1%' to `%2%'")
                         % *j % *i);
                     nixDB.setString(txn, dbReferrers, addPrefix(*j, *i), "");
                 }
@@ -873,26 +873,26 @@ void verifyStore(bool checkContents)
     }
 
 #if 0 // !!!
-    /* Check the `referers' table. */
-    Paths referersKeys;
-    nixDB.enumTable(txn, dbReferers, referersKeys);
-    for (Paths::iterator i = referersKeys.begin();
-         i != referersKeys.end(); ++i)
+    /* Check the `referrers' table. */
+    Paths referrersKeys;
+    nixDB.enumTable(txn, dbReferrers, referrersKeys);
+    for (Paths::iterator i = referrersKeys.begin();
+         i != referrersKeys.end(); ++i)
     {
         if (usablePaths.find(*i) == usablePaths.end()) {
-            printMsg(lvlError, format("found referers entry for unusable path `%1%'")
+            printMsg(lvlError, format("found referrers entry for unusable path `%1%'")
                 % *i);
-            nixDB.delPair(txn, dbReferers, *i);
+            nixDB.delPair(txn, dbReferrers, *i);
         }
         else {
-            PathSet referers, newReferers;
-            queryReferers(txn, *i, referers);
-            for (PathSet::iterator j = referers.begin();
-                 j != referers.end(); ++j)
+            PathSet referrers, newReferrers;
+            queryReferrers(txn, *i, referrers);
+            for (PathSet::iterator j = referrers.begin();
+                 j != referrers.end(); ++j)
             {
                 Paths references;
                 if (usablePaths.find(*j) == usablePaths.end()) {
-                    printMsg(lvlError, format("referer mapping from `%1%' to unusable `%2%'")
+                    printMsg(lvlError, format("referrer mapping from `%1%' to unusable `%2%'")
                         % *i % *j);
                 } else {
                     nixDB.queryStrings(txn, dbReferences, *j, references);
@@ -901,12 +901,12 @@ void verifyStore(bool checkContents)
                             % *j % *i);
                         /* !!! repair by inserting *i into references */
                     }
-                    else newReferers.insert(*j);
+                    else newReferrers.insert(*j);
                 }
             }
-            if (referers != newReferers)
-                nixDB.setStrings(txn, dbReferers, *i,
-                    Paths(newReferers.begin(), newReferers.end()));
+            if (referrers != newReferrers)
+                nixDB.setStrings(txn, dbReferrers, *i,
+                    Paths(newReferrers.begin(), newReferrers.end()));
         }
     }
 #endif    
diff --git a/src/libstore/store.hh b/src/libstore/store.hh
index 2b83bd7fef04..0f35ff0c626c 100644
--- a/src/libstore/store.hh
+++ b/src/libstore/store.hh
@@ -123,8 +123,8 @@ void queryReferences(const Transaction & txn,
 
 /* Queries the set of incoming FS references for a store path.  The
    result is not cleared. */
-void queryReferers(const Transaction & txn,
-    const Path & storePath, PathSet & referers);
+void queryReferrers(const Transaction & txn,
+    const Path & storePath, PathSet & referrers);
 
 /* Sets the deriver of a store path.  Use with care! */
 void setDeriver(const Transaction & txn, const Path & storePath,