lisp/emacs-lisp/cl-indent.el

   1 ;;; cl-indent.el --- enhanced lisp-indent mode
   2
   3 ;; Copyright (C) 1987, 2000, 2001, 2002, 2003, 2004,
   4 ;;   2005, 2006, 2007 Free Software Foundation, Inc.
   5
   6 ;; Author: Richard Mlynarik <mly@eddie.mit.edu>
   7 ;; Created: July 1987
   8 ;; Maintainer: FSF
   9 ;; Keywords: lisp, tools
  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 2, or (at your option)
  16 ;; 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; see the file COPYING.  If not, write to the
  25 ;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  26 ;; Boston, MA 02110-1301, USA.
  27
  28 ;;; Commentary:
  29
  30 ;; This package supplies a single entry point, common-lisp-indent-function,
  31 ;; which performs indentation in the preferred style for Common Lisp code.
  32 ;; To enable it:
  33 ;;
  34 ;; (setq lisp-indent-function 'common-lisp-indent-function)
  35
  36 ;;>> TODO
  37 ;; :foo
  38 ;;   bar
  39 ;; :baz
  40 ;;   zap
  41 ;; &key (like &body)??
  42
  43 ;; &rest 1 in lambda-lists doesn't work
  44 ;;  -- really want (foo bar
  45 ;;                  baz)
  46 ;;     not (foo bar
  47 ;;              baz)
  48 ;;  Need something better than &rest for such cases
  49
  50 ;;; Code:
  51
  52 (defgroup lisp-indent nil
  53   "Indentation in Lisp."
  54   :group 'lisp)
  55
  56
  57 (defcustom lisp-indent-maximum-backtracking 3
  58   "*Maximum depth to backtrack out from a sublist for structured indentation.
  59 If this variable is 0, no backtracking will occur and forms such as `flet'
  60 may not be correctly indented."
  61   :type 'integer
  62   :group 'lisp-indent)
  63
  64 (defcustom lisp-tag-indentation 1
  65   "*Indentation of tags relative to containing list.
  66 This variable is used by the function `lisp-indent-tagbody'."
  67   :type 'integer
  68   :group 'lisp-indent)
  69
  70 (defcustom lisp-tag-body-indentation 3
  71   "*Indentation of non-tagged lines relative to containing list.
  72 This variable is used by the function `lisp-indent-tagbody' to indent normal
  73 lines (lines without tags).
  74 The indentation is relative to the indentation of the parenthesis enclosing
  75 the special form.  If the value is t, the body of tags will be indented
  76 as a block at the same indentation as the first s-expression following
  77 the tag.  In this case, any forms before the first tag are indented
  78 by `lisp-body-indent'."
  79   :type 'integer
  80   :group 'lisp-indent)
  81
  82 (defcustom lisp-backquote-indentation t
  83   "*Whether or not to indent backquoted lists as code.
  84 If nil, indent backquoted lists as data, i.e., like quoted lists."
  85   :type 'boolean
  86   :group 'lisp-indent)
  87
  88
  89 (defcustom lisp-loop-keyword-indentation 3
  90   "*Indentation of loop keywords in extended loop forms."
  91   :type 'integer
  92   :group 'lisp-indent)
  93
  94
  95 (defcustom lisp-loop-forms-indentation 5
  96   "*Indentation of forms in extended loop forms."
  97   :type 'integer
  98   :group 'lisp-indent)
  99
 100
 101 (defcustom lisp-simple-loop-indentation 3
 102   "*Indentation of forms in simple loop forms."
 103   :type 'integer
 104   :group 'lisp-indent)
 105
 106 \f
 107 (defvar lisp-indent-error-function)
 108 (defvar lisp-indent-defun-method '(4 &lambda &body))
 109
 110
 111 (defun extended-loop-p (loop-start)
 112   "True if an extended loop form starts at LOOP-START."
 113   (condition-case ()
 114       (save-excursion
 115         (goto-char loop-start)
 116         (forward-char 1)
 117         (forward-sexp 2)
 118         (backward-sexp 1)
 119         (looking-at "\\sw"))
 120     (error t)))
 121
 122
 123 (defun common-lisp-loop-part-indentation (indent-point state)
 124   "Compute the indentation of loop form constituents."
 125   (let* ((loop-indentation (save-excursion
 126                              (goto-char (elt state 1))
 127                              (current-column))))
 128     (goto-char indent-point)
 129     (beginning-of-line)
 130     (cond ((not (extended-loop-p (elt state 1)))
 131            (+ loop-indentation lisp-simple-loop-indentation))
 132           ((looking-at "^\\s-*\\(:?\\sw+\\|;\\)")
 133            (+ loop-indentation lisp-loop-keyword-indentation))
 134           (t
 135            (+ loop-indentation lisp-loop-forms-indentation)))))
 136
 137
 138 ;;;###autoload
 139 (defun common-lisp-indent-function (indent-point state)
 140   (if (save-excursion (goto-char (elt state 1))
 141                       (looking-at "([Ll][Oo][Oo][Pp]"))
 142       (common-lisp-loop-part-indentation indent-point state)
 143     (common-lisp-indent-function-1 indent-point state)))
 144
 145
 146 (defun common-lisp-indent-function-1 (indent-point state)
 147   (let ((normal-indent (current-column)))
 148     ;; Walk up list levels until we see something
 149     ;;  which does special things with subforms.
 150     (let ((depth 0)
 151           ;; Path describes the position of point in terms of
 152           ;;  list-structure with respect to containing lists.
 153           ;; `foo' has a path of (0 4 1) in `((a b c (d foo) f) g)'
 154           (path ())
 155           ;; set non-nil when somebody works out the indentation to use
 156           calculated
 157           ;; If non-nil, this is an indentation to use
 158           ;; if nothing else specifies it more firmly.
 159           tentative-calculated
 160           (last-point indent-point)
 161           ;; the position of the open-paren of the innermost containing list
 162           (containing-form-start (elt state 1))
 163           ;; the column of the above
 164           sexp-column)
 165       ;; Move to start of innermost containing list
 166       (goto-char containing-form-start)
 167       (setq sexp-column (current-column))
 168
 169       ;; Look over successively less-deep containing forms
 170       (while (and (not calculated)
 171                   (< depth lisp-indent-maximum-backtracking))
 172         (let ((containing-sexp (point)))
 173           (forward-char 1)
 174           (parse-partial-sexp (point) indent-point 1 t)
 175           ;; Move to the car of the relevant containing form
 176           (let (tem function method tentative-defun)
 177             (if (not (looking-at "\\sw\\|\\s_"))
 178                 ;; This form doesn't seem to start with a symbol
 179                 (setq function nil method nil)
 180               (setq tem (point))
 181               (forward-sexp 1)
 182               (setq function (downcase (buffer-substring-no-properties
 183                                         tem (point))))
 184               (goto-char tem)
 185               (setq tem (intern-soft function)
 186                     method (get tem 'common-lisp-indent-function))
 187               (cond ((and (null method)
 188                           (string-match ":[^:]+" function))
 189                      ;; The pleblisp package feature
 190                      (setq function (substring function
 191                                                (1+ (match-beginning 0)))
 192                            method (get (intern-soft function)
 193                                        'common-lisp-indent-function)))
 194                     ((and (null method))
 195                      ;; backwards compatibility
 196                      (setq method (get tem 'lisp-indent-function)))))
 197             (let ((n 0))
 198               ;; How far into the containing form is the current form?
 199               (if (< (point) indent-point)
 200                   (while (condition-case ()
 201                              (progn
 202                                (forward-sexp 1)
 203                                (if (>= (point) indent-point)
 204                                    nil
 205                                  (parse-partial-sexp (point)
 206                                                      indent-point 1 t)
 207                                  (setq n (1+ n))
 208                                  t))
 209                            (error nil))))
 210               (setq path (cons n path)))
 211
 212             ;; backwards compatibility.
 213             (cond ((null function))
 214                   ((null method)
 215                    (when (null (cdr path))
 216                      ;; (package prefix was stripped off above)
 217                      (cond ((string-match "\\`def"
 218                                           function)
 219                             (setq tentative-defun t))
 220                            ((string-match
 221                              (eval-when-compile
 222                               (concat "\\`\\("
 223                                       (regexp-opt '("with" "without" "do"))
 224                                       "\\)-"))
 225                              function)
 226                             (setq method '(&lambda &body))))))
 227                   ;; backwards compatibility.  Bletch.
 228                   ((eq method 'defun)
 229                    (setq method lisp-indent-defun-method)))
 230
 231             (cond ((and (or (eq (char-after (1- containing-sexp)) ?\')
 232                             (and (not lisp-backquote-indentation)
 233                                  (eq (char-after (1- containing-sexp)) ?\`)))
 234                         (not (eq (char-after (- containing-sexp 2)) ?\#)))
 235                    ;; No indentation for "'(...)" elements
 236                    (setq calculated (1+ sexp-column)))
 237                   ((or (eq (char-after (1- containing-sexp)) ?\,)
 238                        (and (eq (char-after (1- containing-sexp)) ?\@)
 239                             (eq (char-after (- containing-sexp 2)) ?\,)))
 240                    ;; ",(...)" or ",@(...)"
 241                    (setq calculated normal-indent))
 242                   ((eq (char-after (1- containing-sexp)) ?\#)
 243                    ;; "#(...)"
 244                    (setq calculated (1+ sexp-column)))
 245                   ((null method)
 246                    ;; If this looks like a call to a `def...' form,
 247                    ;; think about indenting it as one, but do it
 248                    ;; tentatively for cases like
 249                    ;; (flet ((defunp ()
 250                    ;;          nil)))
 251                    ;; Set both normal-indent and tentative-calculated.
 252                    ;; The latter ensures this value gets used
 253                    ;; if there are no relevant containing constructs.
 254                    ;; The former ensures this value gets used
 255                    ;; if there is a relevant containing construct
 256                    ;; but we are nested within the structure levels
 257                    ;; that it specifies indentation for.
 258                    (if tentative-defun
 259                        (setq tentative-calculated
 260                              (common-lisp-indent-call-method
 261                               function lisp-indent-defun-method
 262                               path state indent-point
 263                               sexp-column normal-indent)
 264                              normal-indent tentative-calculated)))
 265                   ((integerp method)
 266                    ;; convenient top-level hack.
 267                    ;;  (also compatible with lisp-indent-function)
 268                    ;; The number specifies how many `distinguished'
 269                    ;;  forms there are before the body starts
 270                    ;; Equivalent to (4 4 ... &body)
 271                    (setq calculated (cond ((cdr path)
 272                                            normal-indent)
 273                                           ((<= (car path) method)
 274                                            ;; `distinguished' form
 275                                            (list (+ sexp-column 4)
 276                                                  containing-form-start))
 277                                           ((= (car path) (1+ method))
 278                                            ;; first body form.
 279                                            (+ sexp-column lisp-body-indent))
 280                                           (t
 281                                            ;; other body form
 282                                            normal-indent))))
 283                   (t
 284                    (setq calculated
 285                          (common-lisp-indent-call-method
 286                           function method path state indent-point
 287                           sexp-column normal-indent)))))
 288           (goto-char containing-sexp)
 289           (setq last-point containing-sexp)
 290           (unless calculated
 291             (condition-case ()
 292                 (progn (backward-up-list 1)
 293                        (setq depth (1+ depth)))
 294               (error (setq depth lisp-indent-maximum-backtracking))))))
 295       (or calculated tentative-calculated))))
 296
 297
 298 (defun common-lisp-indent-call-method (function method path state indent-point
 299                                        sexp-column normal-indent)
 300   (let ((lisp-indent-error-function function))
 301     (if (symbolp method)
 302         (funcall method
 303                  path state indent-point
 304                  sexp-column normal-indent)
 305       (lisp-indent-259 method path state indent-point
 306                        sexp-column normal-indent))))
 307
 308 (defun lisp-indent-report-bad-format (m)
 309   (error "%s has a badly-formed %s property: %s"
 310          ;; Love those free variable references!!
 311          lisp-indent-error-function 'common-lisp-indent-function m))
 312
 313 ;; Blame the crufty control structure on dynamic scoping
 314 ;;  -- not on me!
 315 (defun lisp-indent-259 (method path state indent-point
 316                         sexp-column normal-indent)
 317   (catch 'exit
 318     (let ((p path)
 319           (containing-form-start (elt state 1))
 320           n tem tail)
 321       ;; Isn't tail-recursion wonderful?
 322       (while p
 323         ;; This while loop is for destructuring.
 324         ;; p is set to (cdr p) each iteration.
 325         (if (not (consp method)) (lisp-indent-report-bad-format method))
 326         (setq n (1- (car p))
 327               p (cdr p)
 328               tail nil)
 329         (while n
 330           ;; This while loop is for advancing along a method
 331           ;; until the relevant (possibly &rest/&body) pattern
 332           ;; is reached.
 333           ;; n is set to (1- n) and method to (cdr method)
 334           ;; each iteration.
 335           (setq tem (car method))
 336
 337           (or (eq tem 'nil)             ;default indentation
 338               (eq tem '&lambda)         ;lambda list
 339               (and (eq tem '&body) (null (cdr method)))
 340               (and (eq tem '&rest)
 341                    (consp (cdr method))
 342                    (null (cddr method)))
 343               (integerp tem)            ;explicit indentation specified
 344               (and (consp tem)          ;destructuring
 345                    (eq (car tem) '&whole)
 346                    (or (symbolp (cadr tem))
 347                        (integerp (cadr tem))))
 348               (and (symbolp tem)        ;a function to call to do the work.
 349                    (null (cdr method)))
 350               (lisp-indent-report-bad-format method))
 351
 352           (cond ((and tail (not (consp tem)))
 353                  ;; indent tail of &rest in same way as first elt of rest
 354                  (throw 'exit normal-indent))
 355                 ((eq tem '&body)
 356                  ;; &body means (&rest <lisp-body-indent>)
 357                  (throw 'exit
 358                    (if (and (= n 0)     ;first body form
 359                             (null p))   ;not in subforms
 360                        (+ sexp-column
 361                           lisp-body-indent)
 362                        normal-indent)))
 363                 ((eq tem '&rest)
 364                  ;; this pattern holds for all remaining forms
 365                  (setq tail (> n 0)
 366                        n 0
 367                        method (cdr method)))
 368                 ((> n 0)
 369                  ;; try next element of pattern
 370                  (setq n (1- n)
 371                        method (cdr method))
 372                  (if (< n 0)
 373                      ;; Too few elements in pattern.
 374                      (throw 'exit normal-indent)))
 375                 ((eq tem 'nil)
 376                  (throw 'exit (if (consp normal-indent)
 377                                   normal-indent
 378                                 (list normal-indent containing-form-start))))
 379                 ((eq tem '&lambda)
 380                  (throw 'exit
 381                         (cond ((null p)
 382                                (list (+ sexp-column 4) containing-form-start))
 383                               ((null (cdr p))
 384                                (+ sexp-column 1))
 385                               (t normal-indent))))
 386                 ((integerp tem)
 387                  (throw 'exit
 388                    (if (null p)         ;not in subforms
 389                        (list (+ sexp-column tem) containing-form-start)
 390                        normal-indent)))
 391                 ((symbolp tem)          ;a function to call
 392                  (throw 'exit
 393                    (funcall tem path state indent-point
 394                             sexp-column normal-indent)))
 395                 (t
 396                  ;; must be a destructing frob
 397                  (if (not (null p))
 398                      ;; descend
 399                (setq method (cddr tem)
 400                            n nil)
 401                (setq tem (cadr tem))
 402                    (throw 'exit
 403                      (cond (tail
 404                             normal-indent)
 405                            ((eq tem 'nil)
 406                             (list normal-indent
 407                                   containing-form-start))
 408                            ((integerp tem)
 409                             (list (+ sexp-column tem)
 410                                   containing-form-start))
 411                            (t
 412                             (funcall tem path state indent-point
 413                                      sexp-column normal-indent))))))))))))
 414 \f
 415 (defun lisp-indent-tagbody (path state indent-point sexp-column normal-indent)
 416   (if (not (null (cdr path)))
 417       normal-indent
 418     (save-excursion
 419       (goto-char indent-point)
 420       (beginning-of-line)
 421       (skip-chars-forward " \t")
 422       (list (cond ((looking-at "\\sw\\|\\s_")
 423                    ;; a tagbody tag
 424                    (+ sexp-column lisp-tag-indentation))
 425                   ((integerp lisp-tag-body-indentation)
 426                    (+ sexp-column lisp-tag-body-indentation))
 427                   ((eq lisp-tag-body-indentation 't)
 428                    (condition-case ()
 429                        (progn (backward-sexp 1) (current-column))
 430                      (error (1+ sexp-column))))
 431                   (t (+ sexp-column lisp-body-indent)))
 432 ;            (cond ((integerp lisp-tag-body-indentation)
 433 ;                   (+ sexp-column lisp-tag-body-indentation))
 434 ;                  ((eq lisp-tag-body-indentation 't)
 435 ;                   normal-indent)
 436 ;                  (t
 437 ;                   (+ sexp-column lisp-body-indent)))
 438             (elt state 1)
 439             ))))
 440
 441 (defun lisp-indent-do (path state indent-point sexp-column normal-indent)
 442   (if (>= (car path) 3)
 443       (let ((lisp-tag-body-indentation lisp-body-indent))
 444         (funcall (function lisp-indent-tagbody)
 445                  path state indent-point sexp-column normal-indent))
 446     (funcall (function lisp-indent-259)
 447              '((&whole nil &rest
 448                 ;; the following causes weird indentation
 449                 ;;(&whole 1 1 2 nil)
 450                 )
 451                (&whole nil &rest 1))
 452              path state indent-point sexp-column normal-indent)))
 453
 454
 455 (defun lisp-indent-defmethod (path state indent-point sexp-column
 456                                    normal-indent)
 457   "Indentation function defmethod."
 458   (lisp-indent-259 (if (and (>= (car path) 3)
 459                             (null (cdr path))
 460                             (save-excursion (goto-char (elt state 1))
 461                                             (forward-char 1)
 462                                             (forward-sexp 3)
 463                                             (backward-sexp)
 464                                             (looking-at ":\\|\\sw+")))
 465                        '(4 4 (&whole 4 &rest 4) &body)
 466                      (get 'defun 'common-lisp-indent-function))
 467                    path state indent-point sexp-column normal-indent))
 468
 469
 470 (defun lisp-indent-function-lambda-hack (path state indent-point
 471                                          sexp-column normal-indent)
 472   ;; indent (function (lambda () <newline> <body-forms>)) kludgily.
 473   (if (or (cdr path) ; wtf?
 474           (> (car path) 3))
 475       ;; line up under previous body form
 476       normal-indent
 477     ;; line up under function rather than under lambda in order to
 478     ;;  conserve horizontal space.  (Which is what #' is for.)
 479     (condition-case ()
 480         (save-excursion
 481           (backward-up-list 2)
 482           (forward-char 1)
 483           (if (looking-at "\\(lisp:+\\)?function\\(\\Sw\\|\\S_\\)")
 484               (+ lisp-body-indent -1 (current-column))
 485               (+ sexp-column lisp-body-indent)))
 486        (error (+ sexp-column lisp-body-indent)))))
 487
 488
 489 \f
 490 (let ((l '((block 1)
 491            (case        (4 &rest (&whole 2 &rest 1)))
 492            (ccase . case) (ecase . case)
 493            (typecase . case) (etypecase . case) (ctypecase . case)
 494            (catch 1)
 495            (cond        (&rest (&whole 2 &rest 1)))
 496            (defvar      (4 2 2))
 497            (defclass    (6 4 (&whole 2 &rest 1) (&whole 2 &rest 1)))
 498            (defconstant . defvar)
 499            (defcustom   (4 2 2 2))
 500            (defparameter . defvar)
 501            (defconst     . defcustom)
 502            (define-condition  . defclass)
 503            (define-modify-macro (4 &lambda &body))
 504            (defsetf     (4 &lambda 4 &body))
 505            (defun       (4 &lambda &body))
 506            (define-setf-method . defun)
 507            (define-setf-expander . defun)
 508            (defmacro . defun) (defsubst . defun) (deftype . defun)
 509            (defmethod   lisp-indent-defmethod)
 510            (defpackage  (4 2))
 511            (defstruct   ((&whole 4 &rest (&whole 2 &rest 1))
 512                          &rest (&whole 2 &rest 1)))
 513            (destructuring-bind
 514                         ((&whole 6 &rest 1) 4 &body))
 515            (do          lisp-indent-do)
 516            (do* . do)
 517            (dolist      ((&whole 4 2 1) &body))
 518            (dotimes . dolist)
 519            (eval-when   1)
 520            (flet        ((&whole 4 &rest (&whole 1 &lambda &body)) &body))
 521            (labels . flet)
 522            (macrolet . flet)
 523            (generic-flet . flet) (generic-labels . flet)
 524            (handler-case (4 &rest (&whole 2 &lambda &body)))
 525            (restart-case . handler-case)
 526            ;; `else-body' style
 527            (if          (nil nil &body))
 528            ;; single-else style (then and else equally indented)
 529            (if          (&rest nil))
 530            (lambda      (&lambda &rest lisp-indent-function-lambda-hack))
 531            (let         ((&whole 4 &rest (&whole 1 1 2)) &body))
 532            (let* . let)
 533            (compiler-let . let) ;barf
 534            (handler-bind . let) (restart-bind . let)
 535            (locally 1)
 536            ;(loop         lisp-indent-loop)
 537            (:method (&lambda &body)) ; in `defgeneric'
 538            (multiple-value-bind ((&whole 6 &rest 1) 4 &body))
 539            (multiple-value-call (4 &body))
 540            (multiple-value-prog1 1)
 541            (multiple-value-setq (4 2))
 542            (multiple-value-setf . multiple-value-setq)
 543            (pprint-logical-block (4 2))
 544            (print-unreadable-object ((&whole 4 1 &rest 1) &body))
 545            ;; Combines the worst features of BLOCK, LET and TAGBODY
 546            (prog        (&lambda &rest lisp-indent-tagbody))
 547            (prog* . prog)
 548            (prog1 1)
 549            (prog2 2)
 550            (progn 0)
 551            (progv       (4 4 &body))
 552            (return 0)
 553            (return-from (nil &body))
 554            (symbol-macrolet . let)
 555            (tagbody     lisp-indent-tagbody)
 556            (throw 1)
 557            (unless 1)
 558            (unwind-protect (5 &body))
 559            (when 1)
 560            (with-accessors . multiple-value-bind)
 561            (with-condition-restarts . multiple-value-bind)
 562            (with-output-to-string (4 2))
 563            (with-slots . multiple-value-bind)
 564            (with-standard-io-syntax (2)))))
 565   (dolist (el l)
 566     (put (car el) 'common-lisp-indent-function
 567          (if (symbolp (cdr el))
 568              (get (cdr el) 'common-lisp-indent-function)
 569              (car (cdr el))))))
 570
 571 \f
 572 ;(defun foo (x)
 573 ;  (tagbody
 574 ;   foo
 575 ;     (bar)
 576 ;   baz
 577 ;     (when (losing)
 578 ;       (with-big-loser
 579 ;           (yow)
 580 ;         ((lambda ()
 581 ;            foo)
 582 ;          big)))
 583 ;     (flet ((foo (bar baz zap)
 584 ;              (zip))
 585 ;            (zot ()
 586 ;              quux))
 587 ;       (do ()
 588 ;           ((lose)
 589 ;            (foo 1))
 590 ;         (quux)
 591 ;        foo
 592 ;         (lose))
 593 ;       (cond ((x)
 594 ;              (win 1 2
 595 ;                   (foo)))
 596 ;             (t
 597 ;              (lose
 598 ;                3))))))
 599
 600
 601 ;(put 'while    'common-lisp-indent-function 1)
 602 ;(put 'defwrapper'common-lisp-indent-function ...)
 603 ;(put 'def 'common-lisp-indent-function ...)
 604 ;(put 'defflavor        'common-lisp-indent-function ...)
 605 ;(put 'defsubst 'common-lisp-indent-function ...)
 606
 607 ;(put 'with-restart 'common-lisp-indent-function '((1 4 ((* 1))) (2 &body)))
 608 ;(put 'restart-case 'common-lisp-indent-function '((1 4) (* 2 ((0 1) (* 1)))))
 609 ;(put 'define-condition 'common-lisp-indent-function '((1 6) (2 6 ((&whole 1))) (3 4 ((&whole 1))) (4 &body)))
 610 ;(put 'with-condition-handler 'common-lisp-indent-function '((1 4 ((* 1))) (2 &body)))
 611 ;(put 'condition-case 'common-lisp-indent-function '((1 4) (* 2 ((0 1) (1 3) (2 &body)))))
 612 ;(put 'defclass 'common-lisp-indent-function '((&whole 2 &rest (&whole 2 &rest 1) &rest (&whole 2 &rest 1)))
 613 ;(put 'defgeneric 'common-lisp-indent-function 'defun)
 614
 615 ;;; arch-tag: 7914d50f-92ec-4476-93fc-0f043a380e03
 616 ;;; cl-indent.el ends here