anchor.diff:    (or (gethash name *static-indent-table*)
         (caar (gethash name *dynamic-indent-table*))))
   
  -(defun indent-method-malformed-error (name method &rest msg-args)
  -  (apply #'editor-error "Invalid method ~a for ~a: ~@?" method name msg-args))
  -
  -(defun indent-method-welformed-p (name method &key (if-malformed :error))
  -  (flet ((malformed (&rest args)
  -           (cond
  -             ((eq if-malformed :error)
  -              (apply #'indent-method-malformed-error name method args))
  -             ((not if-malformed)
  -              (return-from indent-method-welformed-p (values nil args)))
  -             (t (error "unrecognised ':if-malformed' option: ~a" if-malformed)))))
  -    (typecase method
  -      ((or integer null) t)
  -      (null t)
  -      (cons
  -       (unless (alexandria:proper-list-p method)
  -         (malformed "not a proper list: ~a" method))
  -       (loop for (method1 . method-rest) :on method
  -             :finally (return t)
  -             :do
  -                (typecase method1
  -                  ((or integer null) nil) ; ok
  -                  (cons
  -                   (unless (eq '&whole (first method1))
  -                     (malformed "submethod must begin with &whole: ~a" method1))
  -                   (unless (and (consp (cdr method1))
  -                                (consp (cddr method1)))
  -                     (malformed "&whole must be followed by two or more elements: ~a"
  -                                method1))
  -                   (multiple-value-bind (winp error-msg-args)
  -                       (indent-method-welformed-p name (cdr method1) :if-malformed nil)
  -                     (unless winp
  -                       (apply #'malformed error-msg-args))))
  -                  (symbol
  -                   (case method1
  -                     ((&body)
  -                      (unless (null method-rest)
  -                        (malformed "&body is not the last element")))
  -                     ((&rest)
  -                      (unless (and (consp method-rest) (null (cdr method-rest)))
  -                        (malformed "&rest must be followed by only one element"))
  -                      (when (eq '&rest (car method-rest))
  -                        (malformed "&rest cannot be followed by another &rest")))
  -                     ((&whole)
  -                      (malformed "&whole can only be the first element in a submethod"))
  -                     ((&lambda) nil)
  -                     (t
  -                      (unless (fboundp method1)
  -                        (warn "undefined function used in method: ~a" method))))))))
  -      (symbol (case method
  -                ((&body &lambda &rest &whole)
  -                 (values nil '("~a should be used inside a list" method)))
  -                (t
  -                 (unless (fboundp method)
  -                   (warn "undefined function used as method: ~a" method))
  -                 t))))))
  -
   (defun set-indentation (name method)
  -  (when (indent-method-welformed-p name method)
  -    (setf (gethash name *static-indent-table*) method)))
  +  (setf (gethash name *static-indent-table*) method))
   
   (defun update-system-indentation (name indent packages)
     (push (list :update-system-indentation name indent packages) *indent-log*)
  
positive.code: (defun compute-indent-complex-method (method path indent-point sexp-column)
    (loop
      :named exit
      :for (n-start . pathrest) :on path
      :finally (return-from exit 'default-indent)
      :if (and (= n-start 0)
               (eq '&rest (car method))
               (consp (cadr method))) :do
         (setq n-start 1)
      :do (loop :with restp := nil
                :for (method1 . method-rest) :on method
                :for n :from (1- n-start) :downto 0
                :if (eq method1 '&rest) :do
                   (setq method1 (car method-rest)
                         method-rest nil
                         restp (> n 0)
                         n 0)
                :if (eq method1 '&body) :do
                   (return-from exit
                     (cond ((null pathrest)
                            (+ sexp-column *body-indent*))
                           (t 'default-indent)))
                :if (zerop n) :do
                   (if (and (consp pathrest) (consp method1))
                       ;; since n is 0, (return) is not needed here
                       (setf method (cddr method1))
                       (return-from exit
                         (cond
                           ((integerp method1)
                            (if (null pathrest)
                                (+ sexp-column method1)
                                'default-indent))
                           ((eq method1 '&lambda)
                            (if (null pathrest)
                                (+ sexp-column 4)
                                (compute-indent-lambda-list path indent-point sexp-column)))
                           ((not method1) 'default-indent)
                           ((symbolp method1)
                            (compute-indent-symbol-method method1 path indent-point
                                                          sexp-column))
                           ;; (&whole ...)
                           (t (let ((method1 (cadr method1)))
                                (cond (restp 'default-indent)
                                      ((integerp method1)
                                       (+ sexp-column method1))
                                      (t
                                       (compute-indent-symbol-method
                                        method1 path indent-point sexp-column)))))))))))
  
  (defun compute-indent-method (method path indent-point sexp-column)
    (funcall (etypecase method
  
negative.code:         ;("do"          lisp-indent-do)
          ("do" 2)
          ("do*" . "do")
          ("dolist"      1)
          ("dotimes" . "dolist")
          ("eval-when"   1)
          ("flet"        ((&whole 4 &rest (&whole 1 &lambda &body)) &body))
  