12 files changed, 44 insertions, 44 deletions

diff --git a/lisp/eshell/em-dirs.el b/lisp/eshell/em-dirs.el
index 8a3b5817d5f..ac1616d504f 100644
--- a/lisp/eshell/em-dirs.el
+++ b/lisp/eshell/em-dirs.el
@@ -71,7 +71,7 @@ they lack somewhat in feel from the typical shell equivalents."
   "The function used to normalize the value of Eshell's `pwd'.
 The value returned by `pwd' is also used when recording the
 last-visited directory in the last-dir-ring, so it will affect the
-form of the list used by 'cd ='."
+form of the list used by `cd ='."
   :type '(radio (function-item file-truename)
                 (function-item expand-file-name)
                 (function-item identity)
@@ -115,7 +115,7 @@ calls \"ls\" and references `eshell-last-arguments'."
   :group 'eshell-dirs)
 
 (defcustom eshell-pushd-tohome nil
-  "If non-nil, make pushd with no arg behave as 'pushd ~' (like `cd').
+  "If non-nil, make pushd with no arg behave as `pushd ~' (like `cd').
 This mirrors the optional behavior of tcsh."
   :type 'boolean
   :group 'eshell-dirs)
@@ -150,11 +150,11 @@ If it is nil, the last-dir-ring will not be written to disk."
   "If non-nil, the size of the directory history ring.
 This ring is added to every time `cd' or `pushd' is used.  It simply
 stores the most recent directory locations Eshell has been in.  To
-return to the most recent entry, use 'cd -' (equivalent to 'cd -0').
-To return to an older entry, use 'cd -N', where N is an integer less
+return to the most recent entry, use `cd -' (equivalent to `cd -0').
+To return to an older entry, use `cd -N', where N is an integer less
 than `eshell-last-dir-ring-size'.  To return to the last directory
-matching a particular regexp, use 'cd =REGEXP'.  To display the
-directory history list, use 'cd ='.
+matching a particular regexp, use `cd =REGEXP'.  To display the
+directory history list, use `cd ='.
 
 This mechanism is very similar to that provided by `pushd', except
 it's far more automatic.  `pushd' allows the user to decide which
@@ -313,7 +313,7 @@ Thus, this does not include the current directory.")
       path)))
 
 (defun eshell-expand-multiple-dots (path)
-  "Convert '...' to '../..', '....' to '../../..', etc..
+  "Convert `...' to `../..', `....' to `../../..', etc..
 
 With the following piece of advice, you can make this functionality
 available in most of Emacs, with the exception of filename completion
@@ -364,7 +364,7 @@ in the minibuffer:
       (let ((curdir (eshell/pwd)))
         (if (string-match path curdir)
             (setq path (replace-match subpath nil nil curdir))
-          (error "Path substring '%s' not found" path))))
+          (error "Path substring ‘%s’ not found" path))))
      ((and path (string-match "^-\\([0-9]*\\)$" path))
       (let ((index (match-string 1 path)))
         (setq path
diff --git a/lisp/eshell/em-glob.el b/lisp/eshell/em-glob.el
index c7ebbf8c140..8abdd0058fb 100644
--- a/lisp/eshell/em-glob.el
+++ b/lisp/eshell/em-glob.el
@@ -193,7 +193,7 @@ The basic syntax is:
   *      .*      matches any group of characters (or none)
   #      *       matches zero or more occurrences of preceding
   ##     +       matches one or more occurrences of preceding
-  (x)    \(x\)   makes 'x' a regular expression group
+  (x)    \(x\)   makes ‘x’ a regular expression group
   |      \|      boolean OR within an expression group
   [a-b]  [a-b]   matches a character or range
   [^a]   [^a]    excludes a character or range
@@ -220,7 +220,7 @@ resulting regular expression."
                   matched-in-pattern (1+ op-begin))
           (let ((xlat (assq op-char eshell-glob-translate-alist)))
             (if (not xlat)
-                (error "Unrecognized globbing character '%c'" op-char)
+                (error "Unrecognized globbing character ‘%c’" op-char)
               (if (stringp (cdr xlat))
                   (setq regexp (concat regexp (cdr xlat))
                         matched-in-pattern (1+ op-begin))
diff --git a/lisp/eshell/em-pred.el b/lisp/eshell/em-pred.el
index 289d37dd580..539080f35c4 100644
--- a/lisp/eshell/em-pred.el
+++ b/lisp/eshell/em-pred.el
@@ -193,7 +193,7 @@ EXAMPLES:
   ***/*~f*(-/)  recursively (though not traversing symlinks),
                 find all directories (or symlinks referring to
                 directories) whose names do not begin with f.
-  e*(*Lk+50)    executables 50k or larger beginning with 'e'")
+  e*(*Lk+50)    executables 50k or larger beginning with ‘e’")
 
 (defvar eshell-modifier-help-string
   "Eshell modifier quick reference:
@@ -318,7 +318,7 @@ resultant list of strings."
                     (if (and func (functionp func))
                         (setq preds (eshell-add-pred-func func preds
                                                           negate follow))
-                      (error "Invalid function predicate '%s'"
+                      (error "Invalid function predicate ‘%s’"
                              (eshell-stringify func))))
                 (error "Invalid function predicate")))
              ((eq char ?^)
@@ -336,20 +336,20 @@ resultant list of strings."
                               (cons `(lambda (lst)
                                        (mapcar (function ,func) lst))
                                     mods))
-                      (error "Invalid function modifier '%s'"
+                      (error "Invalid function modifier ‘%s’"
                              (eshell-stringify func))))
                 (error "Invalid function modifier")))
              ((eq char ?:)
               (forward-char)
               (let ((mod (assq (char-after) eshell-modifier-alist)))
                 (if (not mod)
-                    (error "Unknown modifier character '%c'" (char-after))
+                    (error "Unknown modifier character ‘%c’" (char-after))
                   (forward-char)
                   (setq mods (cons (eval (cdr mod)) mods)))))
              (t
               (let ((pred (assq char eshell-predicate-alist)))
                 (if (not pred)
-                    (error "Unknown predicate character '%c'" char)
+                    (error "Unknown predicate character ‘%c’" char)
                   (forward-char)
                   (setq preds
                         (eshell-add-pred-func (eval (cdr pred)) preds
@@ -451,7 +451,7 @@ resultant list of strings."
 (defun eshell-pred-file-type (type)
   "Return a test which tests that the file is of a certain TYPE.
 TYPE must be a character, and should be one of the possible options
-that 'ls -l' will show in the first column of its display. "
+that `ls -l' will show in the first column of its display. "
   (when (eq type ?%)
     (setq type (char-after))
     (if (memq type '(?b ?c))
diff --git a/lisp/eshell/em-script.el b/lisp/eshell/em-script.el
index 04f3a9828e2..8e65e440417 100644
--- a/lisp/eshell/em-script.el
+++ b/lisp/eshell/em-script.el
@@ -45,7 +45,7 @@ commands, as a script file."
 (defcustom eshell-login-script (expand-file-name "login" eshell-directory-name)
   "If non-nil, a file to invoke when starting up Eshell interactively.
 This file should be a file containing Eshell commands, where comment
-lines begin with '#'."
+lines begin with ‘#’."
   :type 'file
   :group 'eshell-script)
 
@@ -89,7 +89,7 @@ This includes when running `eshell-command'."
 
 (defun eshell-source-file (file &optional args subcommand-p)
   "Execute a series of Eshell commands in FILE, passing ARGS.
-Comments begin with '#'."
+Comments begin with ‘#’."
   (interactive "f")
   (let ((orig (point))
         (here (point-max))
diff --git a/lisp/eshell/em-term.el b/lisp/eshell/em-term.el
index 9ac281372cf..a8fa9733b42 100644
--- a/lisp/eshell/em-term.el
+++ b/lisp/eshell/em-term.el
@@ -40,7 +40,7 @@
 ;;;###autoload
 (progn
 (defgroup eshell-term nil
-  "This module causes visual commands (e.g., 'vi') to be executed by
+  "This module causes visual commands (e.g., `vi') to be executed by
 the `term' package, which comes with Emacs.  This package handles most
 of the ANSI control codes, allowing curses-based applications to run
 within an Emacs window.  The variable `eshell-visual-commands' defines
diff --git a/lisp/eshell/em-unix.el b/lisp/eshell/em-unix.el
index c50a874629b..210e74dc1b7 100644
--- a/lisp/eshell/em-unix.el
+++ b/lisp/eshell/em-unix.el
@@ -168,10 +168,10 @@ Otherwise, Emacs will attempt to use rsh to invoke du on the remote machine."
 
 (defun eshell/info (&rest args)
   "Run the info command in-frame with the same behavior as command-line `info', ie:
-  'info'           => goes to top info window
-  'info arg1'      => IF arg1 is a file, then visits arg1
-  'info arg1'      => OTHERWISE goes to top info window and then menu item arg1
-  'info arg1 arg2' => does action for arg1 (either visit-file or menu-item) and then menu item arg2
+  `info'           => goes to top info window
+  `info arg1'      => IF arg1 is a file, then visits arg1
+  `info arg1'      => OTHERWISE goes to top info window and then menu item arg1
+  `info arg1 arg2' => does action for arg1 (either visit-file or menu-item) and then menu item arg2
   etc."
   (eval-and-compile (require 'info))
   (let ((file (cond
@@ -579,7 +579,7 @@ Copy SOURCE to DEST, or multiple SOURCE(s) to DIRECTORY.")
 Create a link to the specified TARGET with optional LINK_NAME.  If there is
 more than one TARGET, the last argument must be a directory;  create links
 in DIRECTORY to each TARGET.  Create hard links by default, symbolic links
-with '--symbolic'.  When creating hard links, each TARGET must exist.")
+with `--symbolic'.  When creating hard links, each TARGET must exist.")
    (let ((no-dereference t))
      (eshell-mvcpln-template "ln" "linking"
                              (if symbolic
diff --git a/lisp/eshell/esh-arg.el b/lisp/eshell/esh-arg.el
index 49ba72735da..93d795b1351 100644
--- a/lisp/eshell/esh-arg.el
+++ b/lisp/eshell/esh-arg.el
@@ -237,7 +237,7 @@ Point is left at the end of the arguments."
                    (let* ((here (point))
                           (arg (eshell-parse-argument)))
                      (if (= (point) here)
-                         (error "Failed to parse argument '%s'"
+                         (error "Failed to parse argument `%s'"
                                 (buffer-substring here (point-max))))
                      (and arg (nconc args (list arg)))))))
               (throw 'eshell-incomplete (if (listp delim)
@@ -357,13 +357,13 @@ after are both returned."
           (goto-char (1+ end)))))))
 
 (defun eshell-parse-special-reference ()
-  "Parse a special syntax reference, of the form '#<args>'.
+  "Parse a special syntax reference, of the form `#<args>'.
 
 args           := `type' `whitespace' `arbitrary-args' | `arbitrary-args'
 type           := \"buffer\" or \"process\"
 arbitrary-args := any string of characters.
 
-If the form has no 'type', the syntax is parsed as if 'type' were
+If the form has no `type', the syntax is parsed as if `type' were
 \"buffer\"."
   (when (and (not eshell-current-argument)
              (not eshell-current-quoted)
diff --git a/lisp/eshell/esh-cmd.el b/lisp/eshell/esh-cmd.el
index d0c8cc422aa..efd85826f27 100644
--- a/lisp/eshell/esh-cmd.el
+++ b/lisp/eshell/esh-cmd.el
@@ -165,13 +165,13 @@ In order to substitute an alternate command form for execution, the
 hook function should throw it using the tag `eshell-replace-command'.
 For example:
 
-  (add-hook 'eshell-named-command-hook 'subst-with-cd)
+  (add-hook \\='eshell-named-command-hook \\='subst-with-cd)
   (defun subst-with-cd (command args)
-    (throw 'eshell-replace-command
+    (throw \\='eshell-replace-command
            (eshell-parse-command \"cd\" args)))
 
 Although useless, the above code will cause any non-glob, non-Lisp
-command (i.e., 'ls' as opposed to '*ls' or '(ls)') to be replaced by a
+command (i.e., `ls' as opposed to `*ls' or `(ls)') to be replaced by a
 call to `cd' using the arguments that were passed to the function."
   :type 'hook
   :group 'eshell-cmd)
@@ -243,7 +243,7 @@ return non-nil if the command is complex."
   "If non-nil, enable Eshell debugging code.
 This is slow, and only useful for debugging problems with Eshell.
 If you change this without using customize after Eshell has loaded,
-you must re-load 'esh-cmd.el'."
+you must re-load `esh-cmd.el'."
   :initialize 'custom-initialize-default
   :set (lambda (symbol value)
          (set symbol value)
@@ -390,7 +390,7 @@ hooks should be run before and after the command."
       (macroexp-progn commands))))
 
 (defun eshell-debug-command (tag subform)
-  "Output a debugging message to '*eshell last cmd*'."
+  "Output a debugging message to `*eshell last cmd*'."
   (let ((buf (get-buffer-create "*eshell last cmd*"))
         (text (eshell-stringify eshell-current-command)))
     (with-current-buffer buf
@@ -424,14 +424,14 @@ hooks should be run before and after the command."
     (setq terms (cdr terms))))
 
 (defun eshell-rewrite-sexp-command (terms)
-  "Rewrite a sexp in initial position, such as '(+ 1 2)'."
+  "Rewrite a sexp in initial position, such as `(+ 1 2)'."
   ;; this occurs when a Lisp expression is in first position
   (if (and (listp (car terms))
            (eq (caar terms) 'eshell-command-to-value))
       (car (cdar terms))))
 
 (defun eshell-rewrite-initial-subcommand (terms)
-  "Rewrite a subcommand in initial position, such as '{+ 1 2}'."
+  "Rewrite a subcommand in initial position, such as `{+ 1 2}'."
   (if (and (listp (car terms))
            (eq (caar terms) 'eshell-as-subcommand))
       (car terms)))
@@ -634,7 +634,7 @@ For an external command, it means an exit code of 0."
     final))
 
 (defun eshell-parse-subcommand-argument ()
-  "Parse a subcommand argument of the form '{command}'."
+  "Parse a subcommand argument of the form `{command}'."
   (if (and (not eshell-current-argument)
            (not eshell-current-quoted)
            (eq (char-after) ?\{)
diff --git a/lisp/eshell/esh-ext.el b/lisp/eshell/esh-ext.el
index 91c4f4b6095..81ffaa713da 100644
--- a/lisp/eshell/esh-ext.el
+++ b/lisp/eshell/esh-ext.el
@@ -66,7 +66,7 @@ loaded into memory, thus beginning a new process."
 This can be useful on systems like Windows, where the operating system
 doesn't support the execution bit for shell scripts; or in cases where
 you want to associate an interpreter with a particular kind of script
-file, but the language won't let you but a '#!' interpreter line in
+file, but the language won't let you but a `#!' interpreter line in
 the file, and you don't want to make it executable since nothing else
 but Eshell will be able to understand
 `eshell-interpreter-alist'."
diff --git a/lisp/eshell/esh-io.el b/lisp/eshell/esh-io.el
index dc731bc928a..749c481da3e 100644
--- a/lisp/eshell/esh-io.el
+++ b/lisp/eshell/esh-io.el
@@ -182,7 +182,7 @@ not be added to this variable."
                 #'eshell--apply-redirections))
 
 (defun eshell-parse-redirection ()
-  "Parse an output redirection, such as '2>'."
+  "Parse an output redirection, such as `2>'."
   (if (and (not eshell-current-quoted)
            (looking-at "\\([0-9]\\)?\\(<\\|>+\\)&?\\([0-9]\\)?\\s-*"))
       (if eshell-current-argument
diff --git a/lisp/eshell/esh-opt.el b/lisp/eshell/esh-opt.el
index 5b4cdb08830..2e929b05f49 100644
--- a/lisp/eshell/esh-opt.el
+++ b/lisp/eshell/esh-opt.el
@@ -178,9 +178,9 @@ This code doesn't really need to be macro expanded everywhere."
       (if extcmd
           (setq usage
                 (concat usage
-                        (format "
+                        (format-message "
 This command is implemented in Lisp.  If an unrecognized option is
-passed to this command, the external version '%s'
+passed to this command, the external version ‘%s’
 will be called instead." extcmd)))))
     (throw 'eshell-usage usage)))
 
diff --git a/lisp/eshell/esh-var.el b/lisp/eshell/esh-var.el
index 197a8e77cc7..f5110c38475 100644
--- a/lisp/eshell/esh-var.el
+++ b/lisp/eshell/esh-var.el
@@ -116,7 +116,7 @@
 (require 'ring)
 
 (defgroup eshell-var nil
-  "Variable interpolation is introduced whenever the '$' character
+  "Variable interpolation is introduced whenever the ‘$’ character
 appears unquoted in any argument (except when that argument is
 surrounded by single quotes).  It may be used to interpolate a
 variable value, a subcommand, or even the result of a Lisp form."
@@ -148,7 +148,7 @@ variable value, a subcommand, or even the result of a Lisp form."
 
 (defcustom eshell-variable-name-regexp "[A-Za-z0-9_-]+"
   "A regexp identifying what constitutes a variable name reference.
-Note that this only applies for '$NAME'.  If the syntax '$<NAME>' is
+Note that this only applies for `$NAME'.  If the syntax `$<NAME>' is
 used, then NAME can contain any character, including angle brackets,
 if they are quoted with a backslash."
   :type 'regexp
@@ -186,12 +186,12 @@ if they are quoted with a backslash."
 It is very similar in concept to what `eshell-user-aliases-list' does
 for commands.  Each member of this defines the name of a command,
 and the Lisp value to return for that variable if it is accessed
-via the syntax '$NAME'.
+via the syntax `$NAME'.
 
 If the value is a function, that function will be called with two
 arguments: the list of the indices that was used in the reference, and
 whether the user is requesting the length of the ultimate element.
-For example, a reference of '$NAME[10][20]' would result in the
+For example, a reference of `$NAME[10][20]' would result in the
 function for alias `NAME' being called (assuming it were aliased to a
 function), and the arguments passed to this function would be the list
 '(10 20)', and nil."
@@ -231,7 +231,7 @@ function), and the arguments passed to this function would be the list
               'eshell-complete-variable-assignment nil t)))
 
 (defun eshell-handle-local-variables ()
-  "Allow for the syntax 'VAR=val <command> <args>'."
+  "Allow for the syntax `VAR=val <command> <args>'."
   ;; strip off any null commands, which can only happen if a variable
   ;; evaluates to nil, such as "$var x", where `var' is nil.  The
   ;; command name in that case becomes `x', for compatibility with