Fix indentation rules for

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

1 files changed, 61 insertions, 65 deletions

diff --git a/lisp/emacs-lisp/cl-indent.el b/lisp/emacs-lisp/cl-indent.el
index 9e179432de4..c072cac0c7e 100644
--- a/lisp/emacs-lisp/cl-indent.el
+++ b/lisp/emacs-lisp/cl-indent.el
@@ -370,74 +370,70 @@ by `lisp-body-indent'."
 
 (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))))