lisp/emacs-lisp/cl-indent.el

   1 ;;; cl-indent.el --- enhanced lisp-indent mode
   2
   3 ;; Copyright (C) 1987, 2000-2011 Free Software Foundation, Inc.
   4
   5 ;; Author: Richard Mlynarik <mly@eddie.mit.edu>
   6 ;; Created: July 1987
   7 ;; Maintainer: FSF
   8 ;; Keywords: lisp, tools
   9 ;; Package: emacs
  10
  11 ;; This file is part of GNU Emacs.
  12
  13 ;; GNU Emacs is free software: you can redistribute it and/or modify
  14 ;; it under the terms of the GNU General Public License as published by
  15 ;; the Free Software Foundation, either version 3 of the License, or
  16 ;; (at your option) any later version.
  17
  18 ;; GNU Emacs is distributed in the hope that it will be useful,
  19 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  20 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21 ;; GNU General Public License for more details.
  22
  23 ;; You should have received a copy of the GNU General Public License
  24 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  25
  26 ;;; Commentary:
  27
  28 ;; This package supplies a single entry point, common-lisp-indent-function,
  29 ;; which performs indentation in the preferred style for Common Lisp code.
  30 ;; To enable it:
  31 ;;
  32 ;; (setq lisp-indent-function 'common-lisp-indent-function)
  33
  34 ;;; Code:
  35
  36 (eval-when-compile (require 'cl))
  37
  38 (defgroup lisp-indent nil
  39   "Indentation in Lisp."
  40   :group 'lisp)
  41
  42
  43 (defcustom lisp-indent-maximum-backtracking 3
  44   "Maximum depth to backtrack out from a sublist for structured indentation.
  45 If this variable is 0, no backtracking will occur and forms such as `flet'
  46 may not be correctly indented."
  47   :type 'integer
  48   :group 'lisp-indent)
  49
  50 (defcustom lisp-tag-indentation 1
  51   "Indentation of tags relative to containing list.
  52 This variable is used by the function `lisp-indent-tagbody'."
  53   :type 'integer
  54   :group 'lisp-indent)
  55
  56 (defcustom lisp-tag-body-indentation 3
  57   "Indentation of non-tagged lines relative to containing list.
  58 This variable is used by the function `lisp-indent-tagbody' to indent normal
  59 lines (lines without tags).
  60 The indentation is relative to the indentation of the parenthesis enclosing
  61 the special form.  If the value is t, the body of tags will be indented
  62 as a block at the same indentation as the first s-expression following
  63 the tag.  In this case, any forms before the first tag are indented
  64 by `lisp-body-indent'."
  65   :type 'integer
  66   :group 'lisp-indent)
  67
  68 (defcustom lisp-backquote-indentation t
  69   "Whether or not to indent backquoted lists as code.
  70 If nil, indent backquoted lists as data, i.e., like quoted lists."
  71   :type 'boolean
  72   :group 'lisp-indent)
  73
  74
  75 (defcustom lisp-loop-keyword-indentation 3
  76   "Indentation of loop keywords in extended loop forms."
  77   :type 'integer
  78   :group 'lisp-indent)
  79
  80
  81 (defcustom lisp-loop-forms-indentation 5
  82   "Indentation of forms in extended loop forms."
  83   :type 'integer
  84   :group 'lisp-indent)
  85
  86
  87 (defcustom lisp-simple-loop-indentation 3
  88   "Indentation of forms in simple loop forms."
  89   :type 'integer
  90   :group 'lisp-indent)
  91
  92 (defcustom lisp-lambda-list-keyword-alignment nil
  93   "Whether to vertically align lambda-list keywords together.
  94 If nil (the default), keyworded lambda-list parts are aligned
  95 with the initial mandatory arguments, like this:
  96
  97 \(defun foo (arg1 arg2 &rest rest
  98             &key key1 key2)
  99   #|...|#)
 100
 101 If non-nil, alignment is done with the first keyword
 102 \(or falls back to the previous case), as in:
 103
 104 \(defun foo (arg1 arg2 &rest rest
 105                       &key key1 key2)
 106   #|...|#)"
 107   :type 'boolean
 108   :group 'lisp-indent)
 109
 110 (defcustom lisp-lambda-list-keyword-parameter-indentation 2
 111   "Indentation of lambda list keyword parameters.
 112 See `lisp-lambda-list-keyword-parameter-alignment'
 113 for more information."
 114   :type 'integer
 115   :group 'lisp-indent)
 116
 117 (defcustom lisp-lambda-list-keyword-parameter-alignment nil
 118   "Whether to vertically align lambda-list keyword parameters together.
 119 If nil (the default), the parameters are aligned
 120 with their corresponding keyword, plus the value of
 121 `lisp-lambda-list-keyword-parameter-indentation', like this:
 122
 123 \(defun foo (arg1 arg2 &key key1 key2
 124                         key3 key4)
 125   #|...|#)
 126
 127 If non-nil, alignment is done with the first parameter
 128 \(or falls back to the previous case), as in:
 129
 130 \(defun foo (arg1 arg2 &key key1 key2
 131                             key3 key4)
 132   #|...|#)"
 133   :type 'boolean
 134   :group 'lisp-indent)
 135
 136 \f
 137 (defvar lisp-indent-defun-method '(4 &lambda &body)
 138   "Defun-like indentation method.
 139 This applies when the value of the `common-lisp-indent-function' property
 140 is set to `defun'.")
 141
 142
 143 (defun extended-loop-p (loop-start)
 144   "True if an extended loop form starts at LOOP-START."
 145   (condition-case ()
 146       (save-excursion
 147         (goto-char loop-start)
 148         (forward-char 1)
 149         (forward-sexp 2)
 150         (backward-sexp 1)
 151         (looking-at "\\sw"))
 152     (error t)))
 153
 154
 155 (defun common-lisp-loop-part-indentation (indent-point state)
 156   "Compute the indentation of loop form constituents."
 157   (let* ((loop-indentation (save-excursion
 158                              (goto-char (elt state 1))
 159                              (current-column))))
 160     (goto-char indent-point)
 161     (beginning-of-line)
 162     (cond ((not (extended-loop-p (elt state 1)))
 163            (+ loop-indentation lisp-simple-loop-indentation))
 164           ((looking-at "^\\s-*\\(:?\\sw+\\|;\\)")
 165            (+ loop-indentation lisp-loop-keyword-indentation))
 166           (t
 167            (+ loop-indentation lisp-loop-forms-indentation)))))
 168
 169
 170 ;;;###autoload
 171 (defun common-lisp-indent-function (indent-point state)
 172   "Function to indent the arguments of a Lisp function call.
 173 This is suitable for use as the value of the variable
 174 `lisp-indent-function'.  INDENT-POINT is the point at which the
 175 indentation function is called, and STATE is the
 176 `parse-partial-sexp' state at that position.  Browse the
 177 `lisp-indent' customize group for options affecting the behavior
 178 of this function.
 179
 180 If the indentation point is in a call to a Lisp function, that
 181 function's `common-lisp-indent-function' property specifies how
 182 this function should indent it.  Possible values for this
 183 property are:
 184
 185 * defun, meaning indent according to `lisp-indent-defun-method';
 186   i.e., like (4 &lambda &body), as explained below.
 187
 188 * any other symbol, meaning a function to call.  The function should
 189   take the arguments: PATH STATE INDENT-POINT SEXP-COLUMN NORMAL-INDENT.
 190   PATH is a list of integers describing the position of point in terms of
 191   list-structure with respect to the containing lists.  For example, in
 192   ((a b c (d foo) f) g), foo has a path of (0 3 1).  In other words,
 193   to reach foo take the 0th element of the outermost list, then
 194   the 3rd element of the next list, and finally the 1st element.
 195   STATE and INDENT-POINT are as in the arguments to
 196   `common-lisp-indent-function'.  SEXP-COLUMN is the column of
 197   the open parenthesis of the innermost containing list.
 198   NORMAL-INDENT is the column the indentation point was
 199   originally in.  This function should behave like `lisp-indent-259'.
 200
 201 * an integer N, meaning indent the first N arguments like
 202   function arguments, and any further arguments like a body.
 203   This is equivalent to (4 4 ... &body).
 204
 205 * a list.  The list element in position M specifies how to indent the Mth
 206   function argument.  If there are fewer elements than function arguments,
 207   the last list element applies to all remaining arguments.  The accepted
 208   list elements are:
 209
 210   * nil, meaning the default indentation.
 211
 212   * an integer, specifying an explicit indentation.
 213
 214   * &lambda.  Indent the argument (which may be a list) by 4.
 215
 216   * &rest.  When used, this must be the penultimate element.  The
 217     element after this one applies to all remaining arguments.
 218
 219   * &body.  This is equivalent to &rest lisp-body-indent, i.e., indent
 220     all remaining elements by `lisp-body-indent'.
 221
 222   * &whole.  This must be followed by nil, an integer, or a
 223     function symbol.  This indentation is applied to the
 224     associated argument, and as a base indent for all remaining
 225     arguments.  For example, an integer P means indent this
 226     argument by P, and all remaining arguments by P, plus the
 227     value specified by their associated list element.
 228
 229   * a symbol.  A function to call, with the 6 arguments specified above.
 230
 231   * a list, with elements as described above.  This applies when the
 232     associated function argument is itself a list.  Each element of the list
 233     specifies how to indent the associated argument.
 234
 235 For example, the function `case' has an indent property
 236 \(4 &rest (&whole 2 &rest 1)), meaning:
 237   * indent the first argument by 4.
 238   * arguments after the first should be lists, and there may be any number
 239     of them.  The first list element has an offset of 2, all the rest
 240     have an offset of 2+1=3."
 241   (if (save-excursion (goto-char (elt state 1))
 242                       (looking-at "([Ll][Oo][Oo][Pp]"))
 243       (common-lisp-loop-part-indentation indent-point state)
 244     (common-lisp-indent-function-1 indent-point state)))
 245
 246
 247 (defun common-lisp-indent-function-1 (indent-point state)
 248   (let ((normal-indent (current-column)))
 249     ;; Walk up list levels until we see something
 250     ;;  which does special things with subforms.
 251     (let ((depth 0)
 252           ;; Path describes the position of point in terms of
 253           ;;  list-structure with respect to containing lists.
 254           ;; `foo' has a path of (0 3 1) in `((a b c (d foo) f) g)'.
 255           (path ())
 256           ;; set non-nil when somebody works out the indentation to use
 257           calculated
 258           ;; If non-nil, this is an indentation to use
 259           ;; if nothing else specifies it more firmly.
 260           tentative-calculated
 261           (last-point indent-point)
 262           ;; the position of the open-paren of the innermost containing list
 263           (containing-form-start (elt state 1))
 264           ;; the column of the above
 265           sexp-column)
 266       ;; Move to start of innermost containing list
 267       (goto-char containing-form-start)
 268       (setq sexp-column (current-column))
 269
 270       ;; Look over successively less-deep containing forms
 271       (while (and (not calculated)
 272                   (< depth lisp-indent-maximum-backtracking))
 273         (let ((containing-sexp (point)))
 274           (forward-char 1)
 275           (parse-partial-sexp (point) indent-point 1 t)
 276           ;; Move to the car of the relevant containing form
 277           (let (tem function method tentative-defun)
 278             (if (not (looking-at "\\sw\\|\\s_"))
 279                 ;; This form doesn't seem to start with a symbol
 280                 (setq function nil method nil)
 281               (setq tem (point))
 282               (forward-sexp 1)
 283               (setq function (downcase (buffer-substring-no-properties
 284                                         tem (point))))
 285               (goto-char tem)
 286               (setq tem (intern-soft function)
 287                     method (get tem 'common-lisp-indent-function))
 288               (cond ((and (null method)
 289                           (string-match ":[^:]+" function))
 290                      ;; The pleblisp package feature
 291                      (setq function (substring function
 292                                                (1+ (match-beginning 0)))
 293                            method (get (intern-soft function)
 294                                        'common-lisp-indent-function)))
 295                     ((and (null method))
 296                      ;; backwards compatibility
 297                      (setq method (get tem 'lisp-indent-function)))))
 298             (let ((n 0))
 299               ;; How far into the containing form is the current form?
 300               (if (< (point) indent-point)
 301                   (while (condition-case ()
 302                              (progn
 303                                (forward-sexp 1)
 304                                (if (>= (point) indent-point)
 305                                    nil
 306                                  (parse-partial-sexp (point)
 307                                                      indent-point 1 t)
 308                                  (setq n (1+ n))
 309                                  t))
 310                            (error nil))))
 311               (setq path (cons n path)))
 312
 313             ;; backwards compatibility.
 314             (cond ((null function))
 315                   ((null method)
 316                    (when (null (cdr path))
 317                      ;; (package prefix was stripped off above)
 318                      (cond ((string-match "\\`def"
 319                                           function)
 320                             (setq tentative-defun t))
 321                            ((string-match
 322                              (eval-when-compile
 323                               (concat "\\`\\("
 324                                       (regexp-opt '("with" "without" "do"))
 325                                       "\\)-"))
 326                              function)
 327                             (setq method '(&lambda &body))))))
 328                   ;; backwards compatibility.  Bletch.
 329                   ((eq method 'defun)
 330                    (setq method lisp-indent-defun-method)))
 331
 332             (cond ((and (or (eq (char-after (1- containing-sexp)) ?\')
 333                             (and (not lisp-backquote-indentation)
 334                                  (eq (char-after (1- containing-sexp)) ?\`)))
 335                         (not (eq (char-after (- containing-sexp 2)) ?\#)))
 336                    ;; No indentation for "'(...)" elements
 337                    (setq calculated (1+ sexp-column)))
 338                   ((or (eq (char-after (1- containing-sexp)) ?\,)
 339                        (and (eq (char-after (1- containing-sexp)) ?\@)
 340                             (eq (char-after (- containing-sexp 2)) ?\,)))
 341                    ;; ",(...)" or ",@(...)"
 342                    (setq calculated normal-indent))
 343                   ((eq (char-after (1- containing-sexp)) ?\#)
 344                    ;; "#(...)"
 345                    (setq calculated (1+ sexp-column)))
 346                   ((null method)
 347                    ;; If this looks like a call to a `def...' form,
 348                    ;; think about indenting it as one, but do it
 349                    ;; tentatively for cases like
 350                    ;; (flet ((defunp ()
 351                    ;;          nil)))
 352                    ;; Set both normal-indent and tentative-calculated.
 353                    ;; The latter ensures this value gets used
 354                    ;; if there are no relevant containing constructs.
 355                    ;; The former ensures this value gets used
 356                    ;; if there is a relevant containing construct
 357                    ;; but we are nested within the structure levels
 358                    ;; that it specifies indentation for.
 359                    (if tentative-defun
 360                        (setq tentative-calculated
 361                              (common-lisp-indent-call-method
 362                               function lisp-indent-defun-method
 363                               path state indent-point
 364                               sexp-column normal-indent)
 365                              normal-indent tentative-calculated)))
 366                   ((integerp method)
 367                    ;; convenient top-level hack.
 368                    ;;  (also compatible with lisp-indent-function)
 369                    ;; The number specifies how many `distinguished'
 370                    ;;  forms there are before the body starts
 371                    ;; Equivalent to (4 4 ... &body)
 372                    (setq calculated (cond ((cdr path)
 373                                            normal-indent)
 374                                           ((<= (car path) method)
 375                                            ;; `distinguished' form
 376                                            (list (+ sexp-column 4)
 377                                                  containing-form-start))
 378                                           ((= (car path) (1+ method))
 379                                            ;; first body form.
 380                                            (+ sexp-column lisp-body-indent))
 381                                           (t
 382                                            ;; other body form
 383                                            normal-indent))))
 384                   (t
 385                    (setq calculated
 386                          (common-lisp-indent-call-method
 387                           function method path state indent-point
 388                           sexp-column normal-indent)))))
 389           (goto-char containing-sexp)
 390           (setq last-point containing-sexp)
 391           (unless calculated
 392             (condition-case ()
 393                 (progn (backward-up-list 1)
 394                        (setq depth (1+ depth)))
 395               (error (setq depth lisp-indent-maximum-backtracking))))))
 396       (or calculated tentative-calculated))))
 397
 398
 399 (defun common-lisp-indent-call-method (function method path state indent-point
 400                                        sexp-column normal-indent)
 401   (let ((lisp-indent-error-function function))
 402     (if (symbolp method)
 403         (funcall method
 404                  path state indent-point
 405                  sexp-column normal-indent)
 406       (lisp-indent-259 method path state indent-point
 407                        sexp-column normal-indent))))
 408
 409 ;; Dynamically bound in common-lisp-indent-call-method.
 410 (defvar lisp-indent-error-function)
 411
 412 (defun lisp-indent-report-bad-format (m)
 413   (error "%s has a badly-formed %s property: %s"
 414          ;; Love those free variable references!!
 415          lisp-indent-error-function 'common-lisp-indent-function m))
 416
 417
 418 ;; Lambda-list indentation is now done in LISP-INDENT-LAMBDA-LIST.
 419 ;; See also `lisp-lambda-list-keyword-alignment',
 420 ;; `lisp-lambda-list-keyword-parameter-alignment' and
 421 ;; `lisp-lambda-list-keyword-parameter-indentation' -- dvl
 422
 423 (defvar lisp-indent-lambda-list-keywords-regexp
 424   "&\\(\
 425 optional\\|rest\\|key\\|allow-other-keys\\|aux\\|whole\\|body\\|environment\
 426 \\)\\([ \t]\\|$\\)"
 427   "Regular expression matching lambda-list keywords.")
 428
 429 (defun lisp-indent-lambda-list
 430     (indent-point sexp-column containing-form-start)
 431   (let (limit)
 432     (cond ((save-excursion
 433              (goto-char indent-point)
 434              (beginning-of-line)
 435              (skip-chars-forward " \t")
 436              (setq limit (point))
 437              (looking-at lisp-indent-lambda-list-keywords-regexp))
 438            ;; We're facing a lambda-list keyword.
 439            (if lisp-lambda-list-keyword-alignment
 440                ;; Align to the first keyword if any, or to the beginning of
 441                ;; the lambda-list.
 442                (save-excursion
 443                  (goto-char containing-form-start)
 444                  (save-match-data
 445                    (if (re-search-forward
 446                         lisp-indent-lambda-list-keywords-regexp
 447                         limit t)
 448                        (progn
 449                          (goto-char (match-beginning 0))
 450                          (current-column))
 451                        (1+ sexp-column))))
 452                ;; Align to the beginning of the lambda-list.
 453                (1+ sexp-column)))
 454           (t
 455            ;; Otherwise, align to the first argument of the last lambda-list
 456            ;; keyword, the keyword itself, or the beginning of the
 457            ;; lambda-list.
 458            (save-excursion
 459              (goto-char indent-point)
 460              (forward-line -1)
 461              (end-of-line)
 462              (save-match-data
 463                (if (re-search-backward lisp-indent-lambda-list-keywords-regexp
 464                                        containing-form-start t)
 465                    (let* ((keyword-posn
 466                            (progn
 467                              (goto-char (match-beginning 0))
 468                              (current-column)))
 469                           (indented-keyword-posn
 470                            (+ keyword-posn
 471                               lisp-lambda-list-keyword-parameter-indentation)))
 472                      (goto-char (match-end 0))
 473                      (skip-chars-forward " \t")
 474                      (if (eolp)
 475                          indented-keyword-posn
 476                          (if lisp-lambda-list-keyword-parameter-alignment
 477                              (current-column)
 478                              indented-keyword-posn)))
 479                    (1+ sexp-column))))))))
 480
 481 ;; Blame the crufty control structure on dynamic scoping
 482 ;;  -- not on me!
 483 (defun lisp-indent-259
 484     (method path state indent-point sexp-column normal-indent)
 485   (catch 'exit
 486     (let ((p path)
 487           (containing-form-start (elt state 1))
 488           n tem tail)
 489       ;; Isn't tail-recursion wonderful?
 490       (while p
 491         ;; This while loop is for destructuring.
 492         ;; p is set to (cdr p) each iteration.
 493         (if (not (consp method)) (lisp-indent-report-bad-format method))
 494         (setq n (1- (car p))
 495               p (cdr p)
 496               tail nil)
 497         (while n
 498           ;; This while loop is for advancing along a method
 499           ;; until the relevant (possibly &rest/&body) pattern
 500           ;; is reached.
 501           ;; n is set to (1- n) and method to (cdr method)
 502           ;; each iteration.
 503           (setq tem (car method))
 504
 505           (or (eq tem 'nil)             ;default indentation
 506               (eq tem '&lambda)         ;lambda list
 507               (and (eq tem '&body) (null (cdr method)))
 508               (and (eq tem '&rest)
 509                    (consp (cdr method))
 510                    (null (cddr method)))
 511               (integerp tem)            ;explicit indentation specified
 512               (and (consp tem)          ;destructuring
 513                    (eq (car tem) '&whole)
 514                    (or (symbolp (cadr tem))
 515                        (integerp (cadr tem))))
 516               (and (symbolp tem)        ;a function to call to do the work.
 517                    (null (cdr method)))
 518               (lisp-indent-report-bad-format method))
 519
 520           (cond ((and tail (not (consp tem)))
 521                  ;; indent tail of &rest in same way as first elt of rest
 522                  (throw 'exit normal-indent))
 523                 ((eq tem '&body)
 524                  ;; &body means (&rest <lisp-body-indent>)
 525                  (throw 'exit
 526                    (if (and (= n 0)     ;first body form
 527                             (null p))   ;not in subforms
 528                        (+ sexp-column
 529                           lisp-body-indent)
 530                        normal-indent)))
 531                 ((eq tem '&rest)
 532                  ;; this pattern holds for all remaining forms
 533                  (setq tail (> n 0)
 534                        n 0
 535                        method (cdr method)))
 536                 ((> n 0)
 537                  ;; try next element of pattern
 538                  (setq n (1- n)
 539                        method (cdr method))
 540                  (if (< n 0)
 541                      ;; Too few elements in pattern.
 542                      (throw 'exit normal-indent)))
 543                 ((eq tem 'nil)
 544                  (throw 'exit (if (consp normal-indent)
 545                                   normal-indent
 546                                 (list normal-indent containing-form-start))))
 547                 ((eq tem '&lambda)
 548                  (throw 'exit
 549                         (cond ((null p)
 550                                (list (+ sexp-column 4) containing-form-start))
 551                               ((null (cdr p))
 552                                ;; Indentation within a lambda-list. -- dvl
 553                                (list (lisp-indent-lambda-list
 554                                       indent-point
 555                                       sexp-column
 556                                       containing-form-start)
 557                                      containing-form-start))
 558                               (t
 559                                normal-indent))))
 560                 ((integerp tem)
 561                  (throw 'exit
 562                    (if (null p)         ;not in subforms
 563                        (list (+ sexp-column tem) containing-form-start)
 564                        normal-indent)))
 565                 ((symbolp tem)          ;a function to call
 566                  (throw 'exit
 567                    (funcall tem path state indent-point
 568                             sexp-column normal-indent)))
 569                 (t
 570                  ;; must be a destructing frob
 571                  (if (not (null p))
 572                      ;; descend
 573                (setq method (cddr tem)
 574                            n nil)
 575                (setq tem (cadr tem))
 576                    (throw 'exit
 577                      (cond (tail
 578                             normal-indent)
 579                            ((eq tem 'nil)
 580                             (list normal-indent
 581                                   containing-form-start))
 582                            ((integerp tem)
 583                             (list (+ sexp-column tem)
 584                                   containing-form-start))
 585                            (t
 586                             (funcall tem path state indent-point
 587                                      sexp-column normal-indent))))))))))))
 588 \f
 589 (defun lisp-indent-tagbody (path state indent-point sexp-column normal-indent)
 590   (if (not (null (cdr path)))
 591       normal-indent
 592     (save-excursion
 593       (goto-char indent-point)
 594       (beginning-of-line)
 595       (skip-chars-forward " \t")
 596       (list (cond ((looking-at "\\sw\\|\\s_")
 597                    ;; a tagbody tag
 598                    (+ sexp-column lisp-tag-indentation))
 599                   ((integerp lisp-tag-body-indentation)
 600                    (+ sexp-column lisp-tag-body-indentation))
 601                   ((eq lisp-tag-body-indentation 't)
 602                    (condition-case ()
 603                        (progn (backward-sexp 1) (current-column))
 604                      (error (1+ sexp-column))))
 605                   (t (+ sexp-column lisp-body-indent)))
 606 ;            (cond ((integerp lisp-tag-body-indentation)
 607 ;                   (+ sexp-column lisp-tag-body-indentation))
 608 ;                  ((eq lisp-tag-body-indentation 't)
 609 ;                   normal-indent)
 610 ;                  (t
 611 ;                   (+ sexp-column lisp-body-indent)))
 612             (elt state 1)
 613             ))))
 614
 615 (defun lisp-indent-do (path state indent-point sexp-column normal-indent)
 616   (if (>= (car path) 3)
 617       (let ((lisp-tag-body-indentation lisp-body-indent))
 618         (funcall (function lisp-indent-tagbody)
 619                  path state indent-point sexp-column normal-indent))
 620     (funcall (function lisp-indent-259)
 621              '((&whole nil &rest
 622                 ;; the following causes weird indentation
 623                 ;;(&whole 1 1 2 nil)
 624                 )
 625                (&whole nil &rest 1))
 626              path state indent-point sexp-column normal-indent)))
 627
 628
 629 ;; LISP-INDENT-DEFMETHOD now supports the presence of more than one method
 630 ;; qualifier and indents the method's lambda list properly. -- dvl
 631 (defun lisp-indent-defmethod
 632     (path state indent-point sexp-column normal-indent)
 633   (lisp-indent-259
 634    (let ((nqual 0))
 635      (if (and (>= (car path) 3)
 636               (save-excursion
 637                 (beginning-of-defun)
 638                 (forward-char 1)
 639                 (forward-sexp 2)
 640                 (skip-chars-forward " \t\n")
 641                 (while (looking-at "\\sw\\|\\s_")
 642                   (incf nqual)
 643                   (forward-sexp)
 644                   (skip-chars-forward " \t\n"))
 645                 (> nqual 0)))
 646          (append '(4) (make-list nqual 4) '(&lambda &body))
 647          (get 'defun 'common-lisp-indent-function)))
 648    path state indent-point sexp-column normal-indent))
 649
 650
 651 (defun lisp-indent-function-lambda-hack (path state indent-point
 652                                          sexp-column normal-indent)
 653   ;; indent (function (lambda () <newline> <body-forms>)) kludgily.
 654   (if (or (cdr path) ; wtf?
 655           (> (car path) 3))
 656       ;; line up under previous body form
 657       normal-indent
 658     ;; line up under function rather than under lambda in order to
 659     ;;  conserve horizontal space.  (Which is what #' is for.)
 660     (condition-case ()
 661         (save-excursion
 662           (backward-up-list 2)
 663           (forward-char 1)
 664           (if (looking-at "\\(lisp:+\\)?function\\(\\Sw\\|\\S_\\)")
 665               (+ lisp-body-indent -1 (current-column))
 666               (+ sexp-column lisp-body-indent)))
 667        (error (+ sexp-column lisp-body-indent)))))
 668
 669
 670 \f
 671 (let ((l '((block 1)
 672            (case        (4 &rest (&whole 2 &rest 1)))
 673            (ccase . case)
 674            (ecase . case)
 675            (typecase . case)
 676            (etypecase . case)
 677            (ctypecase . case)
 678            (catch 1)
 679            (cond        (&rest (&whole 2 &rest 1)))
 680            (defvar      (4 2 2))
 681            (defclass    (6 4 (&whole 2 &rest 1) (&whole 2 &rest 1)))
 682            (defconstant . defvar)
 683            (defcustom   (4 2 2 2))
 684            (defparameter . defvar)
 685            (defconst     . defcustom)
 686            (define-condition  . defclass)
 687            (define-modify-macro (4 &lambda &body))
 688            (defsetf     (4 &lambda 4 &body))
 689            (defun       (4 &lambda &body))
 690            (defgeneric  (4 &lambda &body))
 691            (define-setf-method . defun)
 692            (define-setf-expander . defun)
 693            (defmacro . defun)
 694            (defsubst . defun)
 695            (deftype . defun)
 696            (defmethod   lisp-indent-defmethod)
 697            (defpackage  (4 2))
 698            (defstruct   ((&whole 4 &rest (&whole 2 &rest 1))
 699                          &rest (&whole 2 &rest 1)))
 700            (destructuring-bind
 701                         ((&whole 6 &rest 1) 4 &body))
 702            (do          lisp-indent-do)
 703            (do* . do)
 704            (dolist      ((&whole 4 2 1) &body))
 705            (dotimes . dolist)
 706            (eval-when   1)
 707            (flet        ((&whole 4 &rest (&whole 1 &lambda &body)) &body))
 708            (labels . flet)
 709            (macrolet . flet)
 710            (generic-flet . flet)
 711            (generic-labels . flet)
 712            (handler-case (4 &rest (&whole 2 &lambda &body)))
 713            (restart-case . handler-case)
 714            ;; `else-body' style
 715            (if          (nil nil &body))
 716            ;; single-else style (then and else equally indented)
 717            (if          (&rest nil))
 718            (lambda      (&lambda &rest lisp-indent-function-lambda-hack))
 719            (let         ((&whole 4 &rest (&whole 1 1 2)) &body))
 720            (let* . let)
 721            (compiler-let . let) ;barf
 722            (handler-bind . let)
 723            (restart-bind . let)
 724            (locally 1)
 725            ;(loop         lisp-indent-loop)
 726            (:method (&lambda &body)) ; in `defgeneric'
 727            (multiple-value-bind ((&whole 6 &rest 1) 4 &body))
 728            (multiple-value-call (4 &body))
 729            (multiple-value-prog1 1)
 730            (multiple-value-setq (4 2))
 731            (multiple-value-setf . multiple-value-setq)
 732            (pprint-logical-block (4 2))
 733            (print-unreadable-object ((&whole 4 1 &rest 1) &body))
 734            ;; Combines the worst features of BLOCK, LET and TAGBODY
 735            (prog        (&lambda &rest lisp-indent-tagbody))
 736            (prog* . prog)
 737            (prog1 1)
 738            (prog2 2)
 739            (progn 0)
 740            (progv       (4 4 &body))
 741            (return 0)
 742            (return-from (nil &body))
 743            (symbol-macrolet . let)
 744            (tagbody     lisp-indent-tagbody)
 745            (throw 1)
 746            (unless 1)
 747            (unwind-protect (5 &body))
 748            (when 1)
 749            (with-accessors . multiple-value-bind)
 750            (with-condition-restarts . multiple-value-bind)
 751            (with-output-to-string (4 2))
 752            (with-slots . multiple-value-bind)
 753            (with-standard-io-syntax (2)))))
 754   (dolist (el l)
 755     (put (car el) 'common-lisp-indent-function
 756          (if (symbolp (cdr el))
 757              (get (cdr el) 'common-lisp-indent-function)
 758              (car (cdr el))))))
 759
 760 \f
 761 ;(defun foo (x)
 762 ;  (tagbody
 763 ;   foo
 764 ;     (bar)
 765 ;   baz
 766 ;     (when (losing)
 767 ;       (with-big-loser
 768 ;           (yow)
 769 ;         ((lambda ()
 770 ;            foo)
 771 ;          big)))
 772 ;     (flet ((foo (bar baz zap)
 773 ;              (zip))
 774 ;            (zot ()
 775 ;              quux))
 776 ;       (do ()
 777 ;           ((lose)
 778 ;            (foo 1))
 779 ;         (quux)
 780 ;        foo
 781 ;         (lose))
 782 ;       (cond ((x)
 783 ;              (win 1 2
 784 ;                   (foo)))
 785 ;             (t
 786 ;              (lose
 787 ;                3))))))
 788
 789
 790 ;(put 'while    'common-lisp-indent-function 1)
 791 ;(put 'defwrapper'common-lisp-indent-function ...)
 792 ;(put 'def 'common-lisp-indent-function ...)
 793 ;(put 'defflavor        'common-lisp-indent-function ...)
 794 ;(put 'defsubst 'common-lisp-indent-function ...)
 795
 796 ;(put 'with-restart 'common-lisp-indent-function '((1 4 ((* 1))) (2 &body)))
 797 ;(put 'restart-case 'common-lisp-indent-function '((1 4) (* 2 ((0 1) (* 1)))))
 798 ;(put 'define-condition 'common-lisp-indent-function '((1 6) (2 6 ((&whole 1))) (3 4 ((&whole 1))) (4 &body)))
 799 ;(put 'with-condition-handler 'common-lisp-indent-function '((1 4 ((* 1))) (2 &body)))
 800 ;(put 'condition-case 'common-lisp-indent-function '((1 4) (* 2 ((0 1) (1 3) (2 &body)))))
 801 ;(put 'defclass 'common-lisp-indent-function '((&whole 2 &rest (&whole 2 &rest 1) &rest (&whole 2 &rest 1)))
 802 ;(put 'defgeneric 'common-lisp-indent-function 'defun)
 803
 804 ;;; cl-indent.el ends here