Prefer directed to neutral quotes

Prefer directed to neutral quotes in docstings and diagnostics.
In docstrings, escape apostrophes that would otherwise be translated
to curved quotes using the newer, simpler rules.
* admin/unidata/unidata-gen.el (unidata-gen-table):
* lisp/align.el (align-region):
* lisp/allout.el (allout-mode, allout-solicit-alternate-bullet):
* lisp/bookmark.el (bookmark-default-annotation-text):
* lisp/calc/calc-aent.el (math-read-if, math-read-factor):
* lisp/calc/calc-lang.el (math-read-giac-subscr)
(math-read-math-subscr):
* lisp/calc/calc-misc.el (report-calc-bug):
* lisp/calc/calc-prog.el (calc-fix-token-name)
(calc-read-parse-table-part):
* lisp/cedet/ede/pmake.el (ede-proj-makefile-insert-dist-rules):
* lisp/cedet/semantic/complete.el (semantic-displayor-show-request):
* lisp/dabbrev.el (dabbrev-expand):
* lisp/emacs-lisp/checkdoc.el (checkdoc-this-string-valid-engine):
* lisp/emacs-lisp/elint.el (elint-get-top-forms):
* lisp/emacs-lisp/lisp-mnt.el (lm-verify):
* lisp/emulation/viper-cmd.el (viper-toggle-search-style):
* lisp/erc/erc-button.el (erc-nick-popup):
* lisp/erc/erc.el (erc-cmd-LOAD, erc-handle-login):
* lisp/eshell/em-dirs.el (eshell/cd):
* lisp/eshell/em-glob.el (eshell-glob-regexp):
* lisp/eshell/em-pred.el (eshell-parse-modifiers):
* lisp/eshell/esh-arg.el (eshell-parse-arguments):
* lisp/eshell/esh-opt.el (eshell-show-usage):
* lisp/files-x.el (modify-file-local-variable):
* lisp/filesets.el (filesets-add-buffer, filesets-remove-buffer)
(filesets-update-pre010505):
* lisp/find-cmd.el (find-generic, find-to-string):
* lisp/gnus/auth-source.el (auth-source-netrc-parse-entries):
* lisp/gnus/gnus-agent.el (gnus-agent-check-overview-buffer)
(gnus-agent-fetch-headers):
* lisp/gnus/gnus-int.el (gnus-start-news-server):
* lisp/gnus/gnus-registry.el:
(gnus-registry--split-fancy-with-parent-internal):
* lisp/gnus/gnus-score.el (gnus-summary-increase-score):
* lisp/gnus/gnus-start.el (gnus-convert-old-newsrc):
* lisp/gnus/gnus-topic.el (gnus-topic-rename):
* lisp/gnus/legacy-gnus-agent.el (gnus-agent-unlist-expire-days):
* lisp/gnus/nnmairix.el (nnmairix-widget-create-query):
* lisp/gnus/spam.el (spam-check-blackholes):
* lisp/mail/feedmail.el (feedmail-run-the-queue):
* lisp/mpc.el (mpc-playlist-rename):
* lisp/net/ange-ftp.el (ange-ftp-shell-command):
* lisp/net/mairix.el (mairix-widget-create-query):
* lisp/net/tramp-cache.el:
* lisp/obsolete/otodo-mode.el (todo-more-important-p):
* lisp/obsolete/pgg-gpg.el (pgg-gpg-process-region):
* lisp/obsolete/pgg-pgp.el (pgg-pgp-process-region):
* lisp/obsolete/pgg-pgp5.el (pgg-pgp5-process-region):
* lisp/org/ob-core.el (org-babel-goto-named-src-block)
(org-babel-goto-named-result):
* lisp/org/ob-fortran.el (org-babel-fortran-ensure-main-wrap):
* lisp/org/ob-ref.el (org-babel-ref-resolve):
* lisp/org/org-agenda.el (org-agenda-prepare):
* lisp/org/org-bibtex.el (org-bibtex-fields):
* lisp/org/org-clock.el (org-clock-notify-once-if-expired)
(org-clock-resolve):
* lisp/org/org-feed.el (org-feed-parse-atom-entry):
* lisp/org/org-habit.el (org-habit-parse-todo):
* lisp/org/org-mouse.el (org-mouse-popup-global-menu)
(org-mouse-context-menu):
* lisp/org/org-table.el (org-table-edit-formulas):
* lisp/org/ox.el (org-export-async-start):
* lisp/play/dunnet.el (dun-score, dun-help, dun-endgame-question)
(dun-rooms, dun-endgame-questions):
* lisp/progmodes/ada-mode.el (ada-goto-matching-start):
* lisp/progmodes/ada-xref.el (ada-find-executable):
* lisp/progmodes/antlr-mode.el (antlr-options-alists):
* lisp/progmodes/flymake.el (flymake-parse-err-lines)
(flymake-start-syntax-check-process):
* lisp/progmodes/python.el (python-define-auxiliary-skeleton):
* lisp/progmodes/sql.el (sql-comint):
* lisp/progmodes/verilog-mode.el (verilog-load-file-at-point):
* lisp/server.el (server-get-auth-key):
* lisp/subr.el (version-to-list):
* lisp/textmodes/reftex-ref.el (reftex-label):
* lisp/textmodes/reftex-toc.el (reftex-toc-rename-label):
* lisp/vc/ediff-diff.el (ediff-same-contents):
* lisp/vc/vc-cvs.el (vc-cvs-mode-line-string):
* test/automated/tramp-tests.el (tramp-test33-asynchronous-requests):
Use directed rather than neutral quotes in diagnostics.

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