Fix indentation rules for

multiple-value-setf and multiple-value-list.

diff --git a/lisp/emacs-lisp/cl-indent.el b/lisp/emacs-lisp/cl-indent.el
index 9e179432de46cb82328f24954e94dea6497ac0ce..c072cac0c7e19a4a0e1f2268c66aaaf244eac921 100644 (file)
--- a/lisp/emacs-lisp/cl-indent.el
+++ b/lisp/emacs-lisp/cl-indent.el
@@ -370,74 +370,70 @@ by `lisp-body-indent'."
 \f
 (let ((l '((block 1)
           (catch 1)
-           (case        (4 &rest (&whole 2 &rest 1)))
-           (ccase . case) (ecase . case)
-           (typecase . case) (etypecase . case) (ctypecase . case)
-           (catch 1)
-           (cond        (&rest (&whole 2 &rest 1)))
-           (block 1)
-           (defvar      (4 2 2))
-           (defconstant . defvar) (defparameter . defvar)
-           (define-modify-macro
-                        (4 &body))
-           (define-setf-method
-                        (4 (&whole 4 &rest 1) &body))
-           (defsetf     (4 (&whole 4 &rest 1) 4 &body))
-           (defun       (4 (&whole 4 &rest 1) &body))
-           (defmacro . defun) (deftype . defun)
-           (defstruct   ((&whole 4 &rest (&whole 2 &rest 1))
-                         &rest (&whole 2 &rest 1)))
-           (destructuring-bind
-                        ((&whole 6 &rest 1) 4 &body))
-           (do          lisp-indent-do)
-           (do* . do)
-           (dolist      ((&whole 4 2 1) &body))
-           (dotimes . dolist)
-           (eval-when  1)
-           (flet        ((&whole 4 &rest (&whole 1 (&whole 4 &rest 1) &body))
-                         &body))
-           (labels . flet)
-           (macrolet . flet)
-           ;; `else-body' style
-           (if          (nil nil &body))
-           ;; single-else style (then and else equally indented)
-           (if          (&rest nil))
-           ;(lambda     ((&whole 4 &rest 1) &body))
-           (lambda      ((&whole 4 &rest 1)
-                         &rest lisp-indent-function-lambda-hack))
-           (let         ((&whole 4 &rest (&whole 1 1 2)) &body))
-           (let* . let)
-           (compiler-let . let) ;barf
-           (locally    1)
-           ;(loop ...)
-           (multiple-value-bind
-                        ((&whole 6 &rest 1) 4 &body))
-           (multiple-value-call
+          (case        (4 &rest (&whole 2 &rest 1)))
+          (ccase . case) (ecase . case)
+          (typecase . case) (etypecase . case) (ctypecase . case)
+          (catch 1)
+          (cond        (&rest (&whole 2 &rest 1)))
+          (block 1)
+          (defvar      (4 2 2))
+          (defconstant . defvar) (defparameter . defvar)
+          (define-modify-macro
                        (4 &body))
-           (multiple-value-list 1)
-           (multiple-value-prog1 1)
-           (multiple-value-setq
-                       (4 2))
-           ;; Combines the worst features of BLOCK, LET and TAGBODY
-           (prog        ((&whole 4 &rest 1) &rest lisp-indent-tagbody))
-           (prog* . prog)
-           (prog1 1)
-           (prog2 2)
-           (progn 0)
-           (progv       (4 4 &body))
-           (return 0)
-           (return-from (nil &body))
-           (tagbody     lisp-indent-tagbody)
-           (throw 1)
-           (unless 1)
-           (unwind-protect
-                        (5 &body))
-           (when 1))))
+          (define-setf-method
+                       (4 (&whole 4 &rest 1) &body))
+          (defsetf     (4 (&whole 4 &rest 1) 4 &body))
+          (defun       (4 (&whole 4 &rest 1) &body))
+          (defmacro . defun) (deftype . defun)
+          (defstruct   ((&whole 4 &rest (&whole 2 &rest 1))
+                        &rest (&whole 2 &rest 1)))
+          (destructuring-bind
+                       ((&whole 6 &rest 1) 4 &body))
+          (do          lisp-indent-do)
+          (do* . do)
+          (dolist      ((&whole 4 2 1) &body))
+          (dotimes . dolist)
+          (eval-when   1)
+          (flet        ((&whole 4 &rest (&whole 1 (&whole 4 &rest 1) &body))
+                        &body))
+          (labels . flet)
+          (macrolet . flet)
+          ;; `else-body' style
+          (if          (nil nil &body))
+          ;; single-else style (then and else equally indented)
+          (if          (&rest nil))
+          ;(lambda     ((&whole 4 &rest 1) &body))
+          (lambda      ((&whole 4 &rest 1)
+                        &rest lisp-indent-function-lambda-hack))
+          (let         ((&whole 4 &rest (&whole 1 1 2)) &body))
+          (let* . let)
+          (compiler-let . let) ;barf
+          (locally 1)
+          ;(loop ...)
+          (multiple-value-bind ((&whole 6 &rest 1) 4 &body))
+          (multiple-value-call (4 &body))
+          (multiple-value-prog1 1)
+          (multiple-value-setq (4 2))
+          (multiple-value-setf . multiple-value-setq)
+          ;; Combines the worst features of BLOCK, LET and TAGBODY
+          (prog        ((&whole 4 &rest 1) &rest lisp-indent-tagbody))
+          (prog* . prog)
+          (prog1 1)
+          (prog2 2)
+          (progn 0)
+          (progv       (4 4 &body))
+          (return 0)
+          (return-from (nil &body))
+          (tagbody     lisp-indent-tagbody)
+          (throw 1)
+          (unless 1)
+          (unwind-protect (5 &body))
+          (when 1))))
   (while l
     (put (car (car l)) 'common-lisp-indent-function
-         (if (symbolp (cdr (car l)))
-             (get (cdr (car l)) 'common-lisp-indent-function)
-             (car (cdr (car l)))))
+        (if (symbolp (cdr (car l)))
+            (get (cdr (car l)) 'common-lisp-indent-function)
+            (car (cdr (car l)))))
     (setq l (cdr l))))
 
 \f