anchor.diff:                              `((,macro? (,def) ,@(expand-top (rest forms)))))
                              ((nil)
                               (cons exp (expand-top (rest forms)))))))))
  -               (extract-special-macro-arg (sym args)
  -                 "Extract an argument (like `&environment' or `&whole') from a macro lambda list.
  -If the argument is not present, return a gensym."
  -                 (assert (char= (aref (string sym) 0) #\&))
  -                 (if-let (tail (member sym args))
  -                   (values (cadr tail)
  -                           (append (ldiff args tail) (cddr tail)))
  -                   (values (gensym)
  -                           args)))
  -               (compile-macro-function (args body)
  -                 "Compile a macro function into a form acceptable to `augment-environment.'"
  -                 (multiple-value-bind (env-var args)
  -                     (extract-special-macro-arg '&environment args)
  -                   (multiple-value-bind (whole-var args)
  -                       (extract-special-macro-arg '&whole args)
  -                     (compile nil (eval `(lambda (,whole-var ,env-var)
  -                                           (declare (ignorable ,env-var ,whole-var))
  -                                           (destructuring-bind ,args (rest ,whole-var)
  -                                             ,@body)))))))
                  (expand-1 (form env)
                    "Like macroexpand-1 with local macro and symbol macro definitions."
                    (match form
  
positive.code:                         ;; Remember `def' returns a symbol.
                          (let ((expr (expand expr env)))
                            (if (and
                                 (constantp expr env)
                                 ;;Don't hoist if null.
                                 (not (null expr))
                                 ;; Don't hoist unless this is the first
  
negative.code:       ;; macro definitions should only take effect *after* they are
        ;; declared, and, after they are declared, they must be
        ;; available to `expand-partially'.
        (labels ((in-env? ()
                   (or in-let? symbol-macros macros))
                 (expand-top (forms)
                   "Expand FORMS recursively, wrapping with macros as they are defined."
                   (if (null forms)
                       nil
  