- (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)
- (defpackage (4 2))
- (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))
- (handler-case (4 &rest (&whole 2 (&whole 4 &rest 1) &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))
+ (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)))
+ (defvar (4 2 2))
+ (defclass (6 4 (&whole 2 &rest 1) (&whole 2 &rest 1)))
+ (defconstant . defvar)
+ (defcustom (4 2 2 2))
+ (defparameter . defvar)
+ (defconst . defcustom)
+ (define-condition . defclass)
+ (define-modify-macro (4 &lambda &body))
+ (defsetf (4 &lambda 4 &body))
+ (defun (4 &lambda &body))
+ (define-setf-method . defun)
+ (define-setf-expander . defun)
+ (defmacro . defun) (defsubst . defun) (deftype . defun)
+ (defmethod lisp-indent-defmethod)
+ (defpackage (4 2))
+ (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 &lambda &body)) &body))
+ (labels . flet)
+ (macrolet . flet)
+ (generic-flet . flet) (generic-labels . flet)
+ (handler-case (4 &rest (&whole 2 &lambda &body)))
+ (restart-case . handler-case)
+ ;; `else-body' style
+ (if (nil nil &body))
+ ;; single-else style (then and else equally indented)
+ (if (&rest nil))
+ (lambda (&lambda &rest lisp-indent-function-lambda-hack))
+ (let ((&whole 4 &rest (&whole 1 1 2)) &body))
+ (let* . let)
+ (compiler-let . let) ;barf
+ (handler-bind . let) (restart-bind . let)
+ (locally 1)
+ ;(loop lisp-indent-loop)
+ (:method (&lambda &body)) ; in `defgeneric'
+ (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)
+ (pprint-logical-block (4 2))
+ (print-unreadable-object ((&whole 4 1 &rest 1) &body))
+ ;; Combines the worst features of BLOCK, LET and TAGBODY
+ (prog (&lambda &rest lisp-indent-tagbody))
+ (prog* . prog)
+ (prog1 1)
+ (prog2 2)
+ (progn 0)
+ (progv (4 4 &body))
+ (return 0)
+ (return-from (nil &body))
+ (symbol-macrolet . let)
+ (tagbody lisp-indent-tagbody)
+ (throw 1)
+ (unless 1)
+ (unwind-protect (5 &body))