anchor.diff:  (defstruct (advise-record
                (:conc-name #:advised-)
                (:constructor
  -              make-advise-record (name original-function)))
  +              make-advise-record (name env original-function)))
     (original-function
      #'(lambda ()
          (error "Default advised-original-function"))
      :type function)
  -  ;; FIXME: add slot ENV
  -  (name #:unmamed
  +  ;; NB: no portable 'environment' type.
  +  ;; 'env' slot may only be useful for debugging
  +  (env)
  +  (name #:unnamed
           :type function-name))
   
   (defconstant %advise-expand% 8)
  
positive.code:                     (macro-function ,%name ,%env)))))
  
         ;; FIXME: store ,%FORM on hash of (,%NAME ,%ENV)
         (register-advise ,%name ,%form)
             
         (defmacro ,name ,lambda
           ,@(when before
  
negative.code:     ;; (test '(a a) '(a a)) ;; => T
      ;; (test '(a a a) '(a a b)) ;; => NIL
      ;; (test '(a a b) '(a a b)) ;; => T
      (let ((o (find-if
                (lambda (o)
                  (let ((name2 (advised-name o))
                        (env2 (advised-env o)))
                        (and (test name name2)
                             ;; FIXME: EQ compare of
                             ;; NULL environment not accurate
                             (eq env env2))))
                %advise-rec%)))
        (cond
          (o (values o))
          (errorp (error "ADVISE-RECORD NOT FOUND: ~S" name))
          (t (values nil nil))))))
  
  ;; (trace get-advise)
  
  #+NIL (defmethod print-object ((o sb-kernel:lexenv) stream) (print-unreadable-object (o stream :type t :identity t)))
  
  (defun register-advise (name env form)
    ;; FIXME: lock %ADVISE-REC% (WRITE) in this function
    (let ((adv (get-advise name env nil)))
      (cond
        ((and adv (not (eq form (advised-original-function adv))))
         (error "ALREAY ADVISED: ~S => ~S" name adv))
        (t (let ((adv (make-advise-record name env form)))
             (vector-push-extend adv %advise-rec% %advise-expand%)
             (values adv))))))
  
  (defun unregister-advise (name env)
    ;; FIXME: lock %ADVISE-REC% (WRITE) in this function
    (let ((adv (get-advise name env nil)))
      (cond
        (adv
         (setf %advise-rec% (delete adv %advise-rec% :test #'eq))
         (values adv))
        (t (error "NOT ADVISED: ~S" name)))))
  
  