Merge from emacs--devo--0

Patches applied:

 * emacs--devo--0  (patch 846-851)

   - Update from CVS
   - Merge from emacs--rel--22

 * emacs--rel--22  (patch 88-92)

   - Update from CVS
   - Merge from gnus--rel--5.10

 * gnus--rel--5.10  (patch 242-244)

   - Update from CVS

Revision: emacs@sv.gnu.org/emacs--unicode--0--patch-246

lisp/emacs-lisp/autoload.el

@@ -209,6 +209,7 @@ put the output in."
 	    (setcdr p nil)
 	    (princ "\n(" outbuf)
 	    (let ((print-escape-newlines t)
+                  (print-quoted t)
 		  (print-escape-nonascii t))
 	      (dolist (elt form)
 		(prin1 elt outbuf)
@@ -232,6 +233,7 @@ put the output in."
 		       outbuf))
 	      (terpri outbuf)))
 	(let ((print-escape-newlines t)
+              (print-quoted t)
 	      (print-escape-nonascii t))
 	  (print form outbuf)))))))
 

lisp/emacs-lisp/backquote.el

@@ -118,10 +118,28 @@ Vectors work just like lists.  Nested backquotes are permitted."
 ;; constant, 1 => to be unquoted, 2 => to be spliced in.
 ;; The top-level backquote macro just discards the tag.
 
-(defun backquote-process (s)
+(defun backquote-delay-process (s level)
+  "Process a (un|back|splice)quote inside a backquote.
+This simply recurses through the body."
+  (let ((exp (backquote-listify (list (backquote-process (nth 1 s) level)
+                                      (cons 0 (list 'quote (car s))))
+                                '(0))))
+    (if (eq (car-safe exp) 'quote)
+        (cons 0 (list 'quote s))
+      (cons 1 exp))))
+
+(defun backquote-process (s &optional level)
+  "Process the body of a backquote.
+S is the body.  Returns a cons cell whose cdr is piece of code which
+is the macro-expansion of S, and whose car is a small integer whose value
+can either indicate that the code is constant (0), or not (1), or returns
+a list which should be spliced into its environment (2).
+LEVEL is only used internally and indicates the nesting level:
+0 (the default) is for the toplevel nested inside a single backquote."
+  (unless level (setq level 0))
   (cond
    ((vectorp s)
-    (let ((n (backquote-process (append s ()))))
+    (let ((n (backquote-process (append s ()) level)))
       (if (= (car n) 0)
 	  (cons 0 s)
 	(cons 1 (cond
@@ -138,11 +156,15 @@ Vectors work just like lists.  Nested backquotes are permitted."
 		s
 	      (list 'quote s))))
    ((eq (car s) backquote-unquote-symbol)
-    (cons 1 (nth 1 s)))
+    (if (<= level 0)
+        (cons 1 (nth 1 s))
+      (backquote-delay-process s (1- level))))
    ((eq (car s) backquote-splice-symbol)
-    (cons 2 (nth 1 s)))
+    (if (<= level 0)
+        (cons 2 (nth 1 s))
+      (backquote-delay-process s (1- level))))
    ((eq (car s) backquote-backquote-symbol)
-    (backquote-process (cdr (backquote-process (nth 1 s)))))
+      (backquote-delay-process s (1+ level)))
    (t
     (let ((rest s)
 	  item firstlist list lists expression)
@@ -154,11 +176,13 @@ Vectors work just like lists.  Nested backquotes are permitted."
       ;; at the beginning, put them in FIRSTLIST,
       ;; as a list of tagged values (TAG . FORM).
       ;; If there are any at the end, they go in LIST, likewise.
-      (while (consp rest)
-	;; Turn . (, foo) into (,@ foo).
-	(if (eq (car rest) backquote-unquote-symbol)
-	    (setq rest (list (list backquote-splice-symbol (nth 1 rest)))))
-	(setq item (backquote-process (car rest)))
+      (while (and (consp rest)
+                  ;; Stop if the cdr is an expression inside a backquote or
+                  ;; unquote since this needs to go recursively through
+                  ;; backquote-process.
+                  (not (or (eq (car rest) backquote-unquote-symbol)
+                           (eq (car rest) backquote-backquote-symbol))))
+	(setq item (backquote-process (car rest) level))
 	(cond
 	 ((= (car item) 2)
 	  ;; Put the nonspliced items before the first spliced item
@@ -168,8 +192,8 @@ Vectors work just like lists.  Nested backquotes are permitted."
 		    list nil))
 	  ;; Otherwise, put any preceding nonspliced items into LISTS.
 	  (if list
-	      (setq lists (cons (backquote-listify list '(0 . nil)) lists)))
-	  (setq lists (cons (cdr item) lists))
+	      (push (backquote-listify list '(0 . nil)) lists))
+	  (push (cdr item) lists)
 	  (setq list nil))
 	 (t
 	  (setq list (cons item list))))
@@ -177,8 +201,8 @@ Vectors work just like lists.  Nested backquotes are permitted."
       ;; Handle nonsplicing final elements, and the tail of the list
       ;; (which remains in REST).
       (if (or rest list)
-	  (setq lists (cons (backquote-listify list (backquote-process rest))
-			    lists)))
+	  (push (backquote-listify list (backquote-process rest level))
+                lists))
       ;; Turn LISTS into a form that produces the combined list.
       (setq expression
 	    (if (or (cdr lists)
@@ -221,5 +245,5 @@ Vectors work just like lists.  Nested backquotes are permitted."
 	tail))
      (t (cons 'list heads)))))
 
-;;; arch-tag: 1a26206a-6b5e-4c56-8e24-2eef0f7e0e7a
+;; arch-tag: 1a26206a-6b5e-4c56-8e24-2eef0f7e0e7a
 ;;; backquote.el ends here

lisp/emacs-lisp/byte-opt.el

@@ -564,7 +564,7 @@
 	       (cons fn args)))))))
 
 (defun byte-optimize-all-constp (list)
-  "Non-nil iff all elements of LIST satisfy `byte-compile-constp'."
+  "Non-nil if all elements of LIST satisfy `byte-compile-constp'."
   (let ((constant t))
     (while (and list constant)
       (unless (byte-compile-constp (car list))

lisp/emacs-lisp/checkdoc.el

@@ -1243,7 +1243,8 @@ generating a buffered list of errors."
 ;;;###autoload
 (define-minor-mode checkdoc-minor-mode
   "Toggle Checkdoc minor mode, a mode for checking Lisp doc strings.
-With prefix ARG, turn Checkdoc minor mode on iff ARG is positive.
+With prefix ARG, turn Checkdoc minor mode on if ARG is positive, otherwise
+turn it off.
 
 In Checkdoc minor mode, the usual bindings for `eval-defun' which is
 bound to \\<checkdoc-minor-mode-map>\\[checkdoc-eval-defun] and `checkdoc-eval-current-buffer' are overridden to include

lisp/emacs-lisp/cl-loaddefs.el

@@ -10,7 +10,7 @@
 ;;;;;;  ceiling* floor* isqrt lcm gcd cl-progv-before cl-set-frame-visible-p
 ;;;;;;  cl-map-overlays cl-map-intervals cl-map-keymap-recursively
 ;;;;;;  notevery notany every some mapcon mapcan mapl maplist map
-;;;;;;  cl-mapcar-many equalp coerce) "cl-extra" "cl-extra.el" "47c92504dda976a632c2c10bedd4b6a4")
+;;;;;;  cl-mapcar-many equalp coerce) "cl-extra" "cl-extra.el" "53c2b3ede19dac62cff13a37f58cdf9c")
 ;;; Generated autoloads from cl-extra.el
 
 (autoload (quote coerce) "cl-extra" "\
@@ -745,7 +745,7 @@ Not documented
 ;;;;;;  find nsubstitute-if-not nsubstitute-if nsubstitute substitute-if-not
 ;;;;;;  substitute-if substitute delete-duplicates remove-duplicates
 ;;;;;;  delete-if-not delete-if delete* remove-if-not remove-if remove*
-;;;;;;  replace fill reduce) "cl-seq" "cl-seq.el" "8805f76626399794931f5db36ddf855f")
+;;;;;;  replace fill reduce) "cl-seq" "cl-seq.el" "c972a97c053d4e001ac1d1012c315b28")
 ;;; Generated autoloads from cl-seq.el
 
 (autoload (quote reduce) "cl-seq" "\

lisp/emacs-lisp/easymenu.el

@@ -546,7 +546,7 @@ earlier by `easy-menu-define' or `easy-menu-create-menu'."
     (easy-menu-define-key map (easy-menu-intern (car item)) (cdr item) before)))
 
 (defun easy-menu-item-present-p (map path name)
-  "In submenu of MAP with path PATH, return non-nil iff item NAME is present.
+  "In submenu of MAP with path PATH, return non-nil if item NAME is present.
 MAP and PATH are defined as in `easy-menu-add-item'.
 NAME should be a string, the name of the element to be looked for."
   (easy-menu-return-item (easy-menu-get-map map path) name))

lisp/emacs-lisp/eldoc.el

@@ -267,13 +267,13 @@ Emacs Lisp mode) that support Eldoc.")
 ;; Return a string containing the function parameter list, or 1-line
 ;; docstring if function is a subr and no arglist is obtainable from the
 ;; docstring or elsewhere.
-(defun eldoc-get-fnsym-args-string (sym argument-index)
+(defun eldoc-get-fnsym-args-string (sym &optional argument-index)
   (let ((args nil)
         (doc nil))
     (cond ((not (and sym (symbolp sym) (fboundp sym))))
           ((and (eq sym (aref eldoc-last-data 0))
                 (eq 'function (aref eldoc-last-data 2)))
-           (setq args (aref eldoc-last-data 1)))
+           (setq doc (aref eldoc-last-data 1)))
 	  ((setq doc (help-split-fundoc (documentation sym t) sym))
 	   (setq args (car doc))
 	   (string-match "\\`[^ )]* ?" args)
@@ -281,8 +281,9 @@ Emacs Lisp mode) that support Eldoc.")
 	   (eldoc-last-data-store sym args 'function))
           (t
            (setq args (eldoc-function-argstring sym))))
-    (when args
-      (setq doc (eldoc-highlight-function-argument sym args argument-index)))
+    (and args
+         argument-index
+         (setq doc (eldoc-highlight-function-argument sym args argument-index)))
     doc))
 
 ;; Highlight argument INDEX in ARGS list for SYM.

lisp/emacs-lisp/rx.el

@@ -554,7 +554,7 @@ appended to R will apply to all of R.  For example, \"a\"
 
 This function may return false negatives, but it will not
 return false positives.  It is nevertheless useful in
-situations where an efficiency shortcut can be taken iff a
+situations where an efficiency shortcut can be taken only if a
 regexp is atomic.  The function can be improved to detect
 more cases of atomic regexps.  Presently, this function
 detects the following categories of atomic regexp;

lisp/emacs-lisp/unsafep.el

@@ -212,7 +212,7 @@ of symbols with local bindings."
 
 
 (defun unsafep-function (fun)
-  "Return nil iff FUN is a safe function.
+  "Return nil if FUN is a safe function.
 \(either a safe lambda or a symbol that names a safe function).  Otherwise
 result is a reason code."
   (cond