Use proper quotes everywhere

1 files changed, 40 insertions, 40 deletions

diff --git a/src/libexpr/primops.cc b/src/libexpr/primops.cc
index 4436b636ba..0c4381b113 100644
--- a/src/libexpr/primops.cc
+++ b/src/libexpr/primops.cc
@@ -43,7 +43,7 @@ struct InvalidPathError : EvalError
 {
     Path path;
     InvalidPathError(const Path & path) :
-        EvalError(format("path `%1%' is not valid") % path), path(path) {};
+        EvalError(format("path ‘%1%’ is not valid") % path), path(path) {};
     ~InvalidPathError() throw () { };
 };
 
@@ -82,7 +82,7 @@ static void prim_scopedImport(EvalState & state, const Pos & pos, Value * * args
     try {
         realiseContext(context);
     } catch (InvalidPathError & e) {
-        throw EvalError(format("cannot import `%1%', since path `%2%' is not valid, at %3%")
+        throw EvalError(format("cannot import ‘%1%’, since path ‘%2%’ is not valid, at %3%")
             % path % e.path % pos);
     }
 
@@ -123,7 +123,7 @@ static void prim_scopedImport(EvalState & state, const Pos & pos, Value * * args
                 env->values[displ++] = attr.value;
             }
 
-            startNest(nest, lvlTalkative, format("evaluating file `%1%'") % path);
+            startNest(nest, lvlTalkative, format("evaluating file ‘%1%’") % path);
             Expr * e = state.parseExprFromFile(resolveExprPath(path), staticEnv);
 
             e->eval(state, *env, v);
@@ -145,7 +145,7 @@ static void prim_importNative(EvalState & state, const Pos & pos, Value * * args
     try {
         realiseContext(context);
     } catch (InvalidPathError & e) {
-        throw EvalError(format("cannot import `%1%', since path `%2%' is not valid, at %3%")
+        throw EvalError(format("cannot import ‘%1%’, since path ‘%2%’ is not valid, at %3%")
             % path % e.path % pos);
     }
 
@@ -153,16 +153,16 @@ static void prim_importNative(EvalState & state, const Pos & pos, Value * * args
 
     void *handle = dlopen(path.c_str(), RTLD_LAZY | RTLD_LOCAL);
     if (!handle)
-        throw EvalError(format("could not open `%1%': %2%") % path % dlerror());
+        throw EvalError(format("could not open ‘%1%’: %2%") % path % dlerror());
 
     dlerror();
     ValueInitializer func = (ValueInitializer) dlsym(handle, sym.c_str());
     if(!func) {
         char *message = dlerror();
         if (message)
-            throw EvalError(format("could not load symbol `%1%' from `%2%': %3%") % sym % path % message);
+            throw EvalError(format("could not load symbol ‘%1%’ from ‘%2%’: %3%") % sym % path % message);
         else
-            throw EvalError(format("symbol `%1%' from `%2%' resolved to NULL when a function pointer was expected")
+            throw EvalError(format("symbol ‘%1%’ from ‘%2%’ resolved to NULL when a function pointer was expected")
                     % sym % path);
     }
 
@@ -273,7 +273,7 @@ static void prim_genericClosure(EvalState & state, const Pos & pos, Value * * ar
     Bindings::iterator startSet =
         args[0]->attrs->find(state.symbols.create("startSet"));
     if (startSet == args[0]->attrs->end())
-        throw EvalError(format("attribute `startSet' required, at %1%") % pos);
+        throw EvalError(format("attribute ‘startSet’ required, at %1%") % pos);
     state.forceList(*startSet->value, pos);
 
     ValueList workSet;
@@ -284,7 +284,7 @@ static void prim_genericClosure(EvalState & state, const Pos & pos, Value * * ar
     Bindings::iterator op =
         args[0]->attrs->find(state.symbols.create("operator"));
     if (op == args[0]->attrs->end())
-        throw EvalError(format("attribute `operator' required, at %1%") % pos);
+        throw EvalError(format("attribute ‘operator’ required, at %1%") % pos);
     state.forceValue(*op->value);
 
     /* Construct the closure by applying the operator to element of
@@ -303,7 +303,7 @@ static void prim_genericClosure(EvalState & state, const Pos & pos, Value * * ar
         Bindings::iterator key =
             e->attrs->find(state.symbols.create("key"));
         if (key == e->attrs->end())
-            throw EvalError(format("attribute `key' required, at %1%") % pos);
+            throw EvalError(format("attribute ‘key’ required, at %1%") % pos);
         state.forceValue(*key->value);
 
         if (doneKeys.find(key->value) != doneKeys.end()) continue;
@@ -333,7 +333,7 @@ static void prim_genericClosure(EvalState & state, const Pos & pos, Value * * ar
 static void prim_abort(EvalState & state, const Pos & pos, Value * * args, Value & v)
 {
     PathSet context;
-    throw Abort(format("evaluation aborted with the following error message: `%1%'") %
+    throw Abort(format("evaluation aborted with the following error message: ‘%1%’") %
         state.coerceToString(pos, *args[0], context));
 }
 
@@ -418,13 +418,13 @@ static void prim_derivationStrict(EvalState & state, const Pos & pos, Value * *
     /* Figure out the name first (for stack backtraces). */
     Bindings::iterator attr = args[0]->attrs->find(state.sName);
     if (attr == args[0]->attrs->end())
-        throw EvalError(format("required attribute `name' missing, at %1%") % pos);
+        throw EvalError(format("required attribute ‘name’ missing, at %1%") % pos);
     string drvName;
     Pos & posDrvName(*attr->pos);
     try {
         drvName = state.forceStringNoCtx(*attr->value, pos);
     } catch (Error & e) {
-        e.addPrefix(format("while evaluating the derivation attribute `name' at %1%:\n") % posDrvName);
+        e.addPrefix(format("while evaluating the derivation attribute ‘name’ at %1%:\n") % posDrvName);
         throw;
     }
 
@@ -448,7 +448,7 @@ static void prim_derivationStrict(EvalState & state, const Pos & pos, Value * *
     foreach (Bindings::iterator, i, *args[0]->attrs) {
         if (i->name == state.sIgnoreNulls) continue;
         string key = i->name;
-        startNest(nest, lvlVomit, format("processing attribute `%1%'") % key);
+        startNest(nest, lvlVomit, format("processing attribute ‘%1%’") % key);
 
         try {
 
@@ -476,28 +476,28 @@ static void prim_derivationStrict(EvalState & state, const Pos & pos, Value * *
                 else if (i->name == state.sSystem) drv.platform = s;
                 else if (i->name == state.sName) {
                     drvName = s;
-                    printMsg(lvlVomit, format("derivation name is `%1%'") % drvName);
+                    printMsg(lvlVomit, format("derivation name is ‘%1%’") % drvName);
                 }
                 else if (key == "outputHash") outputHash = s;
                 else if (key == "outputHashAlgo") outputHashAlgo = s;
                 else if (key == "outputHashMode") {
                     if (s == "recursive") outputHashRecursive = true;
                     else if (s == "flat") outputHashRecursive = false;
-                    else throw EvalError(format("invalid value `%1%' for `outputHashMode' attribute, at %2%") % s % posDrvName);
+                    else throw EvalError(format("invalid value ‘%1%’ for ‘outputHashMode’ attribute, at %2%") % s % posDrvName);
                 }
                 else if (key == "outputs") {
                     Strings tmp = tokenizeString<Strings>(s);
                     outputs.clear();
                     foreach (Strings::iterator, j, tmp) {
                         if (outputs.find(*j) != outputs.end())
-                            throw EvalError(format("duplicate derivation output `%1%', at %2%") % *j % posDrvName);
+                            throw EvalError(format("duplicate derivation output ‘%1%’, at %2%") % *j % posDrvName);
                         /* !!! Check whether *j is a valid attribute
                            name. */
                         /* Derivations cannot be named ‘drv’, because
                            then we'd have an attribute ‘drvPath’ in
                            the resulting set. */
                         if (*j == "drv")
-                            throw EvalError(format("invalid derivation output name `drv', at %1%") % posDrvName);
+                            throw EvalError(format("invalid derivation output name ‘drv’, at %1%") % posDrvName);
                         outputs.insert(*j);
                     }
                     if (outputs.empty())
@@ -506,7 +506,7 @@ static void prim_derivationStrict(EvalState & state, const Pos & pos, Value * *
             }
 
         } catch (Error & e) {
-            e.addPrefix(format("while evaluating the attribute `%1%' of the derivation `%2%' at %3%:\n")
+            e.addPrefix(format("while evaluating the attribute ‘%1%’ of the derivation ‘%2%’ at %3%:\n")
                 % key % drvName % posDrvName);
             throw;
         }
@@ -557,14 +557,14 @@ static void prim_derivationStrict(EvalState & state, const Pos & pos, Value * *
 
     /* Do we have all required attributes? */
     if (drv.builder == "")
-        throw EvalError(format("required attribute `builder' missing, at %1%") % posDrvName);
+        throw EvalError(format("required attribute ‘builder’ missing, at %1%") % posDrvName);
     if (drv.platform == "")
-        throw EvalError(format("required attribute `system' missing, at %1%") % posDrvName);
+        throw EvalError(format("required attribute ‘system’ missing, at %1%") % posDrvName);
 
     /* Check whether the derivation name is valid. */
     checkStoreName(drvName);
     if (isDerivation(drvName))
-        throw EvalError(format("derivation names are not allowed to end in `%1%', at %2%")
+        throw EvalError(format("derivation names are not allowed to end in ‘%1%’, at %2%")
             % drvExtension % posDrvName);
 
     if (outputHash != "") {
@@ -574,7 +574,7 @@ static void prim_derivationStrict(EvalState & state, const Pos & pos, Value * *
 
         HashType ht = parseHashType(outputHashAlgo);
         if (ht == htUnknown)
-            throw EvalError(format("unknown hash algorithm `%1%', at %2%") % outputHashAlgo % posDrvName);
+            throw EvalError(format("unknown hash algorithm ‘%1%’, at %2%") % outputHashAlgo % posDrvName);
         Hash h = parseHash16or32(ht, outputHash);
         outputHash = printHash(h);
         if (outputHashRecursive) outputHashAlgo = "r:" + outputHashAlgo;
@@ -610,7 +610,7 @@ static void prim_derivationStrict(EvalState & state, const Pos & pos, Value * *
     /* Write the resulting term into the Nix store directory. */
     Path drvPath = writeDerivation(*store, drv, drvName, state.repair);
 
-    printMsg(lvlChatty, format("instantiated `%1%' -> `%2%'")
+    printMsg(lvlChatty, format("instantiated ‘%1%’ -> ‘%2%’")
         % drvName % drvPath);
 
     /* Optimisation, but required in read-only mode! because in that
@@ -659,7 +659,7 @@ static void prim_storePath(EvalState & state, const Pos & pos, Value * * args, V
        e.g. nix-push does the right thing. */
     if (!isStorePath(path)) path = canonPath(path, true);
     if (!isInStore(path))
-        throw EvalError(format("path `%1%' is not in the Nix store, at %2%") % path % pos);
+        throw EvalError(format("path ‘%1%’ is not in the Nix store, at %2%") % path % pos);
     Path path2 = toStorePath(path);
     if (!settings.readOnlyMode)
         store->ensurePath(path2);
@@ -673,7 +673,7 @@ static void prim_pathExists(EvalState & state, const Pos & pos, Value * * args,
     PathSet context;
     Path path = state.coerceToPath(pos, *args[0], context);
     if (!context.empty())
-        throw EvalError(format("string `%1%' cannot refer to other paths, at %2%") % path % pos);
+        throw EvalError(format("string ‘%1%’ cannot refer to other paths, at %2%") % path % pos);
     mkBool(v, pathExists(path));
 }
 
@@ -704,7 +704,7 @@ static void prim_readFile(EvalState & state, const Pos & pos, Value * * args, Va
     PathSet context;
     Path path = state.coerceToPath(pos, *args[0], context);
     if (!context.empty())
-        throw EvalError(format("string `%1%' cannot refer to other paths, at %2%") % path % pos);
+        throw EvalError(format("string ‘%1%’ cannot refer to other paths, at %2%") % path % pos);
     mkString(v, readFile(path).c_str());
 }
 
@@ -729,7 +729,7 @@ static void prim_findFile(EvalState & state, const Pos & pos, Value * * args, Va
 
         i = v2.attrs->find(state.symbols.create("path"));
         if (i == v2.attrs->end())
-            throw EvalError(format("attribute `path' missing, at %1%") % pos);
+            throw EvalError(format("attribute ‘path’ missing, at %1%") % pos);
         string path = state.coerceToPath(pos, *i->value, context);
 
         searchPath.push_back(std::pair<string, Path>(prefix, path));
@@ -740,7 +740,7 @@ static void prim_findFile(EvalState & state, const Pos & pos, Value * * args, Va
     try {
         realiseContext(context);
     } catch (InvalidPathError & e) {
-        throw EvalError(format("cannot find `%1%', since path `%2%' is not valid, at %3%")
+        throw EvalError(format("cannot find ‘%1%’, since path ‘%2%’ is not valid, at %3%")
             % path % e.path % pos);
     }
 
@@ -799,7 +799,7 @@ static void prim_toFile(EvalState & state, const Pos & pos, Value * * args, Valu
         Path path = *i;
         if (path.at(0) == '=') path = string(path, 1);
         if (isDerivation(path))
-            throw EvalError(format("in `toFile': the file `%1%' cannot refer to derivation outputs, at %2%") % name % pos);
+            throw EvalError(format("in ‘toFile’: the file ‘%1%’ cannot refer to derivation outputs, at %2%") % name % pos);
         refs.insert(path);
     }
 
@@ -829,7 +829,7 @@ struct FilterFromExpr : PathFilter
     {
         struct stat st;
         if (lstat(path.c_str(), &st))
-            throw SysError(format("getting attributes of path `%1%'") % path);
+            throw SysError(format("getting attributes of path ‘%1%’") % path);
 
         /* Call the filter function.  The first argument is the path,
            the second is a string indicating the type of the file. */
@@ -859,11 +859,11 @@ static void prim_filterSource(EvalState & state, const Pos & pos, Value * * args
     PathSet context;
     Path path = state.coerceToPath(pos, *args[1], context);
     if (!context.empty())
-        throw EvalError(format("string `%1%' cannot refer to other paths, at %2%") % path % pos);
+        throw EvalError(format("string ‘%1%’ cannot refer to other paths, at %2%") % path % pos);
 
     state.forceValue(*args[0]);
     if (args[0]->type != tLambda)
-        throw TypeError(format("first argument in call to `filterSource' is not a function but %1%, at %2%") % showType(*args[0]) % pos);
+        throw TypeError(format("first argument in call to ‘filterSource’ is not a function but %1%, at %2%") % showType(*args[0]) % pos);
 
     FilterFromExpr filter(state, *args[0]);
 
@@ -906,7 +906,7 @@ void prim_getAttr(EvalState & state, const Pos & pos, Value * * args, Value & v)
     // !!! Should we create a symbol here or just do a lookup?
     Bindings::iterator i = args[1]->attrs->find(state.symbols.create(attr));
     if (i == args[1]->attrs->end())
-        throw EvalError(format("attribute `%1%' missing, at %2%") % attr % pos);
+        throw EvalError(format("attribute ‘%1%’ missing, at %2%") % attr % pos);
     // !!! add to stack trace?
     if (state.countCalls && i->pos) state.attrSelects[*i->pos]++;
     state.forceValue(*i->value);
@@ -986,14 +986,14 @@ static void prim_listToAttrs(EvalState & state, const Pos & pos, Value * * args,
 
         Bindings::iterator j = v2.attrs->find(state.sName);
         if (j == v2.attrs->end())
-            throw TypeError(format("`name' attribute missing in a call to `listToAttrs', at %1%") % pos);
+            throw TypeError(format("‘name’ attribute missing in a call to ‘listToAttrs’, at %1%") % pos);
         string name = state.forceStringNoCtx(*j->value, pos);
 
         Symbol sym = state.symbols.create(name);
         if (seen.find(sym) == seen.end()) {
             Bindings::iterator j2 = v2.attrs->find(state.symbols.create(state.sValue));
             if (j2 == v2.attrs->end())
-                throw TypeError(format("`value' attribute missing in a call to `listToAttrs', at %1%") % pos);
+                throw TypeError(format("‘value’ attribute missing in a call to ‘listToAttrs’, at %1%") % pos);
 
             v.attrs->push_back(Attr(sym, j2->value, j2->pos));
             seen.insert(sym);
@@ -1039,7 +1039,7 @@ static void prim_functionArgs(EvalState & state, const Pos & pos, Value * * args
 {
     state.forceValue(*args[0]);
     if (args[0]->type != tLambda)
-        throw TypeError(format("`functionArgs' requires a function, at %1%") % pos);
+        throw TypeError(format("‘functionArgs’ requires a function, at %1%") % pos);
 
     if (!args[0]->lambda.fun->matchAttrs) {
         state.mkAttrs(v, 0);
@@ -1098,7 +1098,7 @@ static void prim_tail(EvalState & state, const Pos & pos, Value * * args, Value
 {
     state.forceList(*args[0], pos);
     if (args[0]->list.length == 0)
-        throw Error(format("`tail' called on an empty list, at %1%") % pos);
+        throw Error(format("‘tail’ called on an empty list, at %1%") % pos);
     state.mkList(v, args[0]->list.length - 1);
     for (unsigned int n = 0; n < v.list.length; ++n)
         v.list.elems[n] = args[0]->list.elems[n + 1];
@@ -1247,7 +1247,7 @@ static void prim_substring(EvalState & state, const Pos & pos, Value * * args, V
     PathSet context;
     string s = state.coerceToString(pos, *args[2], context);
 
-    if (start < 0) throw EvalError(format("negative start position in `substring', at %1%") % pos);
+    if (start < 0) throw EvalError(format("negative start position in ‘substring’, at %1%") % pos);
 
     mkString(v, (unsigned int) start >= s.size() ? "" : string(s, start, len), context);
 }
@@ -1297,7 +1297,7 @@ static void prim_hashString(EvalState & state, const Pos & pos, Value * * args,
     string type = state.forceStringNoCtx(*args[0], pos);
     HashType ht = parseHashType(type);
     if (ht == htUnknown)
-      throw Error(format("unknown hash type `%1%', at %2%") % type % pos);
+      throw Error(format("unknown hash type ‘%1%’, at %2%") % type % pos);
 
     PathSet context; // discarded
     string s = state.forceString(*args[1], context);