diff --git a/src/contrib/asdf/asdf.lisp b/src/contrib/asdf/asdf.lisp
index fbc4b37bb988f4360b14303b30e47429e895c946..009dac06d06d2f1fe221382fada5d18f3c19ad87 100644
--- a/src/contrib/asdf/asdf.lisp
+++ b/src/contrib/asdf/asdf.lisp
@@ -1,5 +1,5 @@
-;;; -*- mode: Lisp; Base: 10 ; Syntax: ANSI-Common-Lisp ; buffer-read-only: t; -*-
-;;; This is ASDF 3.3.4: Another System Definition Facility.
+;;; -*- mode: Lisp; Base: 10 ; Syntax: ANSI-Common-Lisp ; Package: CL-USER ; buffer-read-only: t; -*-
+;;; This is ASDF 3.3.5: Another System Definition Facility.
 ;;;
 ;;; Feedback, bug reports, and patches are all welcome:
 ;;; please mail to <asdf-devel@common-lisp.net>.
@@ -62,13 +62,39 @@
 ;; See https://bugs.launchpad.net/asdf/+bug/485687
 ;;
 
-(defpackage :uiop/package
-  ;; CAUTION: we must handle the first few packages specially for hot-upgrade.
-  ;; This package definition MUST NOT change unless its name too changes;
-  ;; if/when it changes, don't forget to add new functions missing from below.
-  ;; Until then, uiop/package is frozen to forever
-  ;; import and export the same exact symbols as for ASDF 2.27.
-  ;; Any other symbol must be import-from'ed and re-export'ed in a different package.
+;; CAUTION: The definition of the UIOP/PACKAGE package MUST NOT CHANGE,
+;; NOT NOW, NOT EVER, NOT UNDER ANY CIRCUMSTANCE. NEVER.
+;; ... and the same goes for UIOP/PACKAGE-LOCAL-NICKNAMES.
+;;
+;; The entire point of UIOP/PACKAGE is to address the fact that the CL standard
+;; *leaves it unspecified what happens when a package is redefined incompatibly*.
+;; For instance, SBCL 1.4.2 will signal a full WARNING when this happens,
+;; throwing a wrench in upgrading code with ASDF itself, while continuing to
+;; export old symbols it now shouldn't as it also exports new ones,
+;; causing problems with code that relies on the new/current exports.
+;; CLISP and CCL also exports both sets of symbols, though without any WARNING.
+;; ABCL 1.6.1 will plainly ignore the new definition.
+;; Other implementations may do whatever they want and change their behavior at any time.
+;; ***Using DEFPACKAGE twice with different definitions is nasal-demon territory.***
+;;
+;; Thus we define UIOP/PACKAGE:DEFINE-PACKAGE with which packages can be defined
+;; in an upgrade-friendly way: the new definition is authoritative, and
+;; the package will define and export exactly those symbols in the new definition,
+;; no more and no fewer, whereas it is well-defined what happens to previous symbols.
+;; However, for obvious bootstrap reasons, we cannot use DEFINE-PACKAGE
+;; to define UIOP/PACKAGE itself, only DEFPACKAGE.
+;; Therefore, unlike the other packages in ASDF, UIOP/PACKAGE is immutable,
+;; now and forever. It is frozen for the aeons to come, like the CL package itself,
+;; to the same exact state it was defined at its inception, in ASDF 2.27 in 2013.
+;; The same goes for UIOP/PACKAGE-LOCAL-NICKNAMES, that we use internally.
+;;
+;; If you ever must define new symbols in this file, you can and must
+;; export them from a different package, possibly defined in the same file,
+;; say a package UIOP/PACKAGE* defined at the end of this file with DEFINE-PACKAGE,
+;; that might use :import-from to import the symbols from UIOP/PACKAGE,
+;; if you must somehow define them in UIOP/PACKAGE.
+
+(defpackage :uiop/package ;;; THOU SHALT NOT modify this definition, EVER. See explanations above.
   (:use :common-lisp)
   (:export
    #:find-package* #:find-symbol* #:symbol-call
@@ -80,10 +106,44 @@
    #:ensure-package-unused #:delete-package*
    #:package-names #:packages-from-names #:fresh-package-name #:rename-package-away
    #:package-definition-form #:parse-define-package-form
-   #:ensure-package #:define-package))
+   #:ensure-package #:define-package
+   ))
 
 (in-package :uiop/package)
 
+;;; package local nicknames feature.
+;;; This can't be deferred until common-lisp.lisp, where most such features are set.
+;;; ABCL and CCL already define this feature appropriately.
+;;; Seems to be unconditionally present for SBCL, ACL, and CLASP
+;;; Don't know about ECL, or others
+(eval-when (:load-toplevel :compile-toplevel :execute)
+  ;; ABCL pushes :package-local-nicknames without UIOP interfering,
+  ;; and Lispworks will do so
+  #+(or sbcl clasp)
+  (pushnew :package-local-nicknames *features*)
+  #+allegro
+  (let ((fname (find-symbol (symbol-name '#:add-package-local-nickname) '#:excl)))
+    (when (and fname (fboundp fname))
+      (pushnew :package-local-nicknames *features*))))
+
+;;; THOU SHALT NOT modify this definition, EVER, *EXCEPT* to add a new implementation.
+;; If you somehow need to modify the API in any way,
+;; you will need to create another, differently named, and just as immutable package.
+#+package-local-nicknames
+(defpackage :uiop/package-local-nicknames
+  (:use :cl)
+  (:import-from
+   #+allegro #:excl
+   #+sbcl #:sb-ext
+   #+(or clasp abcl ecl) #:ext
+   #+ccl #:ccl
+   #+lispworks #:hcl
+   #-(or allegro sbcl clasp abcl ccl lispworks ecl)
+   (error "Don't know from which package this lisp supplies the local-package-nicknames API.")
+   #:remove-package-local-nickname #:package-local-nicknames #:add-package-local-nickname)
+  (:export
+   #:add-package-local-nickname #:remove-package-local-nickname #:package-local-nicknames))
+
 ;;;; General purpose package utilities
 
 (eval-when (:load-toplevel :compile-toplevel :execute)
@@ -630,12 +690,26 @@ or when loading the package is optional."
     (multiple-value-bind (symbol status) (find-symbol* name from-package)
       (unless (eq status :external)
         (ensure-exported name symbol from-package recycle))))
+
+  #+package-local-nicknames
+  (defun install-package-local-nicknames (destination-package new-nicknames)
+    ;; First, remove all package-local nicknames. (We'll reinstall any desired ones later.)
+    (dolist (pair-to-remove (uiop/package-local-nicknames:package-local-nicknames destination-package))
+      (uiop/package-local-nicknames:remove-package-local-nickname
+       (string (car pair-to-remove)) destination-package))
+    ;; Then, install all desired nicknames.
+    (loop :for (nickname package) :in new-nicknames
+          :do (uiop/package-local-nicknames:add-package-local-nickname
+               (string nickname)
+               (find-package package)
+               destination-package)))
+
   (defun ensure-package (name &key
                                 nicknames documentation use
                                 shadow shadowing-import-from
                                 import-from export intern
                                 recycle mix reexport
-                                unintern)
+                                unintern local-nicknames)
     #+genera (declare (ignore documentation))
     (let* ((package-name (string name))
            (nicknames (mapcar #'string nicknames))
@@ -652,17 +726,23 @@ or when loading the package is optional."
            (export (mapcar 'string export))
            (intern (mapcar 'string intern))
            (unintern (mapcar 'string unintern))
+           (local-nicknames (mapcar #'(lambda (pair) (mapcar 'string pair)) local-nicknames))
            (shadowed (make-hash-table :test 'equal)) ; string to bool
            (imported (make-hash-table :test 'equal)) ; string to bool
            (exported (make-hash-table :test 'equal)) ; string to bool
            ;; string to list home package and use package:
            (inherited (make-hash-table :test 'equal)))
+      #-package-local-nicknames
+      (declare (ignore local-nicknames)) ; if not supported
       (when-package-fishiness (record-fishy package-name))
+      ;; if supported, put package documentation
       #-genera
       (when documentation (setf (documentation package t) documentation))
+      ;; remove unwanted packages from use list
       (loop :for p :in (set-difference (package-use-list package) (append mix use))
             :do (note-package-fishiness :over-use name (package-names p))
                 (unuse-package p package))
+      ;; mark unwanted packages for deletion
       (loop :for p :in discarded
             :for n = (remove-if #'(lambda (x) (member x names :test 'equal))
                                 (package-names p))
@@ -670,7 +750,11 @@ or when loading the package is optional."
                 (cond (n (rename-package p (first n) (rest n)))
                       (t (rename-package-away p)
                          (push p to-delete))))
+      ;; give package its desired name
       (rename-package package package-name nicknames)
+      ;; Handle local nicknames
+      #+package-local-nicknames
+      (install-package-local-nicknames package local-nicknames)
       (dolist (name unintern)
         (multiple-value-bind (existing status) (find-symbol name package)
           (when status
@@ -678,11 +762,14 @@ or when loading the package is optional."
               (note-package-fishiness
                :unintern (package-name package) name (symbol-package-name existing) status)
               (unintern* name package nil)))))
+      ;; handle exports
       (dolist (name export)
         (setf (gethash name exported) t))
+      ;; handle reexportss
       (dolist (p reexport)
         (do-external-symbols (sym p)
           (setf (gethash (string sym) exported) t)))
+      ;; unexport symbols not listed in (re)export
       (do-external-symbols (sym package)
         (let ((name (symbol-name sym)))
           (unless (gethash name exported)
@@ -690,6 +777,7 @@ or when loading the package is optional."
              :over-export (package-name package) name
              (or (home-package-p sym package) (symbol-package-name sym)))
             (unexport sym package))))
+      ;; handle explicitly listed shadowed ssymbols
       (dolist (name shadow)
         (setf (gethash name shadowed) t)
         (multiple-value-bind (existing status) (find-symbol name package)
@@ -709,28 +797,35 @@ or when loading the package is optional."
                    (shadowing-import* dummy package)
                    (import* dummy package)))))))
         (shadow* name package))
+      ;; handle shadowing imports
       (loop :for (p . syms) :in shadowing-import-from
             :for pp = (find-package* p) :do
               (dolist (sym syms) (ensure-shadowing-import (string sym) package pp shadowed imported)))
+      ;; handle mixed packages
       (loop :for p :in mix
             :for pp = (find-package* p) :do
               (do-external-symbols (sym pp) (ensure-mix (symbol-name sym) sym package pp shadowed imported inherited)))
+      ;; handle import-from packages
       (loop :for (p . syms) :in import-from
             :for pp = (find-package p) :do
               (dolist (sym syms) (ensure-import (symbol-name sym) package pp shadowed imported)))
+      ;; handle use-list and mix
       (dolist (p (append use mix))
         (do-external-symbols (sym p) (ensure-inherited (string sym) sym package p nil shadowed imported inherited))
         (use-package p package))
       (loop :for name :being :the :hash-keys :of exported :do
         (ensure-symbol name package t recycle shadowed imported inherited exported)
         (ensure-export name package recycle))
+      ;; intern dessired symbols
       (dolist (name intern)
         (ensure-symbol name package t recycle shadowed imported inherited exported))
       (do-symbols (sym package)
         (ensure-symbol (symbol-name sym) package nil recycle shadowed imported inherited exported))
+      ;; delete now-deceased packages
       (map () 'delete-package* to-delete)
       package)))
 
+
 (eval-when (:load-toplevel :compile-toplevel :execute)
   (defun parse-define-package-form (package clauses)
     (loop
@@ -757,6 +852,13 @@ or when loading the package is optional."
       :when (eq kw :mix-reexport) :append args :into mix :and :append args :into reexport
         :and :do (setf use-p t) :else
       :when (eq kw :unintern) :append args :into unintern :else
+      :when (eq kw :local-nicknames)
+        :if (symbol-call '#:uiop '#:featurep :package-local-nicknames)
+          :append args :into local-nicknames
+        :else
+          :do (error ":LOCAL-NICKAMES option is not supported on this lisp implementation.")
+        :end
+      :else
         :do (error "unrecognized define-package keyword ~S" kw)
       :finally (return `(',package
                          :nicknames ',nicknames :documentation ',documentation
@@ -764,13 +866,15 @@ or when loading the package is optional."
                          :shadow ',shadow :shadowing-import-from ',shadowing-import-from
                          :import-from ',import-from :export ',export :intern ',intern
                          :recycle ',(if recycle-p recycle (cons package nicknames))
-                         :mix ',mix :reexport ',reexport :unintern ',unintern)))))
+                         :mix ',mix :reexport ',reexport :unintern ',unintern
+                         :local-nicknames ',local-nicknames)))))
 
 (defmacro define-package (package &rest clauses)
   "DEFINE-PACKAGE takes a PACKAGE and a number of CLAUSES, of the form
 \(KEYWORD . ARGS\).
 DEFINE-PACKAGE supports the following keywords:
-USE, SHADOW, SHADOWING-IMPORT-FROM, IMPORT-FROM, EXPORT, INTERN -- as per CL:DEFPACKAGE.
+USE, SHADOW, SHADOWING-IMPORT-FROM, IMPORT-FROM, EXPORT, INTERN, NICKNAMES,
+DOCUMENTATION -- as per CL:DEFPACKAGE.
 RECYCLE -- Recycle the package's exported symbols from the specified packages,
 in order.  For every symbol scheduled to be exported by the DEFINE-PACKAGE,
 either through an :EXPORT option or a :REEXPORT option, if the symbol exists in
@@ -788,7 +892,13 @@ an error if there is a conflict with an explicitly :IMPORT-FROM symbol.
 REEXPORT -- Takes a list of package designators.  For each package, p, in the list,
 export symbols with the same name as those exported from p.  Note that in the case
 of shadowing, etc. the symbols with the same name may not be the same symbols.
-UNINTERN -- Remove symbols here from PACKAGE."
+UNINTERN -- Remove symbols here from PACKAGE.
+LOCAL-NICKNAMES -- If the host implementation supports package local nicknames
+\(check for the :PACKAGE-LOCAL-NICKNAMES feature\), then this should be a list of
+nickname and package name pairs.  Using this option will cause an error if the
+host CL implementation does not support it.
+USE-REEXPORT, MIX-REEXPORT -- Use or mix the specified packages as per the USE or
+MIX directives, and reexport their contents as per the REEXPORT directive."
   (let ((ensure-form
          `(prog1
               (funcall 'ensure-package ,@(parse-define-package-form package clauses))
@@ -798,6 +908,11 @@ UNINTERN -- Remove symbols here from PACKAGE."
        #+(or clasp ecl gcl mkcl) (defpackage ,package (:use))
        (eval-when (:compile-toplevel :load-toplevel :execute)
          ,ensure-form))))
+
+;; This package, unlike UIOP/PACKAGE, is allowed to evolve and acquire new symbols or drop old ones.
+(define-package :uiop/package*
+  (:use-reexport :uiop/package
+                 #+package-local-nicknames :uiop/package-local-nicknames))
 ;;;; -------------------------------------------------------------------------
 ;;;; Handle compatibility with multiple implementations.
 ;;; This file is for papering over the deficiencies and peculiarities
@@ -807,7 +922,7 @@ UNINTERN -- Remove symbols here from PACKAGE."
 ;;; from this package only common-lisp symbols are exported.
 
 (uiop/package:define-package :uiop/common-lisp
-  (:nicknames :uoip/cl)
+  (:nicknames :uiop/cl)
   (:use :uiop/package)
   (:use-reexport #-genera :common-lisp #+genera :future-common-lisp)
   #+allegro (:intern #:*acl-warn-save*)
@@ -940,6 +1055,7 @@ UNINTERN -- Remove symbols here from PACKAGE."
       (unless (member :lispworks6 *features*)
         (pushnew :lispworks7+ *features*)))))
 
+
 #.(or #+mcl ;; the #$ doesn't work on other lisps, even protected by #+mcl, so we use this trick
       (read-from-string
        "(eval-when (:load-toplevel :compile-toplevel :execute)
@@ -965,13 +1081,6 @@ UNINTERN -- Remove symbols here from PACKAGE."
   (setq clos::*redefine-class-in-place* t)) ;; Make sure we have strict ANSI class redefinition semantics
 
 
-;;;; Looping
-(eval-when (:load-toplevel :compile-toplevel :execute)
-  (defmacro loop* (&rest rest)
-    #-genera `(loop ,@rest)
-    #+genera `(lisp:loop ,@rest))) ;; In genera, CL:LOOP can't destructure, so we use LOOP*. Sigh.
-
-
 ;;;; compatfmt: avoid fancy format directives when unsupported
 (eval-when (:load-toplevel :compile-toplevel :execute)
   (defun frob-substrings (string substrings &optional frob)
@@ -1023,15 +1132,14 @@ Return a string made of the parts not omitted or emitted by FROB."
 (uiop/package:define-package :uiop/utility
   (:use :uiop/common-lisp :uiop/package)
   ;; import and reexport a few things defined in :uiop/common-lisp
-  (:import-from :uiop/common-lisp #:compatfmt #:loop* #:frob-substrings
+  (:import-from :uiop/common-lisp #:compatfmt #:frob-substrings
    #+(or clasp ecl) #:use-ecl-byte-compiler-p #+mcl #:probe-posix)
-  (:export #:compatfmt #:loop* #:frob-substrings #:compatfmt
+  (:export #:compatfmt #:frob-substrings #:compatfmt
    #+(or clasp ecl) #:use-ecl-byte-compiler-p #+mcl #:probe-posix)
   (:export
    ;; magic helper to define debugging functions:
    #:uiop-debug #:load-uiop-debug-utility #:*uiop-debug-utility*
    #:with-upgradability ;; (un)defining functions in an upgrade-friendly way
-   #:defun* #:defgeneric*
    #:nest #:if-let ;; basic flow control
    #:parse-body ;; macro definition helper
    #:while-collecting #:appendf #:length=n-p #:ensure-list ;; lists
@@ -1060,29 +1168,33 @@ Return a string made of the parts not omitted or emitted by FROB."
 (in-package :uiop/utility)
 
 ;;;; Defining functions in a way compatible with hot-upgrade:
-;; DEFUN* and DEFGENERIC* use FMAKUNBOUND to delete any previous fdefinition,
-;; thus replacing the function without warning or error
-;; even if the signature and/or generic-ness of the function has changed.
-;; For a generic function, this invalidates any previous DEFMETHOD.
+;; - The WTIH-UPGRADABILITY infrastructure below ensures that functions are declared NOTINLINE,
+;;   so that new definitions are always seen by all callers, even those up the stack.
+;; - WITH-UPGRADABILITY also uses EVAL-WHEN so that definitions used by ASDF are in a limbo state
+;;   (especially for gf's) in between the COMPILE-OP and LOAD-OP operations on the defining file.
+;; - THOU SHALT NOT redefine a function with a backward-incompatible semantics without renaming it,
+;;   at least if that function is used by ASDF while performing the plan to load ASDF.
+;; - THOU SHALT change the name of a function whenever thou makest an incompatible change.
+;; - For instance, when the meanings of NIL and T for timestamps was inverted,
+;;   functions in the STAMP<, STAMP<=, etc. family had to be renamed to TIMESTAMP<, TIMESTAMP<=, etc.,
+;;   because the change other caused a huge incompatibility during upgrade.
+;; - Whenever a function goes from a DEFUN to a DEFGENERIC, or the DEFGENERIC signature changes, etc.,
+;;   even in a backward-compatible way, you MUST precede the definition by FMAKUNBOUND.
+;; - Since FMAKUNBOUND will remove all the methods on the generic function, make sure that
+;;   all the methods required for ASDF to successfully continue compiling itself
+;;   shall be defined in the same file as the one with the FMAKUNBOUND, *after* the DEFGENERIC.
+;; - When a function goes from DEFGENERIC to DEFUN, you may omit to use FMAKUNBOUND.
+;; - For safety, you shall put the FMAKUNBOUND just before the DEFUN or DEFGENERIC,
+;;   in the same WITH-UPGRADABILITY form (and its implicit EVAL-WHEN).
+;; - Any time you change a signature, please keep a comment specifying the first release after the change;
+;;   put that comment on the same line as FMAKUNBOUND, it you use FMAKUNBOUND.
 (eval-when (:load-toplevel :compile-toplevel :execute)
-  (macrolet
-      ((defdef (def* def)
-         `(defmacro ,def* (name formals &rest rest)
-            (destructuring-bind (name &key (supersede t))
-                (if (or (atom name) (eq (car name) 'setf))
-                    (list name :supersede nil)
-                    name)
-              (declare (ignorable supersede))
-              `(progn
-                 ;; We usually try to do it only for the functions that need it,
-                 ;; which happens in asdf/upgrade - however, for ECL, we need this hammer.
-                 ,@(when supersede
-                     `((fmakunbound ',name)))
-                 ,@(when (and #+(or clasp ecl) (symbolp name)) ; fails for setf functions on ecl
-                     `((declaim (notinline ,name))))
-                 (,',def ,name ,formals ,@rest))))))
-    (defdef defgeneric* defgeneric)
-    (defdef defun* defun))
+  (defun ensure-function-notinline (definition &aux (name (second definition)))
+    (assert (member (first definition) '(defun defgeneric)))
+    `(progn
+       ,(when (and #+(or clasp ecl) (symbolp name)) ; NB: fails for (SETF functions) on ECL
+          `(declaim (notinline ,name)))
+       ,definition))
   (defmacro with-upgradability ((&optional) &body body)
     "Evaluate BODY at compile- load- and run- times, with DEFUN and DEFGENERIC modified
 to also declare the functions NOTINLINE and to accept a wrapping the function name
@@ -1092,11 +1204,9 @@ to supersede any previous definition."
     `(eval-when (:compile-toplevel :load-toplevel :execute)
        ,@(loop :for form :in body :collect
                (if (consp form)
-                   (destructuring-bind (car . cdr) form
-                     (case car
-                       ((defun) `(defun* ,@cdr))
-                       ((defgeneric) `(defgeneric* ,@cdr))
-                       (otherwise form)))
+                   (case (first form)
+                     ((defun defgeneric) (ensure-function-notinline form))
+                     (otherwise form))
                    form)))))
 
 ;;; Magic debugging help. See contrib/debug.lisp
@@ -1204,15 +1314,15 @@ Returns two values: \(A B C\) and \(1 2 3\)."
 (with-upgradability ()
   (defun remove-plist-key (key plist)
     "Remove a single key from a plist"
-    (loop* :for (k v) :on plist :by #'cddr
-           :unless (eq k key)
-           :append (list k v)))
+    (loop :for (k v) :on plist :by #'cddr
+          :unless (eq k key)
+            :append (list k v)))
 
   (defun remove-plist-keys (keys plist)
     "Remove a list of keys from a plist"
-    (loop* :for (k v) :on plist :by #'cddr
-           :unless (member k keys)
-           :append (list k v))))
+    (loop :for (k v) :on plist :by #'cddr
+          :unless (member k keys)
+            :append (list k v))))
 
 
 ;;; Sequences
@@ -1228,17 +1338,17 @@ Returns two values: \(A B C\) and \(1 2 3\)."
   ;; NB: We assume a total order on character types.
   ;; If that's not true... this code will need to be updated.
   (defparameter +character-types+ ;; assuming a simple hierarchy
-    #.(coerce (loop* :for (type next) :on
-                     '(;; In SCL, all characters seem to be 16-bit base-char
-                       ;; Yet somehow character fails to be a subtype of base-char
-                       #-scl base-char
-                       ;; LW6 has BASE-CHAR < SIMPLE-CHAR < CHARACTER
-                       ;; LW7 has BASE-CHAR < BMP-CHAR < SIMPLE-CHAR = CHARACTER
-                       #+lispworks7+ lw:bmp-char
-                       #+lispworks lw:simple-char
-                       character)
-                     :unless (and next (subtypep next type))
-                     :collect type) 'vector))
+    #.(coerce (loop :for (type next) :on
+                    '(;; In SCL, all characters seem to be 16-bit base-char
+                      ;; Yet somehow character fails to be a subtype of base-char
+                      #-scl base-char
+                      ;; LW6 has BASE-CHAR < SIMPLE-CHAR < CHARACTER
+                      ;; LW7 has BASE-CHAR < BMP-CHAR < SIMPLE-CHAR = CHARACTER
+                      #+lispworks7+ lw:bmp-char
+                      #+lispworks lw:simple-char
+                      character)
+                    :unless (and next (subtypep next type))
+                      :collect type) 'vector))
   (defparameter +max-character-type-index+ (1- (length +character-types+)))
   (defconstant +non-base-chars-exist-p+ (plusp +max-character-type-index+))
   (when +non-base-chars-exist-p+ (pushnew :non-base-chars-exist-p *features*)))
@@ -1697,7 +1807,7 @@ form suitable for testing with #+."
 (in-package :uiop/version)
 
 (with-upgradability ()
-  (defparameter *uiop-version* "3.3.4")
+  (defparameter *uiop-version* "3.3.5")
 
   (defun unparse-version (version-list)
     "From a parsed version (a list of natural numbers), compute the version string"
@@ -1907,7 +2017,7 @@ keywords explicitly."
 
   (defun os-unix-p ()
     "Is the underlying operating system some Unix variant?"
-    (or (featurep '(:or :unix :cygwin)) (os-macosx-p)))
+    (or (featurep '(:or :unix :cygwin :haiku)) (os-macosx-p)))
 
   (defun os-windows-p ()
     "Is the underlying operating system Microsoft Windows?"
@@ -1932,22 +2042,22 @@ keywords explicitly."
   (defun detect-os ()
     "Detects the current operating system. Only needs be run at compile-time,
 except on ABCL where it might change between FASL compilation and runtime."
-    (loop* :with o
-           :for (feature . detect) :in '((:os-unix . os-unix-p) (:os-macosx . os-macosx-p)
-                                         (:os-windows . os-windows-p)
-                                         (:genera . os-genera-p) (:os-oldmac . os-oldmac-p)
-                                         (:haiku . os-haiku-p)
-                                         (:mezzano . os-mezzano-p))
-           :when (and (or (not o) (eq feature :os-macosx)) (funcall detect))
-           :do (setf o feature) (pushnew feature *features*)
-           :else :do (setf *features* (remove feature *features*))
-           :finally
-           (return (or o (error "Congratulations for trying ASDF on an operating system~%~
+    (loop :with o
+          :for (feature . detect) :in '((:os-unix . os-unix-p) (:os-macosx . os-macosx-p)
+                                        (:os-windows . os-windows-p)
+                                        (:os-genera . os-genera-p) (:os-oldmac . os-oldmac-p)
+                                        (:os-haiku . os-haiku-p)
+                                        (:os-mezzano . os-mezzano-p))
+          :when (and (or (not o) (eq feature :os-macosx) (eq feature :os-haiku)) (funcall detect))
+            :do (setf o feature) (pushnew feature *features*)
+          :else :do (setf *features* (remove feature *features*))
+          :finally
+             (return (or o (error "Congratulations for trying ASDF on an operating system~%~
 that is neither Unix, nor Windows, nor Genera, nor even old MacOS.~%Now you port it.")))))
 
   (defmacro os-cond (&rest clauses)
     #+abcl `(cond ,@clauses)
-    #-abcl (loop* :for (test . body) :in clauses :when (eval test) :return `(progn ,@body)))
+    #-abcl (loop :for (test . body) :in clauses :when (eval test) :return `(progn ,@body)))
 
   (detect-os))
 
@@ -2054,7 +2164,9 @@ then returning the non-empty string value of the variable"
        (:x86 :x86 :i386 :i486 :i586 :i686 :pentium3 :pentium4 :pc386 :iapx386 :x8632-target)
        (:ppc64 :ppc64 :ppc64-target) (:ppc32 :ppc32 :ppc32-target :ppc :powerpc)
        :hppa64 :hppa :sparc64 (:sparc32 :sparc32 :sparc)
-       :mipsel :mipseb :mips :alpha (:arm :arm :arm-target) :imach
+       :mipsel :mipseb :mips :alpha
+       (:arm64 :arm64 :aarch64 :armv8l :armv8b :aarch64_be :|aarch64|)
+       (:arm :arm :arm-target) :vlm :imach
        ;; Java comes last: if someone uses C via CFFI or otherwise JNA or JNI,
        ;; we may have to segregate the code still by architecture.
        (:java :java :java-1.4 :java-1.5 :java-1.6 :java-1.7))))
@@ -2688,7 +2800,7 @@ For an empty type, *UNSPECIFIC-PATHNAME-TYPE* is returned."
 Unix syntax is used whether or not the underlying system is Unix;
 on such non-Unix systems it is reliably usable only for relative pathnames.
 This function is especially useful to manipulate relative pathnames portably,
-where it is of crucial to possess a portable pathname syntax independent of the underlying OS.
+where it is crucial to possess a portable pathname syntax independent of the underlying OS.
 This is what PARSE-UNIX-NAMESTRING provides, and why we use it in ASDF.
 
 When given a PATHNAME object, just return it untouched.
@@ -2986,7 +3098,7 @@ added to its DIRECTORY component. This is useful for output translations."
                              :defaults pathname)))
         pathname)))
 
-  (defun* (translate-pathname*) (path absolute-source destination &optional root source)
+  (defun translate-pathname* (path absolute-source destination &optional root source)
     "A wrapper around TRANSLATE-PATHNAME to be used by the ASDF output-translations facility.
 PATH is the pathname to be translated.
 ABSOLUTE-SOURCE is an absolute pathname to use as source for translate-pathname,
@@ -3871,7 +3983,7 @@ It must never be modified, though only good implementations will even enforce th
       (read-from-string string eof-error-p eof-value :start start :end end :preserve-whitespace preserve-whitespace))))
 
 ;;; Output helpers
-(with-upgradability ()
+ (with-upgradability ()
   (defun call-with-output-file (pathname thunk
                                 &key
                                   (element-type *default-stream-element-type*)
@@ -3893,39 +4005,46 @@ Other keys are accepted but discarded."
     (declare (ignore element-type external-format if-exists if-does-not-exist))
     `(call-with-output-file ,pathname #'(lambda (,var) ,@body) ,@keys))
 
-  (defun call-with-output (output function &key keys)
+  (defun call-with-output (output function &key (element-type 'character))
     "Calls FUNCTION with an actual stream argument,
 behaving like FORMAT with respect to how stream designators are interpreted:
 If OUTPUT is a STREAM, use it as the stream.
-If OUTPUT is NIL, use a STRING-OUTPUT-STREAM as the stream, and return the resulting string.
+If OUTPUT is NIL, use a STRING-OUTPUT-STREAM of given ELEMENT-TYPE as the stream, and
+return the resulting string.
 If OUTPUT is T, use *STANDARD-OUTPUT* as the stream.
-If OUTPUT is a STRING with a fill-pointer, use it as a string-output-stream.
-If OUTPUT is a PATHNAME, open the file and write to it, passing KEYS to WITH-OUTPUT-FILE
+If OUTPUT is a STRING with a fill-pointer, use it as a STRING-OUTPUT-STREAM of given ELEMENT-TYPE.
+If OUTPUT is a PATHNAME, open the file and write to it, passing ELEMENT-TYPE to WITH-OUTPUT-FILE
 -- this latter as an extension since ASDF 3.1.
+\(Proper ELEMENT-TYPE treatment since ASDF 3.3.4 only.\)
 Otherwise, signal an error."
     (etypecase output
       (null
-       (with-output-to-string (stream) (funcall function stream)))
+       (with-output-to-string (stream nil :element-type element-type) (funcall function stream)))
       ((eql t)
        (funcall function *standard-output*))
       (stream
        (funcall function output))
       (string
        (assert (fill-pointer output))
-       (with-output-to-string (stream output) (funcall function stream)))
+       (with-output-to-string (stream output :element-type element-type) (funcall function stream)))
       (pathname
-       (apply 'call-with-output-file output function keys))))
+       (call-with-output-file output function :element-type element-type)))))
 
-  (defmacro with-output ((output-var &optional (value output-var)) &body body)
-    "Bind OUTPUT-VAR to an output stream, coercing VALUE (default: previous binding of OUTPUT-VAR)
-as per FORMAT, and evaluate BODY within the scope of this binding."
-    `(call-with-output ,value #'(lambda (,output-var) ,@body)))
+(with-upgradability ()
+  (locally (declare #+sbcl (sb-ext:muffle-conditions style-warning))
+    (handler-bind (#+sbcl (style-warning #'muffle-warning))
+      (defmacro with-output ((output-var &optional (value output-var) &key element-type) &body body)
+        "Bind OUTPUT-VAR to an output stream obtained from VALUE (default: previous binding
+of OUTPUT-VAR) treated as a stream designator per CALL-WITH-OUTPUT. Evaluate BODY in
+the scope of this binding."
+        `(call-with-output ,value #'(lambda (,output-var) ,@body)
+                           ,@(when element-type `(:element-type ,element-type)))))))
 
-  (defun output-string (string &optional output)
-    "If the desired OUTPUT is not NIL, print the string to the output; otherwise return the string"
-    (if output
-        (with-output (output) (princ string output))
-        string)))
+(defun output-string (string &optional output)
+  "If the desired OUTPUT is not NIL, print the string to the output; otherwise return the string"
+  (if output
+      (with-output (output) (princ string output))
+      string))
 
 
 ;;; Input helpers
@@ -3988,32 +4107,34 @@ and always returns EOF when read from"
       ((os-unix-p) #p"/dev/null")
       ((os-windows-p) #p"NUL") ;; Q: how many Lisps accept the #p"NUL:" syntax?
       (t (error "No /dev/null on your OS"))))
-  (defun call-with-null-input (fun &rest keys &key element-type external-format if-does-not-exist)
-    "Call FUN with an input stream from the null device; pass keyword arguments to OPEN."
+  (defun call-with-null-input (fun &key element-type external-format if-does-not-exist)
+    "Call FUN with an input stream that always returns end of file.
+The keyword arguments are allowed for backward compatibility, but are ignored."
     (declare (ignore element-type external-format if-does-not-exist))
-    (apply 'call-with-input-file (null-device-pathname) fun keys))
+    (with-open-stream (input (make-concatenated-stream))
+      (funcall fun input)))
   (defmacro with-null-input ((var &rest keys
                               &key element-type external-format if-does-not-exist)
                              &body body)
     (declare (ignore element-type external-format if-does-not-exist))
-    "Evaluate BODY in a context when VAR is bound to an input stream accessing the null device.
-Pass keyword arguments to OPEN."
+    "Evaluate BODY in a context when VAR is bound to an input stream that always returns end of file.
+The keyword arguments are allowed for backward compatibility, but are ignored."
     `(call-with-null-input #'(lambda (,var) ,@body) ,@keys))
   (defun call-with-null-output (fun
                                 &key (element-type *default-stream-element-type*)
                                   (external-format *utf-8-external-format*)
                                   (if-exists :overwrite)
                                   (if-does-not-exist :error))
-    "Call FUN with an output stream to the null device; pass keyword arguments to OPEN."
-    (call-with-output-file
-     (null-device-pathname) fun
-     :element-type element-type :external-format external-format
-     :if-exists if-exists :if-does-not-exist if-does-not-exist))
+    (declare (ignore element-type external-format if-exists if-does-not-exist))
+    "Call FUN with an output stream that discards all output.
+The keyword arguments are allowed for backward compatibility, but are ignored."
+    (with-open-stream (output (make-broadcast-stream))
+      (funcall fun output)))
   (defmacro with-null-output ((var &rest keys
                               &key element-type external-format if-does-not-exist if-exists)
                               &body body)
-    "Evaluate BODY in a context when VAR is bound to an output stream accessing the null device.
-Pass keyword arguments to OPEN."
+    "Evaluate BODY in a context when VAR is bound to an output stream that discards all output.
+The keyword arguments are allowed for backward compatibility, but are ignored."
     (declare (ignore element-type external-format if-exists if-does-not-exist))
     `(call-with-null-output #'(lambda (,var) ,@body) ,@keys)))
 
@@ -4051,13 +4172,13 @@ If LINEWISE is true, then read and copy the stream line by line, with an optiona
 Otherwise, using WRITE-SEQUENCE using a buffer of size BUFFER-SIZE."
     (with-open-stream (input input)
       (if linewise
-          (loop* :for (line eof) = (multiple-value-list (read-line input nil nil))
-                 :while line :do
-                 (when prefix (princ prefix output))
-                 (princ line output)
-                 (unless eof (terpri output))
-                 (finish-output output)
-                 (when eof (return)))
+          (loop :for (line eof) = (multiple-value-list (read-line input nil nil))
+                :while line :do
+                  (when prefix (princ prefix output))
+                  (princ line output)
+                  (unless eof (terpri output))
+                  (finish-output output)
+                  (when eof (return)))
           (loop
             :with buffer-size = (or buffer-size 8192)
             :with buffer = (make-array (list buffer-size) :element-type (or element-type 'character))
@@ -4089,7 +4210,7 @@ Otherwise, using WRITE-SEQUENCE using a buffer of size BUFFER-SIZE."
     "Read the contents of the INPUT stream as a string"
     (let ((string
             (with-open-stream (input input)
-              (with-output-to-string (output)
+              (with-output-to-string (output nil :element-type element-type)
                 (copy-stream-to-stream input output :element-type element-type)))))
       (if stripped (stripln string) string)))
 
@@ -4326,13 +4447,18 @@ Finally, the file will be deleted, unless the KEEP argument when CALL-FUNCTION'e
                      ;; or the non-local return causes the file creation to be undone.
                      (setf results (multiple-value-list
                                     (if want-pathname-p
-                                        (funcall thunk stream pathname)
-                                        (funcall thunk stream)))))))
-               (cond
-                 ((not okp) nil)
-                 (after (return (call-function after okp)))
-                 ((and want-pathname-p (not want-stream-p)) (return (call-function thunk okp)))
-                 (t (return (values-list results)))))
+                                        (call-function thunk stream pathname)
+                                        (call-function thunk stream)))))))
+               ;; if we don't want a stream, then we must call the thunk *after*
+               ;; the stream is closed, but only if it was successfully opened.
+               (when okp
+                 (when (and want-pathname-p (not want-stream-p))
+                   (setf results (multiple-value-list (call-function thunk okp))))
+                 ;; if the stream was successfully opened, then return a value,
+                 ;; either one computed already, or one from AFTER, if that exists.
+                 (if after
+                     (return (call-function after pathname))
+                     (return (values-list results)))))
           (when (and okp (not (call-function keep)))
             (ignore-errors (delete-file-if-exists okp))))))
 
@@ -4358,6 +4484,8 @@ Upon success, the KEEP form is evaluated and the file is is deleted unless it ev
            (after (when afterp (subseq body (1+ afterp))))
            (beforef (gensym "BEFORE"))
            (afterf (gensym "AFTER")))
+      (when (eql afterp 0)
+        (style-warn ":CLOSE-STREAM should not be the first form of BODY in WITH-TEMPORARY-FILE. Instead, do not provide a STREAM."))
       `(flet (,@(when before
                   `((,beforef (,@(when streamp `(,stream)) ,@(when pathnamep `(,pathname)))
                        ,@(when after `((declare (ignorable ,pathname))))
@@ -4380,8 +4508,8 @@ Upon success, the KEEP form is evaluated and the file is is deleted unless it ev
           ,@(when element-type `(:element-type ,element-type))
           ,@(when external-format `(:external-format ,external-format))))))
 
-  (defun get-temporary-file (&key directory prefix suffix type)
-    (with-temporary-file (:pathname pn :keep t
+  (defun get-temporary-file (&key directory prefix suffix type (keep t))
+    (with-temporary-file (:pathname pn :keep keep
                           :directory directory :prefix prefix :suffix suffix :type type)
       pn))
 
@@ -4399,7 +4527,14 @@ clash with any concurrent process attempting the same thing."
     (let* ((px (ensure-pathname x :ensure-physical t))
            (prefix (if-let (n (pathname-name px)) (strcat n "-tmp") "tmp"))
            (directory (pathname-directory-pathname px)))
-      (get-temporary-file :directory directory :prefix prefix :type (pathname-type px))))
+      ;; Genera uses versioned pathnames -- If we leave the empty file in place,
+      ;; the system will create a new version of the file when the caller opens
+      ;; it for output. That empty file will remain after the operation is completed.
+      ;; As Genera is a single core processor, the possibility of a name conflict is
+      ;; minimal if not nil. (And, in the event of a collision, the two processes
+      ;; would be writing to different versions of the file.)
+      (get-temporary-file :directory directory :prefix prefix :type (pathname-type px)
+                          #+genera :keep #+genera nil)))
 
   (defun call-with-staging-pathname (pathname fun)
     "Calls FUN with a staging pathname, and atomically
@@ -4533,7 +4668,9 @@ This is designed to abstract away the implementation specific quit forms."
         :from-read-eval-print-loop nil
         :count (or count t)
         :all t))
-    #+(or clasp ecl mkcl)
+    #+clasp
+    (clasp-debug:print-backtrace :stream stream :count count)
+    #+(or ecl mkcl)
     (let* ((top (si:ihs-top))
            (repeats (if count (min top count) top))
            (backtrace (loop :for ihs :from 0 :below top
@@ -4766,7 +4903,7 @@ of the function will be returned rather than interpreted as a boolean designatin
     "Dump an image of the current Lisp environment at pathname FILENAME, with various options.
 
 First, finalize the image, by evaluating the POSTLUDE as per EVAL-INPUT, then calling each of
- the functions in DUMP-HOOK, in reverse order of registration by REGISTER-DUMP-HOOK.
+ the functions in DUMP-HOOK, in reverse order of registration by REGISTER-IMAGE-DUMP-HOOK.
 
 If EXECUTABLE is true, create an standalone executable program that calls RESTORE-IMAGE on startup.
 
@@ -4794,6 +4931,10 @@ or COMPRESSION on SBCL, and APPLICATION-TYPE on SBCL/Windows."
            :quiet t
            :start-package *package*
            :keep-global-handlers nil
+           ;; Faré explains the odd executable value (slightly paraphrased):
+           ;; 0 is very different from t in clisp and there for a good reason:
+           ;; 0 turns the executable into one that has its own command-line handling, so hackers can't
+           ;; use the underlying -i or -x to turn your would-be restricted binary into an unrestricted evaluator.
            :executable (if executable 0 t) ;--- requires clisp 2.48 or later, still catches --clisp-x
            (when executable
              (list
@@ -5031,11 +5172,12 @@ This can help you produce more deterministic output for FASLs."))
   (progn
     (defun sb-grovel-unknown-constant-condition-p (c)
       "Detect SB-GROVEL unknown-constant conditions on older versions of SBCL"
-      (and (typep c 'sb-int:simple-style-warning)
-           (string-enclosed-p
-            "Couldn't grovel for "
-            (simple-condition-format-control c)
-            " (unknown to the C compiler).")))
+      (ignore-errors
+       (and (typep c 'sb-int:simple-style-warning)
+            (string-enclosed-p
+             "Couldn't grovel for "
+             (simple-condition-format-control c)
+             " (unknown to the C compiler)."))))
     (deftype sb-grovel-unknown-constant-condition ()
       '(and style-warning (satisfies sb-grovel-unknown-constant-condition-p))))
 
@@ -5571,7 +5713,7 @@ possibly in a different process. Otherwise just call THUNK."
   (defvar *compile-check* nil
     "A hook for user-defined compile-time invariants")
 
-  (defun* (compile-file*) (input-file &rest keys
+  (defun compile-file* (input-file &rest keys
                                       &key (compile-check *compile-check*) output-file warnings-file
                                       #+clisp lib-file #+(or clasp ecl mkcl) object-file #+sbcl emit-cfasl
                                       &allow-other-keys)
@@ -5754,7 +5896,8 @@ it will filter them appropriately."
 
 (uiop/package:define-package :uiop/launch-program
   (:use :uiop/common-lisp :uiop/package :uiop/utility
-   :uiop/pathname :uiop/os :uiop/filesystem :uiop/stream)
+   :uiop/pathname :uiop/os :uiop/filesystem :uiop/stream
+   :uiop/version)
   (:export
    ;;; Escaping the command invocation madness
    #:easy-sh-character-p #:escape-sh-token #:escape-sh-command
@@ -5917,6 +6060,15 @@ argument to pass to the internal RUN-PROGRAM"
                                      "Can't send ~a to ~a on this lisp implementation."
                                      role specifier))
              (t (parameter-error "~S IO specifier invalid for ~S" specifier role))))
+      ((eql t)
+       #+ (or lispworks abcl)
+       (not-implemented-error :interactive-output
+                              "On this lisp implementation, cannot interpret ~a value of ~a"
+                              specifier role)
+       #- (or lispworks abcl)
+       (cond ((eq role :error-output) *error-output*)
+             ((eq role :output) #+lispworks *terminal-io* #-lispworks *standard-output*)
+             ((eq role :input) *standard-input*)))
       (otherwise
        (parameter-error "Incorrect I/O specifier ~S for ~S"
                         specifier role))))
@@ -6254,7 +6406,16 @@ IF-DOES-NOT-EXIST parameter to OPEN with :DIRECTION :INPUT.
 ELEMENT-TYPE and EXTERNAL-FORMAT are passed on to your Lisp
 implementation, when applicable, for creation of the output stream.
 
-LAUNCH-PROGRAM returns a PROCESS-INFO object."
+LAUNCH-PROGRAM returns a PROCESS-INFO object.
+
+LAUNCH-PROGRAM currently does not smooth over all the differences between
+implementations. Of particular note is when streams are provided for OUTPUT or
+ERROR-OUTPUT. Some implementations don't support this at all, some support only
+certain subclasses of streams, and some support any arbitrary
+stream. Additionally, the implementations that support streams may have
+differing behavior on how those streams are filled with data. If data is not
+periodically read from the child process and sent to the stream, the child
+could block because its output buffers are full."
     #-(or abcl allegro clozure cmucl ecl (and lispworks os-unix) mkcl sbcl scl)
     (progn command keys input output error-output directory element-type external-format
            if-input-does-not-exist if-output-exists if-error-output-exists ;; ignore
@@ -6275,10 +6436,11 @@ LAUNCH-PROGRAM returns a PROCESS-INFO object."
       (parameter-error "~S: The only admissible value for ~S is ~S on this lisp"
                        'launch-program :error-output :interactive))
     #+ecl
-    (when (some #'(lambda (stream)
-                    (and (streamp stream)
-                         (not (file-or-synonym-stream-p stream))))
-                (list input output error-output))
+    (when (and (version< (lisp-implementation-version) "20.4.24")
+               (some #'(lambda (stream)
+                         (and (streamp stream)
+                              (not (file-or-synonym-stream-p stream))))
+                     (list input output error-output)))
       (parameter-error "~S: Streams passed as I/O parameters need to be (synonymous with) file streams on this lisp"
                        'launch-program))
     #+(or abcl allegro clozure cmucl ecl (and lispworks os-unix) mkcl sbcl scl)
@@ -6372,7 +6534,7 @@ LAUNCH-PROGRAM returns a PROCESS-INFO object."
           (prop 'process pid-or-nil)
           (when (eq input :stream) (prop 'input-stream in-or-io))
           (when (eq output :stream) (prop 'output-stream out-or-err))
-          (when (eq error-output :stream) (prop 'error-stream err-or-pid)))
+          (when (eq error-output :stream) (prop 'error-output-stream err-or-pid)))
          (t
           (prop 'process err-or-pid)
           (ecase (+ (if (eq input :stream) 1 0) (if (eq output :stream) 2 0))
@@ -6381,7 +6543,7 @@ LAUNCH-PROGRAM returns a PROCESS-INFO object."
             (2 (prop 'output-stream in-or-io))
             (3 (prop 'bidir-stream in-or-io)))
           (when (eq error-output :stream)
-            (prop 'error-stream out-or-err))))
+            (prop 'error-output-stream out-or-err))))
        #+(or abcl clozure cmucl sbcl scl)
        (progn
          (prop 'process process)
@@ -6414,6 +6576,11 @@ LAUNCH-PROGRAM returns a PROCESS-INFO object."
          code ;; ignore
          (unless (zerop mode)
            (prop (case mode (1 'input-stream) (2 'output-stream) (3 'bidir-stream)) stream))
+         (when (eq error-output :stream)
+           (prop 'error-output-stream
+                 (if (version< (lisp-implementation-version) "16.0.0")
+                     (symbol-call :ext :external-process-error process)
+                     (symbol-call :ext :external-process-error-stream process))))
          (prop 'process process))
        #+lispworks
        ;; See also the comments on the process-info class
@@ -6425,7 +6592,7 @@ LAUNCH-PROGRAM returns a PROCESS-INFO object."
               (prop (ecase mode (1 'input-stream) (2 'output-stream) (3 'bidir-stream))
                     io-or-pid))
             (when (eq error-output :stream)
-              (prop 'error-stream err-or-nil)))
+              (prop 'error-output-stream err-or-nil)))
            ;; Prior to Lispworks 7, this returned (pid); now it
            ;; returns (io err pid) of which we keep io.
            (t (prop 'process io-or-pid)))))
@@ -7226,24 +7393,24 @@ directive.")
   (declaim (ftype (function (t &key (:directory boolean) (:wilden boolean)
                                (:ensure-directory boolean)) t) resolve-location))
 
-  (defun* (resolve-location) (x &key ensure-directory wilden directory)
+  (defun resolve-location (x &key ensure-directory wilden directory)
     "Resolve location designator X into a PATHNAME"
     ;; :directory backward compatibility, until 2014-01-16: accept directory as well as ensure-directory
-    (loop* :with dirp = (or directory ensure-directory)
-           :with (first . rest) = (if (atom x) (list x) x)
-           :with path = (or (resolve-absolute-location
-                             first :ensure-directory (and (or dirp rest) t)
-                                   :wilden (and wilden (null rest)))
-                            (return nil))
-           :for (element . morep) :on rest
-           :for dir = (and (or morep dirp) t)
-           :for wild = (and wilden (not morep))
-           :for sub = (merge-pathnames*
-                       (resolve-relative-location
-                        element :ensure-directory dir :wilden wild)
-                       path)
-           :do (setf path (if (absolute-pathname-p sub) (resolve-symlinks* sub) sub))
-           :finally (return path)))
+    (loop :with dirp = (or directory ensure-directory)
+          :with (first . rest) = (if (atom x) (list x) x)
+          :with path = (or (resolve-absolute-location
+                            first :ensure-directory (and (or dirp rest) t)
+                            :wilden (and wilden (null rest)))
+                           (return nil))
+          :for (element . morep) :on rest
+          :for dir = (and (or morep dirp) t)
+          :for wild = (and wilden (not morep))
+          :for sub = (merge-pathnames*
+                      (resolve-relative-location
+                       element :ensure-directory dir :wilden wild)
+                      path)
+          :do (setf path (if (absolute-pathname-p sub) (resolve-symlinks* sub) sub))
+          :finally (return path)))
 
   (defun location-designator-p (x)
     "Is X a designator for a location?"
@@ -7333,6 +7500,16 @@ also \"Configuration DSL\"\) in the ASDF manual."
             (or (remove nil (getenv-absolute-directories "XDG_DATA_DIRS"))
                 (os-cond
                  ((os-windows-p) (mapcar 'get-folder-path '(:appdata :common-appdata)))
+                 ;; macOS' separate read-only system volume means that the contents
+                 ;; of /usr/share are frozen by Apple. Unlike when running natively
+                 ;; on macOS, Genera must access the filesystem through NFS. Attempting
+                 ;; to export either the root (/) or /usr/share simply doesn't work.
+                 ;; (Genera will go into an infinite loop trying to access those mounts.)
+                 ;; So, when running Genera on macOS, only search /usr/local/share.
+                 ((os-genera-p)
+                  #+Genera (sys:system-case
+                            (darwin-vlm (mapcar 'parse-unix-namestring '("/usr/local/share/")))
+                            (otherwise (mapcar 'parse-unix-namestring '("/usr/local/share/" "/usr/share/")))))
                  (t (mapcar 'parse-unix-namestring '("/usr/local/share/" "/usr/share/")))))))
 
   (defun xdg-config-dirs (&rest more)
@@ -7517,20 +7694,23 @@ DEPRECATED."
 ;;;; Re-export all the functionality in UIOP
 
 (uiop/package:define-package :uiop/driver
-  (:nicknames :uiop :asdf/driver) ;; asdf/driver is obsolete (uiop isn't);
-  ;; but asdf/driver is still used by swap-bytes, static-vectors.
+  (:nicknames :uiop ;; Official name we recommend should be used for all references to uiop symbols.
+              :asdf/driver) ;; DO NOT USE, a deprecated name, not supported anymore.
+  ;; We should remove the name :asdf/driver at some point,
+  ;; but not until it has been eradicated from Quicklisp for a year or two.
+  ;; The last known user was cffi (PR merged in May 2020).
   (:use :uiop/common-lisp)
-   ;; NB: not reexporting uiop/common-lisp
-   ;; which include all of CL with compatibility modifications on select platforms,
-   ;; that could cause potential conflicts for packages that would :use (cl uiop)
-   ;; or :use (closer-common-lisp uiop), etc.
+  ;; NB: We are not reexporting uiop/common-lisp
+  ;; which include all of CL with compatibility modifications on select platforms,
+  ;; because that would cause potential conflicts for packages that
+  ;; might want to :use (:cl :uiop) or :use (:closer-common-lisp :uiop), etc.
   (:use-reexport
-   :uiop/package :uiop/utility :uiop/version
+   :uiop/package* :uiop/utility :uiop/version
    :uiop/os :uiop/pathname :uiop/filesystem :uiop/stream :uiop/image
    :uiop/launch-program :uiop/run-program
    :uiop/lisp-build :uiop/configuration :uiop/backward-driver))
 
-;; Provide both lowercase and uppercase, to satisfy more people.
+;; Provide both lowercase and uppercase, to satisfy more implementations.
 (provide "uiop") (provide "UIOP")
 ;;;; -------------------------------------------------------------------------
 ;;;; Handle upgrade as forward- and backward-compatibly as possible
@@ -7628,7 +7808,7 @@ previously-loaded version of ASDF."
          ;; "3.4.5.67" would be a development version in the official branch, on top of 3.4.5.
          ;; "3.4.5.0.8" would be your eighth local modification of official release 3.4.5
          ;; "3.4.5.67.8" would be your eighth local modification of development version 3.4.5.67
-         (asdf-version "3.3.4")
+         (asdf-version "3.3.5")
          (existing-version (asdf-version)))
     (setf *asdf-version* asdf-version)
     (when (and existing-version (not (equal asdf-version existing-version)))
@@ -7642,30 +7822,31 @@ previously-loaded version of ASDF."
 (when-upgrading ()
   (let* ((previous-version (first *previous-asdf-versions*))
          (redefined-functions ;; List of functions that changed incompatibly since 2.27:
-          ;; gf signature changed (should NOT happen), defun that became a generic function,
-          ;; method removed that will mess up with new ones (especially :around :before :after,
-          ;; more specific or call-next-method'ed method) and/or semantics otherwise modified. Oops.
+          ;; gf signature changed, defun that became a generic function (but not way around),
+          ;; method removed that will mess up with new ones
+          ;; (especially :around :before :after, more specific or call-next-method'ed method)
+          ;; and/or semantics otherwise modified. Oops.
           ;; NB: it's too late to do anything about functions in UIOP!
-          ;; If you introduce some critical incompatibility there, you must change the function name.
+          ;; If you introduce some critical incompatibility there, you MUST change the function name.
           ;; Note that we don't need do anything about functions that changed incompatibly
           ;; from ASDF 2.26 or earlier: we wholly punt on the entire ASDF package in such an upgrade.
-          ;; Also note that we don't include the defgeneric=>defun, because they are
-          ;; done directly with defun* and need not trigger a punt on data.
+          ;; Also, the strong constraints apply most importantly for functions called from
+          ;; the continuation of compiling or loading some of the code in ASDF or UIOP.
           ;; See discussion at https://gitlab.common-lisp.net/asdf/asdf/merge_requests/36
-          `(,@(when (version< previous-version "3.1.2") '(#:component-depends-on #:input-files)) ;; crucial methods *removed* before 3.1.2
-            ,@(when (version< previous-version "3.1.7.20") '(#:find-component))))
+          ;; and at https://gitlab.common-lisp.net/asdf/asdf/-/merge_requests/141
+          `(,@(when (version< previous-version "2.31") '(#:normalize-version)) ;; pathname became &key
+            ,@(when (version< previous-version "3.1.2") '(#:component-depends-on #:input-files)) ;; crucial methods *removed* before 3.1.2
+            ,@(when (version< previous-version "3.1.7.20") '(#:find-component)))) ;; added &key registered
          (redefined-classes
-          ;; redefining the classes causes interim circularities
           ;; with the old ASDF during upgrade, and many implementations bork
-          #-clozure ()
-          #+clozure
-          '((#:compile-concatenated-source-op (#:operation) ())
-            (#:compile-bundle-op (#:operation) ())
-            (#:concatenate-source-op (#:operation) ())
-            (#:dll-op (#:operation) ())
-            (#:lib-op (#:operation) ())
-            (#:monolithic-compile-bundle-op (#:operation) ())
-            (#:monolithic-concatenate-source-op (#:operation) ()))))
+          (when (or #+(or clozure mkcl) t)
+            '((#:compile-concatenated-source-op (#:operation) ())
+              (#:compile-bundle-op (#:operation) ())
+              (#:concatenate-source-op (#:operation) ())
+              (#:dll-op (#:operation) ())
+              (#:lib-op (#:operation) ())
+              (#:monolithic-compile-bundle-op (#:operation) ())
+              (#:monolithic-concatenate-source-op (#:operation) ())))))
     (loop :for name :in redefined-functions
       :for sym = (find-symbol* name :asdf nil)
       :do (when sym (fmakunbound sym)))
@@ -7673,11 +7854,11 @@ previously-loaded version of ASDF."
                            (if (consp x) (values (car x) (cadr x)) (values x :asdf))
                          (find-symbol* s p nil)))
              (asyms (l) (mapcar #'asym l)))
-      (loop* :for (name superclasses slots) :in redefined-classes
-             :for sym = (find-symbol* name :asdf nil)
-             :when (and sym (find-class sym))
-             :do (eval `(defclass ,sym ,(asyms superclasses) ,(asyms slots)))))))
-
+      (loop :for (name superclasses slots) :in redefined-classes
+            :for sym = (find-symbol* name :asdf nil)
+            :when (and sym (find-class sym))
+              :do #+ccl (eval `(defclass ,sym ,(asyms superclasses) ,(asyms slots)))
+                  #-ccl (setf (find-class sym) nil))))) ;; mkcl
 
 ;;; Self-upgrade functions
 (with-upgradability ()
@@ -8457,16 +8638,18 @@ primary system, after which the .asd file in which it is defined is named.
 If given a string or symbol (to downcase), do it syntactically
  by stripping anything from the first slash on.
 If given a component, do it semantically by extracting
-the system-primary-system-name of its system."
+the system-primary-system-name of its system from its source-file if any,
+falling back to the syntactic criterion if none."
     (etypecase system-designator
       (string (if-let (p (position #\/ system-designator))
                 (subseq system-designator 0 p) system-designator))
       (symbol (primary-system-name (coerce-name system-designator)))
       (component (let* ((system (component-system system-designator))
                         (source-file (physicalize-pathname (system-source-file system))))
-                   (and source-file
-                        (equal (pathname-type source-file) "asd")
-                        (pathname-name source-file))))))
+                   (if source-file
+                       (and (equal (pathname-type source-file) "asd")
+                            (pathname-name source-file))
+                       (primary-system-name (component-name system)))))))
 
   (defun primary-system-p (system)
     "Given a system designator SYSTEM, return T if it designates a primary system, or else NIL.
@@ -8504,10 +8687,11 @@ the primary one."
           (slot-value (find-system (primary-system-name system))
                       slot-name))))
   (defmacro define-system-virtual-slot-reader (slot-name)
-    `(defun* ,(intern (concatenate 'string (string :system-)
-                                   (string slot-name)))
-         (system)
-       (system-virtual-slot-value system ',slot-name)))
+    (let ((name (intern (strcat (string :system-) (string slot-name)))))
+      `(progn
+         (fmakunbound ',name) ;; These were gf from defgeneric before 3.3.2.11
+         (declaim (notinline ,name))
+         (defun ,name (system) (system-virtual-slot-value system ',slot-name)))))
   (defmacro define-system-virtual-slot-readers ()
     `(progn ,@(mapcar (lambda (slot-name)
                         `(define-system-virtual-slot-reader ,slot-name))
@@ -8532,7 +8716,7 @@ the primary one."
 in which the system specification (.asd file) is located."
     (pathname-directory-pathname (system-source-file system-designator)))
 
-  (defun* (system-relative-pathname) (system name &key type)
+  (defun system-relative-pathname (system name &key type)
     "Given a SYSTEM, and a (Unix-style relative path) NAME of a file (or directory) of given TYPE,
 return the absolute pathname of a corresponding file under that system's source code pathname."
     (subpathname (system-source-directory system) name :type type))
@@ -9008,7 +9192,7 @@ Use it in FORMAT control strings as ~/asdf-action:format-action/"
 
 ;;;; Detection of circular dependencies
 (with-upgradability ()
-  (defun (action-valid-p) (operation component)
+  (defun action-valid-p (operation component)
     "Is this action valid to include amongst dependencies?"
     ;; If either the operation or component was resolved to nil, the action is invalid.
     ;; :if-feature will invalidate actions on components for which the features don't apply.
@@ -9018,7 +9202,8 @@ Use it in FORMAT control strings as ~/asdf-action:format-action/"
   (define-condition circular-dependency (system-definition-error)
     ((actions :initarg :actions :reader circular-dependency-actions))
     (:report (lambda (c s)
-               (format s (compatfmt "~@<Circular dependency: ~3i~_~S~@:>")
+               (format s (compatfmt "~@<Circular dependency of ~s on: ~3i~_~S~@:>")
+                       (first (circular-dependency-actions c))
                        (circular-dependency-actions c)))))
 
   (defun call-while-visiting-action (operation component fun)
@@ -9967,7 +10152,13 @@ unless identically to toplevel"
     (reverse (plan-actions-r plan)))
 
   (defgeneric record-dependency (plan operation component)
-    (:documentation "Record an action as a dependency in the current plan"))
+    (:documentation "Record that, within PLAN, performing OPERATION on COMPONENT depends on all
+of the (OPERATION . COMPONENT) actions in the current ASDF session's VISITING-ACTION-LIST.
+
+You can get a single action which dominates the set of dependencies corresponding to this call with
+(first (visiting-action-list *asdf-session*))
+since VISITING-ACTION-LIST is a stack whose top action depends directly on its second action,
+and whose second action depends directly on its third action, and so forth."))
 
   ;; No need to record a dependency to build a full graph, just accumulate nodes in order.
   (defmethod record-dependency ((plan sequential-plan) (o operation) (c component))
@@ -10140,17 +10331,17 @@ to be meaningful, or could it just as well have been done in another Lisp image?
 
 ;;;; Visiting dependencies of an action and computing action stamps
 (with-upgradability ()
-  (defun* (map-direct-dependencies) (operation component fun)
+  (defun map-direct-dependencies (operation component fun)
     "Call FUN on all the valid dependencies of the given action in the given plan"
-    (loop* :for (dep-o-spec . dep-c-specs) :in (component-depends-on operation component)
-      :for dep-o = (find-operation operation dep-o-spec)
-      :when dep-o
-      :do (loop :for dep-c-spec :in dep-c-specs
-            :for dep-c = (and dep-c-spec (resolve-dependency-spec component dep-c-spec))
-            :when (action-valid-p dep-o dep-c)
-            :do (funcall fun dep-o dep-c))))
-
-  (defun* (reduce-direct-dependencies) (operation component combinator seed)
+    (loop :for (dep-o-spec . dep-c-specs) :in (component-depends-on operation component)
+          :for dep-o = (find-operation operation dep-o-spec)
+          :when dep-o
+            :do (loop :for dep-c-spec :in dep-c-specs
+                      :for dep-c = (and dep-c-spec (resolve-dependency-spec component dep-c-spec))
+                      :when (action-valid-p dep-o dep-c)
+                        :do (funcall fun dep-o dep-c))))
+
+  (defun reduce-direct-dependencies (operation component combinator seed)
     "Reduce the direct dependencies to a value computed by iteratively calling COMBINATOR
 for each dependency action on the dependency's operation and component and an accumulator
 initialized with SEED."
@@ -10159,7 +10350,7 @@ initialized with SEED."
      #'(lambda (dep-o dep-c) (setf seed (funcall combinator dep-o dep-c seed))))
     seed)
 
-  (defun* (direct-dependencies) (operation component)
+  (defun direct-dependencies (operation component)
     "Compute a list of the direct dependencies of the action within the plan"
     (reverse (reduce-direct-dependencies operation component #'acons nil)))
 
@@ -10443,7 +10634,7 @@ Update the VISITED-ACTIONS table with the known status, but don't add anything t
         :do (collect-action-dependencies plan (action-operation action) (action-component action)))
       (plan-actions plan)))
 
-  (defun* (required-components) (system &rest keys &key (goal-operation 'load-op) &allow-other-keys)
+  (defun required-components (system &rest keys &key (goal-operation 'load-op) &allow-other-keys)
     "Given a SYSTEM and a GOAL-OPERATION (default LOAD-OP), traverse the dependencies and
 return a list of the components involved in building the desired action."
     (with-asdf-session (:override t)
@@ -10855,7 +11046,7 @@ the implementation's REQUIRE rather than by internal ASDF mechanisms."))
   (defmethod component-depends-on ((o define-op) (s system))
     `(;;NB: 1- ,@(system-defsystem-depends-on s)) ; Should be already included in the below.
       ;; 2- We don't call-next-method to avoid other methods
-      ,@(loop* :for (o . c) :in (definition-dependency-list s) :collect (list o c))))
+      ,@(loop :for (o . c) :in (definition-dependency-list s) :collect (list o c))))
 
   (defmethod component-depends-on ((o operation) (s system))
     `(,@(when (and (not (typep o 'define-op))
@@ -11105,13 +11296,16 @@ PREVIOUS-PRIMARY when not null is the primary system for the PREVIOUS system."
   (:import-from :asdf/find-system #:define-op)
   (:export
    #:defsystem #:register-system-definition
-   #:class-for-type #:*default-component-class*
+   #:*default-component-class*
    #:determine-system-directory #:parse-component-form
    #:non-toplevel-system #:non-system-system #:bad-system-name
    #:*known-systems-with-bad-secondary-system-names*
    #:known-system-with-bad-secondary-system-names-p
    #:sysdef-error-component #:check-component-input
-   #:explain))
+   #:explain
+   ;; for extending the component types
+   #:compute-component-children
+   #:class-for-type))
 (in-package :asdf/parse-defsystem)
 
 ;;; Pathname
@@ -11139,20 +11333,33 @@ PREVIOUS-PRIMARY when not null is the primary system for the PREVIOUS system."
        nil)))))
 
 
+(when-upgrading (:version "3.3.4.17")
+  ;; This turned into a generic function in 3.3.4.17
+  (fmakunbound 'class-for-type))
+
 ;;; Component class
 (with-upgradability ()
   ;; What :file gets interpreted as, unless overridden by a :default-component-class
   (defvar *default-component-class* 'cl-source-file)
 
-  (defun class-for-type (parent type)
-      (or (coerce-class type :package :asdf/interface :super 'component :error nil)
-          (and (eq type :file)
-               (coerce-class
-                (or (loop :for p = parent :then (component-parent p) :while p
-                      :thereis (module-default-component-class p))
-                    *default-component-class*)
-                :package :asdf/interface :super 'component :error nil))
-          (sysdef-error "don't recognize component type ~S" type))))
+  (defgeneric class-for-type (parent type-designator)
+    (:documentation
+     "Return a CLASS object to be used to instantiate components specified by TYPE-DESIGNATOR in the context of PARENT."))
+
+  (defmethod class-for-type ((parent null) type)
+    "If the PARENT is NIL, then TYPE must designate a subclass of SYSTEM."
+    (or (coerce-class type :package :asdf/interface :super 'system :error nil)
+        (sysdef-error "don't recognize component type ~S in the context of no parent" type)))
+
+  (defmethod class-for-type ((parent parent-component) type)
+    (or (coerce-class type :package :asdf/interface :super 'component :error nil)
+        (and (eq type :file)
+             (coerce-class
+              (or (loop :for p = parent :then (component-parent p) :while p
+                          :thereis (module-default-component-class p))
+                  *default-component-class*)
+              :package :asdf/interface :super 'component :error nil))
+        (sysdef-error "don't recognize component type ~S" type))))
 
 
 ;;; Check inputs
@@ -11223,7 +11430,8 @@ Please only define ~S and secondary systems with a name starting with ~S (e.g. ~
   ;; Given a form used as :version specification, in the context of a system definition
   ;; in a file at PATHNAME, for given COMPONENT with given PARENT, normalize the form
   ;; to an acceptable ASDF-format version.
-  (defun* (normalize-version) (form &key pathname component parent)
+  (fmakunbound 'normalize-version) ;; signature changed between 2.27 and 2.31
+  (defun normalize-version (form &key pathname component parent)
     (labels ((invalid (&optional (continuation "using NIL instead"))
                (warn (compatfmt "~@<Invalid :version specifier ~S~@[ for component ~S~]~@[ in ~S~]~@[ from file ~S~]~@[, ~A~]~@:>")
                      form component parent pathname continuation))
@@ -11286,44 +11494,44 @@ Please only define ~S and secondary systems with a name starting with ~S (e.g. ~
   (defun %define-component-inline-methods (ret rest)
     ;; find key-value pairs that look like inline method definitions in REST. For each identified
     ;; definition, parse it and, if it is well-formed, define the method.
-    (loop* :for (key value) :on rest :by #'cddr
-           :for name = (and (keywordp key) (find key +asdf-methods+ :test 'string=))
-           :when name :do
-           ;; parse VALUE as an inline method definition of the form
-           ;;
-           ;;   (OPERATION-NAME [QUALIFIER] (OPERATION-PARAMETER COMPONENT-PARAMETER) &rest BODY)
-           (destructuring-bind (operation-name &rest rest) value
-             (let ((qualifiers '()))
-               ;; ensure that OPERATION-NAME is a symbol.
-               (unless (and (symbolp operation-name) (not (null operation-name)))
-                 (sysdef-error "Ill-formed inline method: ~S. The first element is not a symbol ~
+    (loop :for (key value) :on rest :by #'cddr
+          :for name = (and (keywordp key) (find key +asdf-methods+ :test 'string=))
+          :when name :do
+            ;; parse VALUE as an inline method definition of the form
+            ;;
+            ;;   (OPERATION-NAME [QUALIFIER] (OPERATION-PARAMETER COMPONENT-PARAMETER) &rest BODY)
+            (destructuring-bind (operation-name &rest rest) value
+              (let ((qualifiers '()))
+                ;; ensure that OPERATION-NAME is a symbol.
+                (unless (and (symbolp operation-name) (not (null operation-name)))
+                  (sysdef-error "Ill-formed inline method: ~S. The first element is not a symbol ~
                               designating an operation but ~S."
-                               value operation-name))
-               ;; ensure that REST starts with either a cons (potential lambda list, further checked
-               ;; below) or a qualifier accepted by the standard method combination. Everything else
-               ;; is ill-formed. In case of a valid qualifier, pop it from REST so REST now definitely
-               ;; has to start with the lambda list.
-               (cond
-                 ((consp (car rest)))
-                 ((not (member (car rest)
-                               *standard-method-combination-qualifiers*))
-                  (sysdef-error "Ill-formed inline method: ~S. Only a single of the standard ~
+                                value operation-name))
+                ;; ensure that REST starts with either a cons (potential lambda list, further checked
+                ;; below) or a qualifier accepted by the standard method combination. Everything else
+                ;; is ill-formed. In case of a valid qualifier, pop it from REST so REST now definitely
+                ;; has to start with the lambda list.
+                (cond
+                  ((consp (car rest)))
+                  ((not (member (car rest)
+                                *standard-method-combination-qualifiers*))
+                   (sysdef-error "Ill-formed inline method: ~S. Only a single of the standard ~
                                qualifiers ~{~S~^ ~} is allowed, not ~S."
-                                value *standard-method-combination-qualifiers* (car rest)))
-                 (t
-                  (setf qualifiers (list (pop rest)))))
-               ;; REST must start with a two-element lambda list.
-               (unless (and (listp (car rest))
-                            (length=n-p (car rest) 2)
-                            (null (cddar rest)))
-                 (sysdef-error "Ill-formed inline method: ~S. The operation name ~S is not followed by ~
+                                 value *standard-method-combination-qualifiers* (car rest)))
+                  (t
+                   (setf qualifiers (list (pop rest)))))
+                ;; REST must start with a two-element lambda list.
+                (unless (and (listp (car rest))
+                             (length=n-p (car rest) 2)
+                             (null (cddar rest)))
+                  (sysdef-error "Ill-formed inline method: ~S. The operation name ~S is not followed by ~
                               a lambda-list of the form (OPERATION COMPONENT) and a method body."
-                               value operation-name))
-               ;; define the method.
-               (destructuring-bind ((o c) &rest body) rest
-                 (pushnew
-                  (eval `(defmethod ,name ,@qualifiers ((,o ,operation-name) (,c (eql ,ret))) ,@body))
-                  (component-inline-methods ret)))))))
+                                value operation-name))
+                ;; define the method.
+                (destructuring-bind ((o c) &rest body) rest
+                  (pushnew
+                   (eval `(defmethod ,name ,@qualifiers ((,o ,operation-name) (,c (eql ,ret))) ,@body))
+                   (component-inline-methods ret)))))))
 
   (defun %refresh-component-inline-methods (component rest)
     ;; clear methods, then add the new ones
@@ -11359,7 +11567,20 @@ Please only define ~S and secondary systems with a name starting with ~S (e.g. ~
 system names contained using COERCE-NAME. Return the result."
     (mapcar 'parse-dependency-def dd-list))
 
-  (defun* (parse-component-form) (parent options &key previous-serial-component)
+  (defgeneric compute-component-children (component components serial-p)
+    (:documentation
+     "Return a list of children for COMPONENT.
+
+COMPONENTS is a list of the explicitly defined children descriptions.
+
+SERIAL-P is non-NIL if each child in COMPONENTS should depend on the previous
+children."))
+
+  (defun stable-union (s1 s2 &key (test #'eql) (key 'identity))
+   (append s1
+     (remove-if #'(lambda (e2) (member (funcall key e2) (funcall key s1) :test test)) s2)))
+
+  (defun parse-component-form (parent options &key previous-serial-components)
     (destructuring-bind
         (type name &rest rest &key
                                 (builtin-system-p () bspp)
@@ -11411,18 +11632,10 @@ system names contained using COERCE-NAME. Return the result."
         ;; A better fix is required.
         (setf (slot-value component 'version) version)
         (when (typep component 'parent-component)
-          (setf (component-children component)
-                (loop
-                  :with previous-component = nil
-                  :for c-form :in components
-                  :for c = (parse-component-form component c-form
-                                                 :previous-serial-component previous-component)
-                  :for name = (component-name c)
-                  :collect c
-                  :when serial :do (setf previous-component name)))
+          (setf (component-children component) (compute-component-children component components serial))
           (compute-children-by-name component))
-        (when previous-serial-component
-          (push previous-serial-component depends-on))
+        (when previous-serial-components
+          (setf depends-on (stable-union depends-on previous-serial-components :test #'equal)))
         (when weakly-depends-on
           ;; ASDF4: deprecate this feature and remove it.
           (appendf depends-on
@@ -11434,9 +11647,29 @@ system names contained using COERCE-NAME. Return the result."
           (error "The system definition for ~S uses deprecated ~
             ASDF option :IF-COMPONENT-DEP-FAILS. ~
             Starting with ASDF 3, please use :IF-FEATURE instead"
-           (coerce-name (component-system component))))
+                 (coerce-name (component-system component))))
         component)))
 
+  (defmethod compute-component-children ((component parent-component) components serial-p)
+    (loop
+      :with previous-components = nil ; list of strings
+      :for c-form :in components
+      :for c = (parse-component-form component c-form
+                                     :previous-serial-components previous-components)
+      :for name :of-type string = (component-name c)
+      :when serial-p
+        ;; if this is an if-feature component, we need to make a serial link
+        ;; from previous components to following components -- otherwise should
+        ;; the IF-FEATURE component drop out, the chain of serial dependencies will be
+        ;; broken.
+        :unless (component-if-feature c)
+          :do (setf previous-components nil)
+        :end
+        :and
+          :do (push name previous-components)
+      :end
+      :collect c))
+
   ;; the following are all systems that Stas Boukarev maintains and refuses to fix,
   ;; hoping instead to make my life miserable. Instead, I just make ASDF ignore them.
   (defparameter* *known-systems-with-bad-secondary-system-names*
@@ -11500,7 +11733,7 @@ system names contained using COERCE-NAME. Return the result."
          (error 'non-system-system :name name :class-name (class-name class)))
        (unless (eq (type-of system) class)
          (reset-system-class system class)))
-     (parse-component-form nil (list* :module name :pathname directory component-options))))
+     (parse-component-form nil (list* :system name :pathname directory component-options))))
 
   (defmacro defsystem (name &body options)
     `(apply 'register-system-definition ',name ',options)))
@@ -11724,7 +11957,8 @@ for all the linkable object files associated with the system or its dependencies
        (compile-file-type)) ; on image-based platforms, used as input and output
       ((eql :fasb) ;; the type of a fasl
        #-(or clasp ecl mkcl) (compile-file-type) ; on image-based platforms, used as input and output
-       #+(or clasp ecl mkcl) "fasb") ; on C-linking platforms, only used as output for system bundles
+       #+(or ecl mkcl) "fasb"
+       #+clasp "fasp") ; on C-linking platforms, only used as output for system bundles
       ((member :image)
        #+allegro "dxl"
        #+(and clisp os-windows) "exe"
@@ -11732,7 +11966,9 @@ for all the linkable object files associated with the system or its dependencies
       ;; NB: on CLASP and ECL these implementations, we better agree with
       ;; (compile-file-type :type bundle-type))
       ((eql :object) ;; the type of a linkable object file
-       (os-cond ((os-unix-p) "o")
+       (os-cond ((os-unix-p)
+                 #+clasp "fasp" ;(core:build-extension cmp:*default-object-type*)
+                 #-clasp "o")
                 ((os-windows-p) (if (featurep '(:or :mingw32 :mingw64)) "o" "obj"))))
       ((member :lib :static-library) ;; the type of a linkable library
        (os-cond ((os-unix-p) "a")
@@ -11937,6 +12173,9 @@ or of opaque libraries shipped along the source code."))
     (declare (ignorable o s))
     nil)
 
+  (defun space-for-crlf (s)
+    (substitute-if #\space #'(lambda (x) (find x +crlf+)) s))
+
   (defmethod perform ((o deliver-asd-op) (s system))
     "Write an ASDF system definition for loading S as a delivered system."
     (let* ((inputs (input-files o s))
@@ -11977,8 +12216,7 @@ which is probably not what you want; you probably need to tweak your output tran
                     (machine-type)
                     (software-version))))
           ;; ensure the whole thing is on one line
-          (print (remove-if #'(lambda (x) (member x (list #\newline #\return))) description-string) s)
-          (terpri s))
+          (println (space-for-crlf description-string) s))
         (let ((*package* (find-package :asdf-user)))
           (pprint `(defsystem ,name
                      :class prebuilt-system
@@ -12060,7 +12298,7 @@ which is probably not what you want; you probably need to tweak your output tran
   (defmethod component-depends-on :around ((o image-op) (c system))
     (let* ((next (call-next-method))
            (deps (make-hash-table :test 'equal))
-           (linkable (loop* :for (do . dcs) :in next :collect
+           (linkable (loop :for (do . dcs) :in next :collect
                        (cons do
                              (loop :for dc :in dcs
                                :for dep = (and dc (resolve-dependency-spec c dc))
@@ -12167,10 +12405,11 @@ into a single file"))
           :append
           (when (typep c 'cl-source-file)
             (let ((e (component-encoding c)))
-              (unless (equal e encoding)
+              (unless (or (equal e encoding)
+                          (and (equal e :ASCII) (equal encoding :UTF-8)))
                 (let ((a (assoc e other-encodings)))
                   (if a (push (component-find-path c) (cdr a))
-                      (push (list a (component-find-path c)) other-encodings)))))
+                      (push (list e (component-find-path c)) other-encodings)))))
             (unless (equal around-compile (around-compile-hook c))
               (push (component-find-path c) other-around-compile))
             (input-files (make-operation 'compile-op) c)) :into inputs
@@ -12271,17 +12510,17 @@ the DEFPACKAGE-FORM uses it or imports a symbol from it."
     (assert (defpackage-form-p defpackage-form))
     (remove-duplicates
      (while-collecting (dep)
-       (loop* :for (option . arguments) :in (cddr defpackage-form) :do
-              (ecase option
-                ((:use :mix :reexport :use-reexport :mix-reexport)
-                 (dolist (p arguments) (dep (string p))))
-                ((:import-from :shadowing-import-from)
-                 (dep (string (first arguments))))
-                #+sbcl
-                ((:local-nicknames)
-                 (loop* :for (local-nickname actual-package-name) :in arguments :do
-                      (dep (string actual-package-name))))
-                ((:nicknames :documentation :shadow :export :intern :unintern :recycle)))))
+       (loop :for (option . arguments) :in (cddr defpackage-form) :do
+         (ecase option
+           ((:use :mix :reexport :use-reexport :mix-reexport)
+            (dolist (p arguments) (dep (string p))))
+           ((:import-from :shadowing-import-from)
+            (dep (string (first arguments))))
+           #+package-local-nicknames
+           ((:local-nicknames)
+            (loop :for (nil actual-package-name) :in arguments :do
+              (dep (string actual-package-name))))
+           ((:nicknames :documentation :shadow :export :intern :unintern :recycle)))))
      :from-end t :test 'equal))
 
   (defun package-designator-name (package)
@@ -12327,28 +12566,37 @@ otherwise return a default system name computed from PACKAGE-NAME."
                             (equal (slot-value child 'relative-pathname) subpath))))))))
 
   ;; sysdef search function to push into *system-definition-search-functions*
-  (defun sysdef-package-inferred-system-search (system)
-    (let ((primary (primary-system-name system)))
-      (unless (equal primary system)
+  (defun sysdef-package-inferred-system-search (system-name)
+  "Takes SYSTEM-NAME and returns an initialized SYSTEM object, or NIL.  Made to be added to
+*SYSTEM-DEFINITION-SEARCH-FUNCTIONS*."
+    (let ((primary (primary-system-name system-name)))
+      ;; this function ONLY does something if the primary system name is NOT the same as
+      ;; SYSTEM-NAME.  It is used to find the systems with names that are relative to
+      ;; the primary system's name, and that are not explicitly specified in the system
+      ;; definition
+      (unless (equal primary system-name)
         (let ((top (find-system primary nil)))
           (when (typep top 'package-inferred-system)
             (if-let (dir (component-pathname top))
-              (let* ((sub (subseq system (1+ (length primary))))
-                     (f (probe-file* (subpathname dir sub :type "lisp")
+              (let* ((sub (subseq system-name (1+ (length primary))))
+                     (component-type (class-for-type top :file))
+                     (file-type (file-type (make-instance component-type)))
+                     (f (probe-file* (subpathname dir sub :type file-type)
                                      :truename *resolve-symlinks*)))
                 (when (file-pathname-p f)
-                  (let ((dependencies (package-inferred-system-file-dependencies f system))
-                        (previous (registered-system system))
+                  (let ((dependencies (package-inferred-system-file-dependencies f system-name))
+                        (previous (registered-system system-name))
                         (around-compile (around-compile-hook top)))
-                    (if (same-package-inferred-system-p previous system dir sub around-compile dependencies)
+                    (if (same-package-inferred-system-p previous system-name dir sub around-compile dependencies)
                         previous
-                        (eval `(defsystem ,system
+                        (eval `(defsystem ,system-name
                                  :class package-inferred-system
+                                 :default-component-class ,component-type
                                  :source-file ,(system-source-file top)
                                  :pathname ,dir
                                  :depends-on ,dependencies
                                  :around-compile ,around-compile
-                                 :components ((cl-source-file "lisp" :pathname ,sub)))))))))))))))
+                                 :components ((,component-type file-type :pathname ,sub)))))))))))))))
 
 (with-upgradability ()
   (pushnew 'sysdef-package-inferred-system-search *system-definition-search-functions*)
@@ -12551,7 +12799,7 @@ and the order is by decreasing length of namestring of the source pathname.")
     (when inherit
       (process-output-translations (first inherit) :collect collect :inherit (rest inherit))))
 
-  (defun* (process-output-translations-directive) (directive &key inherit collect)
+  (defun process-output-translations-directive (directive &key inherit collect)
     (if (atom directive)
         (ecase directive
           ((:enable-user-cache)
@@ -12644,25 +12892,25 @@ effectively disabling the output translation facility."
 
 
   ;; Top-level entry-point to _use_ output-translations
-  (defun* (apply-output-translations) (path)
+  (defun apply-output-translations (path)
     (etypecase path
       (logical-pathname
        path)
       ((or pathname string)
        (ensure-output-translations)
-       (loop* :with p = (resolve-symlinks* path)
-              :for (source destination) :in (car *output-translations*)
-              :for root = (when (or (eq source t)
-                                    (and (pathnamep source)
-                                         (not (absolute-pathname-p source))))
-                            (pathname-root p))
-              :for absolute-source = (cond
-                                       ((eq source t) (wilden root))
-                                       (root (merge-pathnames* source root))
-                                       (t source))
-              :when (or (eq source t) (pathname-match-p p absolute-source))
-              :return (translate-pathname* p absolute-source destination root source)
-              :finally (return p)))))
+       (loop :with p = (resolve-symlinks* path)
+             :for (source destination) :in (car *output-translations*)
+             :for root = (when (or (eq source t)
+                                   (and (pathnamep source)
+                                        (not (absolute-pathname-p source))))
+                           (pathname-root p))
+             :for absolute-source = (cond
+                                      ((eq source t) (wilden root))
+                                      (root (merge-pathnames* source root))
+                                      (t source))
+             :when (or (eq source t) (pathname-match-p p absolute-source))
+               :return (translate-pathname* p absolute-source destination root source)
+             :finally (return p)))))
 
 
   ;; Hook into uiop's output-translation mechanism
@@ -12933,11 +13181,11 @@ after having found a .asd file? True by default.")
 
   (defgeneric process-source-registry (spec &key inherit register))
 
-  (defun* (inherit-source-registry) (inherit &key register)
+  (defun inherit-source-registry (inherit &key register)
     (when inherit
       (process-source-registry (first inherit) :register register :inherit (rest inherit))))
 
-  (defun* (process-source-registry-directive) (directive &key inherit register)
+  (defun process-source-registry-directive (directive &key inherit register)
     (destructuring-bind (kw &rest rest) (if (consp directive) directive (list directive))
       (ecase kw
         ((:include)
@@ -13388,7 +13636,8 @@ system or its dependencies if it has already been loaded."
   ;; Note: (1) we are NOT automatically reexporting everything from previous packages.
   ;; (2) we only reexport UIOP functionality when backward-compatibility requires it.
   (:export
-   #:defsystem #:find-system #:load-asd #:locate-system #:coerce-name #:primary-system-name
+   #:defsystem #:find-system #:load-asd #:locate-system #:coerce-name
+   #:primary-system-name #:primary-system-p
    #:oos #:operate #:make-plan #:perform-plan #:sequential-plan
    #:system-definition-pathname
    #:search-for-system-definition #:find-component #:component-find-path
diff --git a/src/contrib/asdf/doc/asdf.html b/src/contrib/asdf/doc/asdf.html
index 14ae1fc0c9077bfd0f152761db2a4be3d6c1fc54..f6575bcd3ec4aa9c0a310fe984545141e9cd439c 100644
--- a/src/contrib/asdf/doc/asdf.html
+++ b/src/contrib/asdf/doc/asdf.html
@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
 <html>
+<!-- Created by GNU Texinfo 6.7dev, http://www.gnu.org/software/texinfo/ -->
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
 <!-- This manual describes ASDF, a system definition facility
 for Common Lisp programs and libraries.
 
@@ -31,9 +34,6 @@ LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  -->
-<!-- Created by GNU Texinfo 6.6dev, http://www.gnu.org/software/texinfo/ -->
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
 <title>ASDF Manual</title>
 
 <meta name="description" content="ASDF Manual">
@@ -45,8 +45,12 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 <link href="#Concept-Index" rel="index" title="Concept Index">
 <link href="#SEC_Contents" rel="contents" title="Table of Contents">
 <link href="dir.html#Top" rel="up" title="(dir)">
+<link href="#Introduction" rel="next" title="Introduction">
+<link href="dir.html#Top" rel="prev" title="(dir)">
 <style type="text/css">
 <!--
+*[id]:hover > a.permalink {visibility: visible}
+a.permalink {padding-left: 0.5em; visibility: hidden; text-decoration: none}
 a.summary-letter {text-decoration: none}
 blockquote.indentedblock {margin-right: 0em}
 div.display {margin-left: 3.2em}
@@ -147,13 +151,14 @@ ul.no-bullet {list-style: none}
         <li><a id="toc-Required-features" href="#Required-features">7.2.1.3 Required features</a></li>
         <li><a id="toc-Dependencies-1" href="#Dependencies-1">7.2.1.4 Dependencies</a></li>
         <li><a id="toc-pathname" href="#pathname">7.2.1.5 pathname</a></li>
-        <li><a id="toc-properties" href="#properties">7.2.1.6 properties</a></li>
+        <li><a id="toc-Properties" href="#Properties">7.2.1.6 Properties</a></li>
       </ul></li>
       <li><a id="toc-Pre_002ddefined-subclasses-of-component-1" href="#Pre_002ddefined-subclasses-of-component">7.2.2 Pre-defined subclasses of component</a></li>
       <li><a id="toc-Creating-new-component-types-1" href="#Creating-new-component-types">7.2.3 Creating new component types</a></li>
     </ul></li>
     <li><a id="toc-Dependencies-2" href="#Dependencies">7.3 Dependencies</a></li>
     <li><a id="toc-Functions-1" href="#Functions">7.4 Functions</a></li>
+    <li><a id="toc-Parsing-system-definitions-1" href="#Parsing-system-definitions">7.5 Parsing system definitions</a></li>
   </ul></li>
   <li><a id="toc-Controlling-where-ASDF-searches-for-systems-1" href="#Controlling-where-ASDF-searches-for-systems">8 Controlling where ASDF searches for systems</a>
   <ul class="no-bullet">
@@ -271,7 +276,7 @@ ul.no-bullet {list-style: none}
 
 
 <span id="Top"></span><span id="ASDF_003a-Another-System-Definition-Facility"></span><h1 class="top">ASDF: Another System Definition Facility</h1>
-<p>Manual for Version 3.3.4
+<p>Manual for Version 3.3.5
 </p>
 
 <p>This manual describes ASDF, a system definition facility
@@ -337,7 +342,7 @@ see <a href="#Using-ASDF">Using ASDF</a>,
 to learn how to use ASDF to load a system.
 See <a href="#Defining-systems-with-defsystem">Defining systems with defsystem</a>,
 to learn how to define a system of your own.
-See <a href="#The-object-model-of-ASDF">The object model of ASDF</a>, for a description of
+See <a href="#The-object-model-of-ASDF">The Object model of ASDF</a>, for a description of
 the ASDF internals and how to extend ASDF.
 </p>
 <p>Note that
@@ -440,7 +445,7 @@ that you can load this way using Common Lisp&rsquo;s <code>require</code> functi
 we recommend you upgrade it.
 If for some reason you would rather not upgrade it,
 we recommend you replace your implementation&rsquo;s ASDF.
-See <a href="#Replacing-your-implementation_0027s-ASDF">Replacing your implementation's ASDF</a>.
+See <a href="#Replacing-your-implementation_0027s-ASDF">Replacing your implementation&rsquo;s ASDF</a>.
 If all else fails, see see <a href="#Loading-ASDF-from-source">Loading ASDF from source</a> below.
 </p>
 <p>If you use an actively maintained implementation that fails to provide
@@ -509,7 +514,7 @@ ASDF 3 will automatically look whether an updated version of itself is available
 amongst the regularly configured systems, before it compiles anything else.
 </p>
 <p>If your implementation fails to provide ASDF 3 or later,
-see <a href="#Replacing-your-implementation_0027s-ASDF">Replacing your implementation's ASDF</a>.
+see <a href="#Replacing-your-implementation_0027s-ASDF">Replacing your implementation&rsquo;s ASDF</a>.
 </p>
 
 <hr>
@@ -643,7 +648,7 @@ If necessary, you can reset the source-registry configuration with:
 </li><li> In earlier versions of ASDF, the system source registry was configured
 using a global variable, <code>asdf:*central-registry*</code>.
 For more details about this, see the following section,
-<a href="#Configuring-ASDF-to-find-your-systems-_002d_002d_002d-old-style">Configuring ASDF to find your systems --- old style</a>.
+<a href="#Configuring-ASDF-to-find-your-systems-_002d_002d_002d-old-style">Configuring ASDF to find your systems &mdash; old style</a>.
 Unless you need to understand this,
 skip directly to <a href="#Configuring-where-ASDF-stores-object-files">Configuring where ASDF stores object files</a>.
 
@@ -687,7 +692,7 @@ in which case you will have to do it again indeed).
 However, if you are using an ancient ASDF 2 or earlier,
 we <em>strongly</em> recommend that you should instead upgrade your implementation,
 or overwrite the ancient ASDF installation with a more recent one:
-See <a href="#Replacing-your-implementation_0027s-ASDF">Replacing your implementation's ASDF</a>.
+See <a href="#Replacing-your-implementation_0027s-ASDF">Replacing your implementation&rsquo;s ASDF</a>.
 </p>
 <p>The <code>asdf:*central-registry*</code> is empty by default in ASDF 2 or ASDF 3,
 but is still supported for compatibility with ASDF 1.
@@ -787,8 +792,8 @@ to delegate object file placement to ASDF.
 you may want to reset the ASDF configuration.
 For that you may use the following function:
 </p>
-<dl>
-<dt id="index-clear_002dconfiguration">Function: <strong>clear-configuration</strong></dt>
+<dl class="def">
+<dt id="index-clear_002dconfiguration"><span class="category">Function: </span><strong>clear-configuration</strong><a href='#index-clear_002dconfiguration' class='permalink'>&para;</a></dt>
 <dd><p>Undoes any ASDF configuration
    regarding source-registry or output-translations.
 </p></dd></dl>
@@ -875,16 +880,16 @@ compiling, loading and testing.
 </p>
 
 
-<dl>
-<dt id="index-load_002dsystem">Function: <strong>load-system</strong> <em>system &amp;rest keys &amp;key force force-not verbose version &amp;allow-other-keys</em></dt>
+<dl class="def">
+<dt id="index-load_002dsystem"><span class="category">Function: </span><strong>load-system</strong> <em>system &amp;rest keys &amp;key force force-not verbose version &amp;allow-other-keys</em><a href='#index-load_002dsystem' class='permalink'>&para;</a></dt>
 <dd><p>Apply <code>operate</code> with the operation <code>load-op</code>, the
 <var>system</var>, and any provided keyword arguments.  Calling
 <code>load-system</code> is the regular, recommended way to load a system
 into the current image.
 </p></dd></dl>
 
-<dl>
-<dt id="index-compile_002dsystem">Function: <strong>compile-system</strong> <em>system &amp;rest keys &amp;key force force-not verbose version &amp;allow-other-keys</em></dt>
+<dl class="def">
+<dt id="index-compile_002dsystem"><span class="category">Function: </span><strong>compile-system</strong> <em>system &amp;rest keys &amp;key force force-not verbose version &amp;allow-other-keys</em><a href='#index-compile_002dsystem' class='permalink'>&para;</a></dt>
 <dd><p>Apply <code>operate</code> with the operation <code>compile-op</code>,
 the <var>system</var>, and any provided keyword arguments.
 This will make sure all the files in the system are compiled,
@@ -895,15 +900,15 @@ unless you are writing build scripts and know what you&rsquo;re doing.
 But then, you might be interested in <code>program-op</code> rather than <code>compile-op</code>.
 </p></dd></dl>
 
-<dl>
-<dt id="index-test_002dsystem">Function: <strong>test-system</strong> <em>system &amp;rest keys &amp;key force force-not verbose version &amp;allow-other-keys</em></dt>
+<dl class="def">
+<dt id="index-test_002dsystem"><span class="category">Function: </span><strong>test-system</strong> <em>system &amp;rest keys &amp;key force force-not verbose version &amp;allow-other-keys</em><a href='#index-test_002dsystem' class='permalink'>&para;</a></dt>
 <dd><p>Apply <code>operate</code> with the operation <code>test-op</code>,
 the <var>system</var>, and any provided keyword arguments.
 See <a href="#test_002dop">test-op</a>.
 </p></dd></dl>
 
-<dl>
-<dt id="index-make">Function: <strong>make</strong> <em>system &amp;rest keys &amp;key &amp;allow-other-keys</em></dt>
+<dl class="def">
+<dt id="index-make"><span class="category">Function: </span><strong>make</strong> <em>system &amp;rest keys &amp;key &amp;allow-other-keys</em><a href='#index-make' class='permalink'>&para;</a></dt>
 <dd><p>Do &ldquo;The Right Thing&rdquo; with your system.
 Starting with ASDF 3.1, this function <code>make</code> is also available.
 The default behaviour is to load the system as if by <code>load-system</code>;
@@ -917,8 +922,8 @@ This function is experimental and largely untested.  Use at your own risk.
 </p></dd></dl>
 <span id="index-build_002doperation"></span>
 
-<dl>
-<dt id="index-require_002dsystem">Function: <strong>require-system</strong> <em>system &amp;rest keys &amp;key &amp;allow-other-keys</em></dt>
+<dl class="def">
+<dt id="index-require_002dsystem"><span class="category">Function: </span><strong>require-system</strong> <em>system &amp;rest keys &amp;key &amp;allow-other-keys</em><a href='#index-require_002dsystem' class='permalink'>&para;</a></dt>
 <dd><p><code>require-system</code> skips any update to systems that have already been loaded,
 in the spirit of <code>cl:require</code>.
 It does it by calling <code>load-system</code> with a keyword option
@@ -949,8 +954,8 @@ ASDF itself never builds anything unless
 it&rsquo;s an explicitly requested system or the dependencies thereof).
 </p></dd></dl>
 
-<dl>
-<dt id="index-already_002dloaded_002dsystems">Function: <strong>already-loaded-systems</strong></dt>
+<dl class="def">
+<dt id="index-already_002dloaded_002dsystems"><span class="category">Function: </span><strong>already-loaded-systems</strong><a href='#index-already_002dloaded_002dsystems' class='permalink'>&para;</a></dt>
 <dd><p>Returns a list of names of the systems that have been successfully
 loaded so far.
 </p></dd></dl>
@@ -1145,7 +1150,7 @@ In this case <code>...</code> would expand to something like
 <p>For more details on the syntax of such forms,
 see <a href="#The-defsystem-grammar">The defsystem grammar</a>.
 For more details on what these methods do, see <a href="#Operations">Operations</a> in
-<a href="#The-object-model-of-ASDF">The object model of ASDF</a>.
+<a href="#The-object-model-of-ASDF">The Object model of ASDF</a>.
 </p>
 </li><li> There is an additional <code>defmethod</code> with a similar effect,
 because ASDF (as of ASDF 3.1.5)
@@ -1238,7 +1243,7 @@ Presumably, the 4th form looks like <code>(defparameter *foo-version* &quot;5.6.
 # see <a href="#Complex-component-names">Complex component names</a>
 <span id="rule_002dcomplex_002dcomponent_002dname"></span>complex-component-name := <var>string</var> | <var>symbol</var>
 
-<span id="rule_002dsystem_002doption"></span>system-option := :defsystem-depends-on <a href="#rule_002dsystem_002dlist">system-list</a>
+<span id="rule_002dsystem_002doption"></span>system-option := :defsystem-depends-on <a href="#rule_002ddependency_002ddef">dependency-def</a>
                | :weakly-depends-on <a href="#rule_002dsystem_002dlist">system-list</a>
                | :class <var>class-name</var> # see <a href="#System-class-names">System class names</a>
                | :build-pathname <a href="#rule_002dpathname_002dspecifier">pathname-specifier</a>
@@ -2011,9 +2016,9 @@ discuss these in turn below.
 
 
 <p>Operations are invoked on systems via <code>operate</code>.
-<span id="operate"></span></p><dl>
-<dt id="index-operate-1">Generic function: <strong>operate</strong> <em><var>operation</var> <var>component</var> &amp;rest <var>initargs</var> &amp;key <code>force</code> <code>force-not</code> <code>verbose</code> &amp;allow-other-keys</em></dt>
-<dt id="index-oos-1">Generic function: <strong>oos</strong> <em><var>operation</var> <var>component</var> &amp;rest <var>initargs</var> &amp;key &amp;allow-other-keys</em></dt>
+<span id="operate"></span></p><dl class="def">
+<dt id="index-operate-1"><span class="category">Generic function: </span><strong>operate</strong> <em><var>operation</var> <var>component</var> &amp;rest <var>initargs</var> &amp;key <code>force</code> <code>force-not</code> <code>verbose</code> &amp;allow-other-keys</em><a href='#index-operate-1' class='permalink'>&para;</a></dt>
+<dt id="index-oos-1"><span class="category">Generic function: </span><strong>oos</strong> <em><var>operation</var> <var>component</var> &amp;rest <var>initargs</var> &amp;key &amp;allow-other-keys</em><a href='#index-oos-1' class='permalink'>&para;</a></dt>
 <dd><p><code>operate</code> invokes <var>operation</var> on <var>system</var>.
 <code>oos</code> is a synonym for <code>operate</code> (it stands for operate-on-system).
 </p>
@@ -2065,8 +2070,8 @@ See <a href="#Miscellaneous-Functions">Miscellaneous Functions</a>.
 
 </dd></dl>
 
-<dl>
-<dt id="index-make_002doperation">Function: <strong>make-operation</strong> <em><var>operation-class</var> &amp;rest <var>initargs</var></em></dt>
+<dl class="def">
+<dt id="index-make_002doperation"><span class="category">Function: </span><strong>make-operation</strong> <em><var>operation-class</var> &amp;rest <var>initargs</var></em><a href='#index-make_002doperation' class='permalink'>&para;</a></dt>
 <dd><span id="make_002doperation"></span>
 <p>The <var>initargs</var> are passed to <code>make-instance</code> call
 when creating the operation object.
@@ -2091,8 +2096,8 @@ They are invoked via the <code>operate</code> generic function.
 <pre class="lisp">(asdf:operate 'asdf:<var>operation-name</var> :<var>system-name</var> {<var>operation-options ...</var>})
 </pre></div>
 
-<dl>
-<dt id="index-compile_002dop">Operation: <strong>compile-op</strong></dt>
+<dl class="def">
+<dt id="index-compile_002dop"><span class="category">Operation: </span><strong>compile-op</strong><a href='#index-compile_002dop' class='permalink'>&para;</a></dt>
 <dd>
 <p>This operation compiles the specified component.
 A <code>cl-source-file</code> will be <code>compile-file</code>&rsquo;d.
@@ -2109,8 +2114,8 @@ because nothing depends on them.
 Use <code>load-op</code> to load a system.
 </p></dd></dl>
 
-<dl>
-<dt id="index-load_002dop">Operation: <strong>load-op</strong></dt>
+<dl class="def">
+<dt id="index-load_002dop"><span class="category">Operation: </span><strong>load-op</strong><a href='#index-load_002dop' class='permalink'>&para;</a></dt>
 <dd>
 <p>This operation loads the compiled code for a specified component.
 A <code>cl-source-file</code> will have its compiled fasl <code>load</code>ed,
@@ -2123,8 +2128,8 @@ itself depends on a <code>load-op</code> of all of a component&rsquo;s dependenc
 as well as of its parent&rsquo;s dependencies.
 </p></dd></dl>
 
-<dl>
-<dt id="index-prepare_002dop">Operation: <strong>prepare-op</strong></dt>
+<dl class="def">
+<dt id="index-prepare_002dop"><span class="category">Operation: </span><strong>prepare-op</strong><a href='#index-prepare_002dop' class='permalink'>&para;</a></dt>
 <dd>
 <p>This operation ensures that the dependencies of a component
 and its recursive parents are loaded (as per <code>load-op</code>),
@@ -2132,9 +2137,9 @@ as a prerequisite before <code>compile-op</code> and <code>load-op</code> operat
 may be performed on a given component.
 </p></dd></dl>
 
-<dl>
-<dt id="index-load_002dsource_002dop">Operation: <strong>load-source-op</strong></dt>
-<dt id="index-prepare_002dsource_002dop">Operation: <strong>prepare-source-op</strong></dt>
+<dl class="def">
+<dt id="index-load_002dsource_002dop"><span class="category">Operation: </span><strong>load-source-op</strong><a href='#index-load_002dsource_002dop' class='permalink'>&para;</a></dt>
+<dt id="index-prepare_002dsource_002dop"><span class="category">Operation: </span><strong>prepare-source-op</strong><a href='#index-prepare_002dsource_002dop' class='permalink'>&para;</a></dt>
 <dd>
 <p><code>load-source-op</code> will load the source for the files in a module
 rather than the compiled fasl output.
@@ -2143,8 +2148,8 @@ that ensures the dependencies are themselves loaded via <code>load-source-op</co
 </p>
 </dd></dl>
 
-<span id="test_002dop"></span><dl>
-<dt id="index-test_002dop">Operation: <strong>test-op</strong></dt>
+<span id="test_002dop"></span><dl class="def">
+<dt id="index-test_002dop"><span class="category">Operation: </span><strong>test-op</strong><a href='#index-test_002dop' class='permalink'>&para;</a></dt>
 <dd>
 <p>This operation will perform some tests on the module.
 The default method will do nothing.
@@ -2196,19 +2201,19 @@ on a library.  For example, one might have
 
 
 
-<dl>
-<dt id="index-compile_002dbundle_002dop">Operation: <strong>compile-bundle-op</strong></dt>
-<dt id="index-monolithic_002dcompile_002dbundle_002dop">Operation: <strong>monolithic-compile-bundle-op</strong></dt>
-<dt id="index-load_002dbundle_002dop">Operation: <strong>load-bundle-op</strong></dt>
-<dt id="index-monolithic_002dload_002dbundle_002dop">Operation: <strong>monolithic-load-bundle-op</strong></dt>
-<dt id="index-deliver_002dasd_002dop">Operation: <strong>deliver-asd-op</strong></dt>
-<dt id="index-monolithic_002ddeliver_002dasd_002dop">Operation: <strong>monolithic-deliver-asd-op</strong></dt>
-<dt id="index-lib_002dop">Operation: <strong>lib-op</strong></dt>
-<dt id="index-monolithic_002dlib_002dop">Operation: <strong>monolithic-lib-op</strong></dt>
-<dt id="index-dll_002dop">Operation: <strong>dll-op</strong></dt>
-<dt id="index-monolithic_002ddll_002dop">Operation: <strong>monolithic-dll-op</strong></dt>
-<dt id="index-image_002dop">Operation: <strong>image-op</strong></dt>
-<dt id="index-program_002dop">Operation: <strong>program-op</strong></dt>
+<dl class="def">
+<dt id="index-compile_002dbundle_002dop"><span class="category">Operation: </span><strong>compile-bundle-op</strong><a href='#index-compile_002dbundle_002dop' class='permalink'>&para;</a></dt>
+<dt id="index-monolithic_002dcompile_002dbundle_002dop"><span class="category">Operation: </span><strong>monolithic-compile-bundle-op</strong><a href='#index-monolithic_002dcompile_002dbundle_002dop' class='permalink'>&para;</a></dt>
+<dt id="index-load_002dbundle_002dop"><span class="category">Operation: </span><strong>load-bundle-op</strong><a href='#index-load_002dbundle_002dop' class='permalink'>&para;</a></dt>
+<dt id="index-monolithic_002dload_002dbundle_002dop"><span class="category">Operation: </span><strong>monolithic-load-bundle-op</strong><a href='#index-monolithic_002dload_002dbundle_002dop' class='permalink'>&para;</a></dt>
+<dt id="index-deliver_002dasd_002dop"><span class="category">Operation: </span><strong>deliver-asd-op</strong><a href='#index-deliver_002dasd_002dop' class='permalink'>&para;</a></dt>
+<dt id="index-monolithic_002ddeliver_002dasd_002dop"><span class="category">Operation: </span><strong>monolithic-deliver-asd-op</strong><a href='#index-monolithic_002ddeliver_002dasd_002dop' class='permalink'>&para;</a></dt>
+<dt id="index-lib_002dop"><span class="category">Operation: </span><strong>lib-op</strong><a href='#index-lib_002dop' class='permalink'>&para;</a></dt>
+<dt id="index-monolithic_002dlib_002dop"><span class="category">Operation: </span><strong>monolithic-lib-op</strong><a href='#index-monolithic_002dlib_002dop' class='permalink'>&para;</a></dt>
+<dt id="index-dll_002dop"><span class="category">Operation: </span><strong>dll-op</strong><a href='#index-dll_002dop' class='permalink'>&para;</a></dt>
+<dt id="index-monolithic_002ddll_002dop"><span class="category">Operation: </span><strong>monolithic-dll-op</strong><a href='#index-monolithic_002ddll_002dop' class='permalink'>&para;</a></dt>
+<dt id="index-image_002dop"><span class="category">Operation: </span><strong>image-op</strong><a href='#index-image_002dop' class='permalink'>&para;</a></dt>
+<dt id="index-program_002dop"><span class="category">Operation: </span><strong>program-op</strong><a href='#index-program_002dop' class='permalink'>&para;</a></dt>
 <dd>
 <p>These are &ldquo;bundle&rdquo; operations, that can create a single-file &ldquo;bundle&rdquo;
 for all the contents of each system in an application,
@@ -2299,15 +2304,15 @@ This behaviour is not very satisfactory and may change in the future.
 Maybe you have suggestions on how to better configure it?
 </p></dd></dl>
 
-<dl>
-<dt id="index-concatenate_002dsource_002dop">Operation: <strong>concatenate-source-op</strong></dt>
-<dt id="index-monolithic_002dconcatenate_002dsource_002dop">Operation: <strong>monolithic-concatenate-source-op</strong></dt>
-<dt id="index-load_002dconcatenated_002dsource_002dop">Operation: <strong>load-concatenated-source-op</strong></dt>
-<dt id="index-compile_002dconcatenated_002dsource_002dop">Operation: <strong>compile-concatenated-source-op</strong></dt>
-<dt id="index-load_002dcompiled_002dconcatenated_002dsource_002dop">Operation: <strong>load-compiled-concatenated-source-op</strong></dt>
-<dt id="index-monolithic_002dload_002dconcatenated_002dsource_002dop">Operation: <strong>monolithic-load-concatenated-source-op</strong></dt>
-<dt id="index-monolithic_002dcompile_002dconcatenated_002dsource_002dop">Operation: <strong>monolithic-compile-concatenated-source-op</strong></dt>
-<dt id="index-monolithic_002dload_002dcompiled_002dconcatenated_002dsource_002dop">Operation: <strong>monolithic-load-compiled-concatenated-source-op</strong></dt>
+<dl class="def">
+<dt id="index-concatenate_002dsource_002dop"><span class="category">Operation: </span><strong>concatenate-source-op</strong><a href='#index-concatenate_002dsource_002dop' class='permalink'>&para;</a></dt>
+<dt id="index-monolithic_002dconcatenate_002dsource_002dop"><span class="category">Operation: </span><strong>monolithic-concatenate-source-op</strong><a href='#index-monolithic_002dconcatenate_002dsource_002dop' class='permalink'>&para;</a></dt>
+<dt id="index-load_002dconcatenated_002dsource_002dop"><span class="category">Operation: </span><strong>load-concatenated-source-op</strong><a href='#index-load_002dconcatenated_002dsource_002dop' class='permalink'>&para;</a></dt>
+<dt id="index-compile_002dconcatenated_002dsource_002dop"><span class="category">Operation: </span><strong>compile-concatenated-source-op</strong><a href='#index-compile_002dconcatenated_002dsource_002dop' class='permalink'>&para;</a></dt>
+<dt id="index-load_002dcompiled_002dconcatenated_002dsource_002dop"><span class="category">Operation: </span><strong>load-compiled-concatenated-source-op</strong><a href='#index-load_002dcompiled_002dconcatenated_002dsource_002dop' class='permalink'>&para;</a></dt>
+<dt id="index-monolithic_002dload_002dconcatenated_002dsource_002dop"><span class="category">Operation: </span><strong>monolithic-load-concatenated-source-op</strong><a href='#index-monolithic_002dload_002dconcatenated_002dsource_002dop' class='permalink'>&para;</a></dt>
+<dt id="index-monolithic_002dcompile_002dconcatenated_002dsource_002dop"><span class="category">Operation: </span><strong>monolithic-compile-concatenated-source-op</strong><a href='#index-monolithic_002dcompile_002dconcatenated_002dsource_002dop' class='permalink'>&para;</a></dt>
+<dt id="index-monolithic_002dload_002dcompiled_002dconcatenated_002dsource_002dop"><span class="category">Operation: </span><strong>monolithic-load-compiled-concatenated-source-op</strong><a href='#index-monolithic_002dload_002dcompiled_002dconcatenated_002dsource_002dop' class='permalink'>&para;</a></dt>
 <dd>
 <p>These operations, as their respective names indicate,
 will concatenate all the <code>cl-source-file</code> source files in a system
@@ -2430,8 +2435,8 @@ Most operations inherit from <code>selfward-operation</code>, which
 appropriately sets the input-files to include the source file itself.
 
 
-<dl>
-<dt id="index-input_002dfiles-1">Function: <strong>input-files</strong> <em>operation component</em></dt>
+<dl class="def">
+<dt id="index-input_002dfiles-1"><span class="category">Function: </span><strong>input-files</strong> <em>operation component</em><a href='#index-input_002dfiles-1' class='permalink'>&para;</a></dt>
 <dd><p>Return a list of pathnames that represent the input to <var>operation</var>
 performed on <var>component</var>.
 </p></dd></dl>
@@ -2481,8 +2486,8 @@ is either a component itself,
 or a string or symbol,
 or a list of designators.
 </p>
-<dl>
-<dt id="index-find_002dsystem">Function: <strong>find-system</strong> <em>system-designator &amp;optional (error-p t)</em></dt>
+<dl class="def">
+<dt id="index-find_002dsystem"><span class="category">Function: </span><strong>find-system</strong> <em>system-designator &amp;optional (error-p t)</em><a href='#index-find_002dsystem' class='permalink'>&para;</a></dt>
 <dd>
 <p>Given a system designator, <code>find-system</code> finds and returns a system.
 If no system is found, an error of type
@@ -2568,8 +2573,8 @@ though it is currently supported for backward compatibility.
 </p>
 </dd></dl>
 
-<dl>
-<dt id="index-primary_002dsystem_002dname-1">Function: <strong>primary-system-name</strong> <em>name</em></dt>
+<dl class="def">
+<dt id="index-primary_002dsystem_002dname-1"><span class="category">Function: </span><strong>primary-system-name</strong> <em>name</em><a href='#index-primary_002dsystem_002dname-1' class='permalink'>&para;</a></dt>
 <dd>
 <p>Internal (not exported) function, <code>asdf::primary-system-name</code>.
 Returns the primary system name (the portion before
@@ -2577,8 +2582,8 @@ the slash, <code>/</code>, in a secondary system name) from <var>name</var>.
 </p>
 </dd></dl>
 
-<dl>
-<dt id="index-locate_002dsystem">Function: <strong>locate-system</strong> <em>name</em></dt>
+<dl class="def">
+<dt id="index-locate_002dsystem"><span class="category">Function: </span><strong>locate-system</strong> <em>name</em><a href='#index-locate_002dsystem' class='permalink'>&para;</a></dt>
 <dd>
 <p>This function should typically <em>not</em> be invoked directly.  It is
 exported as part of the API only for programmers who wish to provide
@@ -2620,8 +2625,8 @@ then <var>locate-system</var> will return the following values:
 </li></ol>
 </dd></dl>
 
-<dl>
-<dt id="index-find_002dcomponent-1">Function: <strong>find-component</strong> <em>base path</em></dt>
+<dl class="def">
+<dt id="index-find_002dcomponent-1"><span class="category">Function: </span><strong>find-component</strong> <em>base path</em><a href='#index-find_002dcomponent-1' class='permalink'>&para;</a></dt>
 <dd>
 <p>Given a <var>base</var> component (or designator for such),
 and a <var>path</var>, find the component designated by the <var>path</var>
@@ -2819,8 +2824,8 @@ This is detailed elsewhere. See <a href="#Defining-systems-with-defsystem">Defin
 </p>
 <p>To find the CL pathname corresponding to a component, use
 </p>
-<dl>
-<dt id="index-component_002dpathname">Function: <strong>component-pathname</strong> <em>component</em></dt>
+<dl class="def">
+<dt id="index-component_002dpathname"><span class="category">Function: </span><strong>component-pathname</strong> <em>component</em><a href='#index-component_002dpathname' class='permalink'>&para;</a></dt>
 <dd><p>Returns the pathname corresponding to <var>component</var>.  For components
 such as source files, this will be a filename pathname.  For example:
 </p>
@@ -2842,7 +2847,7 @@ such as source files, this will be a filename pathname.  For example:
 
 
 
-<span id="properties"></span><h4 class="subsubsection">7.2.1.6 properties</h4>
+<span id="Properties"></span><h4 class="subsubsection">7.2.1.6 Properties</h4>
 
 <p>This attribute is optional.
 </p>
@@ -2863,8 +2868,8 @@ so use symbols or keywords or something.
 <hr>
 <span id="Pre_002ddefined-subclasses-of-component"></span><span id="Pre_002ddefined-subclasses-of-component-1"></span><h4 class="subsection">7.2.2 Pre-defined subclasses of component</h4>
 
-<dl>
-<dt id="index-source_002dfile">Component: <strong>source-file</strong></dt>
+<dl class="def">
+<dt id="index-source_002dfile"><span class="category">Component: </span><strong>source-file</strong><a href='#index-source_002dfile' class='permalink'>&para;</a></dt>
 <dd>
 <p>A source file is any file that the system does not know how to
 generate from other components of the system.
@@ -2883,8 +2888,8 @@ these do count as source files for our purposes.
 <em>FIXME: describe these.</em>
 </p></dd></dl>
 
-<dl>
-<dt id="index-module">Component: <strong>module</strong></dt>
+<dl class="def">
+<dt id="index-module"><span class="category">Component: </span><strong>module</strong><a href='#index-module' class='permalink'>&para;</a></dt>
 <dd>
 <p>A module is a collection of sub-components.
 </p>
@@ -2915,8 +2920,8 @@ most operations will not need to provide methods specialised on modules.
 foreign-language linked libraries or archive files.
 </p></dd></dl>
 
-<dl>
-<dt id="index-system-1">Component: <strong>system</strong></dt>
+<dl class="def">
+<dt id="index-system-1"><span class="category">Component: </span><strong>system</strong><a href='#index-system-1' class='permalink'>&para;</a></dt>
 <dd>
 <p><code>system</code> is a subclass of <code>module</code>.
 </p>
@@ -3007,8 +3012,8 @@ but instead do something global on the system.
 <hr>
 <span id="Functions"></span><span id="Functions-1"></span><h3 class="section">7.4 Functions</h3>
 
-<dl>
-<dt id="index-version_002dsatisfies-1">Function: <strong>version-satisfies</strong> <em><var>version</var> <var>version-spec</var></em></dt>
+<dl class="def">
+<dt id="index-version_002dsatisfies-1"><span class="category">Function: </span><strong>version-satisfies</strong> <em><var>version</var> <var>version-spec</var></em><a href='#index-version_002dsatisfies-1' class='permalink'>&para;</a></dt>
 <dd><p>Does <var>version</var> satisfy the <var>version-spec</var>.  A generic function.
 ASDF provides built-in methods for <var>version</var> being a <code>component</code> or <code>string</code>.
 <var>version-spec</var> should be a string.
@@ -3039,6 +3044,65 @@ could be in the future extended to specify an exclusive upper bound for compatib
 as well as an inclusive lower bound.
 </p></dd></dl>
 
+<hr>
+<span id="Parsing-system-definitions"></span><span id="Parsing-system-definitions-1"></span><h3 class="section">7.5 Parsing system definitions</h3>
+<span id="index-Parsing-system-definitions"></span>
+<span id="index-Extending-ASDF_0027s-defsystem-parser"></span>
+
+<p>Thanks to Eric Timmons, ASDF now provides hooks to extend how it parses
+<code>defsystem</code> forms.
+</p>
+<p><strong>Warning!</strong> These interfaces are experimental, and as such are not
+exported from the ASDF package yet. We plan to export them in ASDF
+3.4.0. If you use them before they are exported, please subscribe to
+<a href="https://gitlab.common-lisp.net/asdf/asdf/-/issues/76">https://gitlab.common-lisp.net/asdf/asdf/-/issues/76</a> so you are
+made aware of any changes.
+</p>
+<dl class="def">
+<dt id="index-parse_002dcomponent_002dform"><span class="category">Function: </span><strong>parse-component-form</strong> <em><var>parent</var> <var>options</var> &amp;key <var>previous-serial-components</var></em><a href='#index-parse_002dcomponent_002dform' class='permalink'>&para;</a></dt>
+<dd>
+<p>This is the core function for parsing a system definition. At the
+moment, we do not expect ASDF extenders to modify this function.
+</p>
+<p>When being called on a <code>component</code> of type <code>system</code> (i.e.,
+inside the <code>defsystem</code> macro), <var>parent</var> will be <code>NIL</code>.
+</p></dd></dl>
+
+<dl class="def">
+<dt id="index-compute_002dcomponent_002dchildren"><span class="category">Generic function: </span><strong>compute-component-children</strong> <em><var>component</var> <var>components</var> <var>serial-p</var></em><a href='#index-compute_002dcomponent_002dchildren' class='permalink'>&para;</a></dt>
+<dd>
+<p>This generic function provides standard means for computing component
+children, but can be extended with additional methods by a programmer.
+</p>
+<p>Returns a list of children (of type <code>component</code>) for <var>component</var>.
+<var>components</var> is a list of the explicitly defined children descriptions.
+<var>serial-p</var> is non-<code>NIL</code> if each child in <var>components</var> should depend on the previous
+children.
+</p>
+
+</dd></dl>
+
+<dl class="def">
+<dt id="index-class_002dfor_002dtype"><span class="category">Generic function: </span><strong>class-for-type</strong> <em><var>parent</var> <var>type-designator</var></em><a href='#index-class_002dfor_002dtype' class='permalink'>&para;</a></dt>
+<dd>
+<p>Return a <code>class</code> designator to be used to instantiate a component
+whose type is specified by <var>type-designator</var> in the context of
+<var>parent</var>, which should be either a <code>parent-component</code> &ndash; or subclass
+thereof &ndash; or <code>nil</code> (if the type designator is some class of system).
+</p>
+<p>This generic function provides a means for changing how ASDF translates
+type-designators (like <code>:file</code>) into CLOS classes.  It is intended
+for programmers to extend by adding new methods.
+</p>
+<p><strong>Warning!</strong> Adding new methods for <code>class-for-type</code> is
+typically <em>not</em> necessary: much can already be done by using
+<code>:default-component-class</code> and defining (and explicitly calling
+for) new component types.
+</p>
+</dd></dl>
+
+
+
 <hr>
 <span id="Controlling-where-ASDF-searches-for-systems"></span><span id="Controlling-where-ASDF-searches-for-systems-1"></span><h2 class="chapter">8 Controlling where ASDF searches for systems</h2>
 
@@ -3539,7 +3603,7 @@ The speedup will only happen if the implementation-provided ASDF is recent enoug
 since the upgrade will itself be found but
 after the old version has scanned the directories without heeding such a cache.
 To upgrade the implementation-provided ASDF,
-see <a href="#Replacing-your-implementation_0027s-ASDF">Replacing your implementation's ASDF</a>.
+see <a href="#Replacing-your-implementation_0027s-ASDF">Replacing your implementation&rsquo;s ASDF</a>.
 </p>
 
 <hr>
@@ -3549,8 +3613,8 @@ see <a href="#Replacing-your-implementation_0027s-ASDF">Replacing your implement
 Thus for ASDF the corresponding functions are in package ASDF,
 and for XCVB the corresponding functions are in package XCVB.
 </p>
-<dl>
-<dt id="index-initialize_002dsource_002dregistry">Function: <strong>initialize-source-registry</strong> <em>&amp;optional PARAMETER</em></dt>
+<dl class="def">
+<dt id="index-initialize_002dsource_002dregistry"><span class="category">Function: </span><strong>initialize-source-registry</strong> <em>&amp;optional PARAMETER</em><a href='#index-initialize_002dsource_002dregistry' class='permalink'>&para;</a></dt>
 <dd><p>will read the configuration and initialize all internal variables.
    You may extend or override configuration
    from the environment and configuration files
@@ -3562,8 +3626,8 @@ and for XCVB the corresponding functions are in package XCVB.
    or a symbol (fbound to function that when called returns one of the above).
 </p></dd></dl>
 
-<dl>
-<dt id="index-clear_002dsource_002dregistry">Function: <strong>clear-source-registry</strong></dt>
+<dl class="def">
+<dt id="index-clear_002dsource_002dregistry"><span class="category">Function: </span><strong>clear-source-registry</strong><a href='#index-clear_002dsource_002dregistry' class='permalink'>&para;</a></dt>
 <dd><p>undoes any source registry configuration
    and clears any cache for the search algorithm.
    You might want to call this function
@@ -3576,8 +3640,8 @@ and for XCVB the corresponding functions are in package XCVB.
    where to look for systems not yet defined.
 </p></dd></dl>
 
-<dl>
-<dt id="index-ensure_002dsource_002dregistry">Function: <strong>ensure-source-registry</strong> <em>&amp;optional PARAMETER</em></dt>
+<dl class="def">
+<dt id="index-ensure_002dsource_002dregistry"><span class="category">Function: </span><strong>ensure-source-registry</strong> <em>&amp;optional PARAMETER</em><a href='#index-ensure_002dsource_002dregistry' class='permalink'>&para;</a></dt>
 <dd><p>checks whether a source registry has been initialized.
    If not, initialize it with the given <var>PARAMETER</var>.
 </p></dd></dl>
@@ -3613,16 +3677,16 @@ read-only.
 These are intended to aid programmers who wish to perform dependency
 analyses.
 </p>
-<dl>
-<dt id="index-system_002ddefsystem_002ddepends_002don">Function: <strong>system-defsystem-depends-on</strong> <em>system</em></dt>
+<dl class="def">
+<dt id="index-system_002ddefsystem_002ddepends_002don"><span class="category">Function: </span><strong>system-defsystem-depends-on</strong> <em>system</em><a href='#index-system_002ddefsystem_002ddepends_002don' class='permalink'>&para;</a></dt>
 </dl>
 
-<dl>
-<dt id="index-system_002ddepends_002don">Function: <strong>system-depends-on</strong> <em>system</em></dt>
+<dl class="def">
+<dt id="index-system_002ddepends_002don"><span class="category">Function: </span><strong>system-depends-on</strong> <em>system</em><a href='#index-system_002ddepends_002don' class='permalink'>&para;</a></dt>
 </dl>
 
-<dl>
-<dt id="index-system_002dweakly_002ddepends_002don">Function: <strong>system-weakly-depends-on</strong> <em>system</em></dt>
+<dl class="def">
+<dt id="index-system_002dweakly_002ddepends_002don"><span class="category">Function: </span><strong>system-weakly-depends-on</strong> <em>system</em><a href='#index-system_002dweakly_002ddepends_002don' class='permalink'>&para;</a></dt>
 <dd><p>Returns a list of names of systems that are weakly depended on by
 <var>system</var>.  Weakly depended on systems are optionally loaded only if
 ASDF can find them; failure to find such systems does <em>not</em> cause an
@@ -3838,8 +3902,8 @@ as configured by the system distributor, or by default.
 <p>Nevertheless, if you are a fan of <code>ASDF-Binary-Locations</code>,
 we provide a limited emulation mode:
 </p>
-<dl>
-<dt id="index-enable_002dasdf_002dbinary_002dlocations_002dcompatibility">Function: <strong>enable-asdf-binary-locations-compatibility</strong> <em>&amp;key centralize-lisp-binaries default-toplevel-directory include-per-user-information map-all-source-files source-to-target-mappings</em></dt>
+<dl class="def">
+<dt id="index-enable_002dasdf_002dbinary_002dlocations_002dcompatibility"><span class="category">Function: </span><strong>enable-asdf-binary-locations-compatibility</strong> <em>&amp;key centralize-lisp-binaries default-toplevel-directory include-per-user-information map-all-source-files source-to-target-mappings</em><a href='#index-enable_002dasdf_002dbinary_002dlocations_002dcompatibility' class='permalink'>&para;</a></dt>
 <dd><p>This function will initialize the new <code>asdf-output-translations</code> facility in a way
 that emulates the behaviour of the old <code>ASDF-Binary-Locations</code> facility.
 Where you would previously set global variables
@@ -4105,8 +4169,8 @@ To explicitly flush any information cached by the system, use the API below.
 
 <p>The specified functions are exported from package ASDF.
 </p>
-<dl>
-<dt id="index-initialize_002doutput_002dtranslations">Function: <strong>initialize-output-translations</strong> <em>&amp;optional PARAMETER</em></dt>
+<dl class="def">
+<dt id="index-initialize_002doutput_002dtranslations"><span class="category">Function: </span><strong>initialize-output-translations</strong> <em>&amp;optional PARAMETER</em><a href='#index-initialize_002doutput_002dtranslations' class='permalink'>&para;</a></dt>
 <dd><p>will read the configuration and initialize all internal variables.
    You may extend or override configuration
    from the environment and configuration files
@@ -4118,15 +4182,15 @@ To explicitly flush any information cached by the system, use the API below.
    or a symbol (fbound to function that when called returns one of the above).
 </p></dd></dl>
 
-<dl>
-<dt id="index-disable_002doutput_002dtranslations">Function: <strong>disable-output-translations</strong></dt>
+<dl class="def">
+<dt id="index-disable_002doutput_002dtranslations"><span class="category">Function: </span><strong>disable-output-translations</strong><a href='#index-disable_002doutput_002dtranslations' class='permalink'>&para;</a></dt>
 <dd><p>will initialize output translations in a way
    that maps every pathname to itself,
    effectively disabling the output translation facility.
 </p></dd></dl>
 
-<dl>
-<dt id="index-clear_002doutput_002dtranslations-1">Function: <strong>clear-output-translations</strong></dt>
+<dl class="def">
+<dt id="index-clear_002doutput_002dtranslations-1"><span class="category">Function: </span><strong>clear-output-translations</strong><a href='#index-clear_002doutput_002dtranslations-1' class='permalink'>&para;</a></dt>
 <dd><p>undoes any output translation configuration
    and clears any cache for the mapping algorithm.
    You might want to call this function
@@ -4139,15 +4203,15 @@ To explicitly flush any information cached by the system, use the API below.
    where to look for systems not yet defined.
 </p></dd></dl>
 
-<dl>
-<dt id="index-ensure_002doutput_002dtranslations">Function: <strong>ensure-output-translations</strong> <em>&amp;optional PARAMETER</em></dt>
+<dl class="def">
+<dt id="index-ensure_002doutput_002dtranslations"><span class="category">Function: </span><strong>ensure-output-translations</strong> <em>&amp;optional PARAMETER</em><a href='#index-ensure_002doutput_002dtranslations' class='permalink'>&para;</a></dt>
 <dd><p>checks whether output translations have been initialized.
    If not, initialize them with the given <var>PARAMETER</var>.
    This function will be called before any attempt to operate on a system.
 </p></dd></dl>
 
-<dl>
-<dt id="index-apply_002doutput_002dtranslations">Function: <strong>apply-output-translations</strong> <em>PATHNAME</em></dt>
+<dl class="def">
+<dt id="index-apply_002doutput_002dtranslations"><span class="category">Function: </span><strong>apply-output-translations</strong> <em>PATHNAME</em><a href='#index-apply_002doutput_002dtranslations' class='permalink'>&para;</a></dt>
 <dd><p>Applies the configured output location translations to <var>PATHNAME</var>
    (calls <code>ensure-output-translations</code> for the translations).
 </p></dd></dl>
@@ -4425,8 +4489,8 @@ for the result probably isn&rsquo;t very portable.
 
 <p>These functions are exported by ASDF for your convenience.
 </p>
-<span id="system_002drelative_002dpathname"></span><dl>
-<dt id="index-system_002drelative_002dpathname">Function: <strong>system-relative-pathname</strong> <em>system name &amp;key type</em></dt>
+<span id="system_002drelative_002dpathname"></span><dl class="def">
+<dt id="index-system_002drelative_002dpathname"><span class="category">Function: </span><strong>system-relative-pathname</strong> <em>system name &amp;key type</em><a href='#index-system_002drelative_002dpathname' class='permalink'>&para;</a></dt>
 <dd>
 <p>It&rsquo;s often handy to locate a file relative to some system.
 The <code>system-relative-pathname</code> function meets this need.
@@ -4447,8 +4511,8 @@ source directory and the relative pathname. For example:
 
 </dd></dl>
 
-<dl>
-<dt id="index-system_002dsource_002ddirectory">Function: <strong>system-source-directory</strong> <em>system-designator</em></dt>
+<dl class="def">
+<dt id="index-system_002dsource_002ddirectory"><span class="category">Function: </span><strong>system-source-directory</strong> <em>system-designator</em><a href='#index-system_002dsource_002ddirectory' class='permalink'>&para;</a></dt>
 <dd>
 <p>ASDF does not provide a turnkey solution for locating
 data (or other miscellaneous) files
@@ -4458,8 +4522,8 @@ Returns a pathname object.
 The <var>system-designator</var> may be a string, symbol, or ASDF system object.
 </p></dd></dl>
 
-<dl>
-<dt id="index-clear_002dsystem">Function: <strong>clear-system</strong> <em>system-designator</em></dt>
+<dl class="def">
+<dt id="index-clear_002dsystem"><span class="category">Function: </span><strong>clear-system</strong> <em>system-designator</em><a href='#index-clear_002dsystem' class='permalink'>&para;</a></dt>
 <dd>
 <p>It is sometimes useful to force recompilation of a previously loaded system.
 For these cases, <code>(asdf:clear-system :foo)</code>
@@ -4488,8 +4552,8 @@ and get inspiration (or disinspiration)
 from what it does in <samp>header.lisp</samp> and <samp>upgrade.lisp</samp>.
 </p></dd></dl>
 
-<dl>
-<dt id="index-register_002dpreloaded_002dsystem">Function: <strong>register-preloaded-system</strong> <em>name &amp;rest keys &amp;key version &amp;allow-other-keys</em></dt>
+<dl class="def">
+<dt id="index-register_002dpreloaded_002dsystem"><span class="category">Function: </span><strong>register-preloaded-system</strong> <em>name &amp;rest keys &amp;key version &amp;allow-other-keys</em><a href='#index-register_002dpreloaded_002dsystem' class='permalink'>&para;</a></dt>
 <dd><p>A system with name <var>name</var>,
 created by <code>make-instance</code> with extra keys <var>keys</var>
 (e.g. <code>:version</code>),
@@ -4513,8 +4577,8 @@ its build information will remain active until you call <code>clear-system</code
 at which point a system without build information will be registered in its place.
 </p></dd></dl>
 
-<dl>
-<dt id="index-register_002dimmutable_002dsystem-1">Function: <strong>register-immutable-system</strong> <em>name &amp;rest keys</em></dt>
+<dl class="def">
+<dt id="index-register_002dimmutable_002dsystem-1"><span class="category">Function: </span><strong>register-immutable-system</strong> <em>name &amp;rest keys</em><a href='#index-register_002dimmutable_002dsystem-1' class='permalink'>&para;</a></dt>
 <dd><p>A system with name <var>name</var> is registered as preloaded,
 and additionally is marked as <em>immutable</em>:
 that is, attempts to compile or load it will be succeed
@@ -4541,8 +4605,8 @@ distributed as source code to regular users.
 <span id="index-immutable-systems-1"></span>
 </p></dd></dl>
 
-<dl>
-<dt id="index-run_002dshell_002dcommand">Function: <strong>run-shell-command</strong> <em>control-string &amp;rest args</em></dt>
+<dl class="def">
+<dt id="index-run_002dshell_002dcommand"><span class="category">Function: </span><strong>run-shell-command</strong> <em>control-string &amp;rest args</em><a href='#index-run_002dshell_002dcommand' class='permalink'>&para;</a></dt>
 <dd>
 <p>This function is obsolete and present only for the sake of backwards-compatibility:
 &ldquo;If it&rsquo;s not backwards, it&rsquo;s not compatible&rdquo;. We <em>strongly</em> discourage its use.
@@ -4573,8 +4637,8 @@ UIOP provides many, many more utility functions, and we recommend
 you read its <samp>README.md</samp> and sources for more information.
 </p>
 
-<dl>
-<dt id="index-parse_002dunix_002dnamestring">Function: <strong>parse-unix-namestring</strong> <em>name &amp;key type defaults dot-dot ensure-directory &amp;allow-other-keys</em></dt>
+<dl class="def">
+<dt id="index-parse_002dunix_002dnamestring"><span class="category">Function: </span><strong>parse-unix-namestring</strong> <em>name &amp;key type defaults dot-dot ensure-directory &amp;allow-other-keys</em><a href='#index-parse_002dunix_002dnamestring' class='permalink'>&para;</a></dt>
 <dd><p>Coerce <var>name</var> into a <var>pathname</var> using standard Unix syntax.
 </p>
 <p>Unix syntax is used whether or not the underlying system is Unix;
@@ -4620,8 +4684,8 @@ even though the OS may not be Unixish, we recommend you use <code>:want-relative
 so that <code>parse-unix-namestring</code> will throw an error if the pathname is absolute.
 </p></dd></dl>
 
-<dl>
-<dt id="index-merge_002dpathnames_002a">Function: <strong>merge-pathnames*</strong> <em>specified &amp;optional defaults</em></dt>
+<dl class="def">
+<dt id="index-merge_002dpathnames_002a"><span class="category">Function: </span><strong>merge-pathnames*</strong> <em>specified &amp;optional defaults</em><a href='#index-merge_002dpathnames_002a' class='permalink'>&para;</a></dt>
 <dd>
 <p>This function is a replacement for <code>merge-pathnames</code> that uses the host and device
 from the <var>defaults</var> rather than the <var>specified</var> pathname when the latter
@@ -4631,8 +4695,8 @@ of the absolute pathnames they are relative to.
 </p>
 </dd></dl>
 
-<dl>
-<dt id="index-subpathname">Function: <strong>subpathname</strong> <em>pathname subpath &amp;key type</em></dt>
+<dl class="def">
+<dt id="index-subpathname"><span class="category">Function: </span><strong>subpathname</strong> <em>pathname subpath &amp;key type</em><a href='#index-subpathname' class='permalink'>&para;</a></dt>
 <dd>
 <p>This function takes a <var>pathname</var> and a <var>subpath</var> and a <var>type</var>.
 If <var>subpath</var> is already a <code>pathname</code> object (not namestring),
@@ -4646,15 +4710,15 @@ as per <code>merge-pathnames*</code>.
 for portably resolving relative pathnames in your code base.
 </p></dd></dl>
 
-<dl>
-<dt id="index-subpathname_002a">Function: <strong>subpathname*</strong> <em>pathname subpath &amp;key type</em></dt>
+<dl class="def">
+<dt id="index-subpathname_002a"><span class="category">Function: </span><strong>subpathname*</strong> <em>pathname subpath &amp;key type</em><a href='#index-subpathname_002a' class='permalink'>&para;</a></dt>
 <dd>
 <p>This function returns <code>nil</code> if the base <var>pathname</var> is <code>nil</code>,
 otherwise acts like <code>subpathname</code>.
 </p></dd></dl>
 
-<dl>
-<dt id="index-run_002dprogram">Function: <strong>run-program</strong> <em>command &amp;key ignore-error-status force-shell input output error-output if-input-does-not-exist if-output-exists if-error-output-exists element-type external-format &amp;allow-other-keys</em></dt>
+<dl class="def">
+<dt id="index-run_002dprogram"><span class="category">Function: </span><strong>run-program</strong> <em>command &amp;key ignore-error-status force-shell input output error-output if-input-does-not-exist if-output-exists if-error-output-exists element-type external-format &amp;allow-other-keys</em><a href='#index-run_002dprogram' class='permalink'>&para;</a></dt>
 <dd>
 <p><code>run-program</code> takes a <var>command</var> argument that is either
 a list of a program name or path and its arguments,
@@ -4733,8 +4797,8 @@ See the source code for more documentation.
 </p>
 </dd></dl>
 
-<dl>
-<dt id="index-slurp_002dinput_002dstream">Function: <strong>slurp-input-stream</strong> <em>processor input-stream &amp;key</em></dt>
+<dl class="def">
+<dt id="index-slurp_002dinput_002dstream"><span class="category">Function: </span><strong>slurp-input-stream</strong> <em>processor input-stream &amp;key</em><a href='#index-slurp_002dinput_002dstream' class='permalink'>&para;</a></dt>
 <dd>
 <p><code>slurp-input-stream</code> is a generic function of two arguments, a target object and an input stream,
 and accepting keyword arguments.
@@ -4817,8 +4881,8 @@ mailing list (see <a href="#Mailing-list">Mailing list</a>).
 <span id="index-gitlab"></span>
 <span id="index-launchpad"></span>
 <p>ASDF bugs are tracked on common-lisp.net&rsquo;s gitlab:: <a href="https://gitlab.common-lisp.net/asdf/asdf/issues">https://gitlab.common-lisp.net/asdf/asdf/issues</a>.
-Previously, we had done bug-tracking on <code>launchpad.net</code>, but we are
-now consolidating project management on <code>common-lisp.net</code>.
+Previously, we had done bug-tracking on <a href="https://launchpad.net/asdf">https://launchpad.net/asdf</a>,
+but we are now consolidating project management on <code>common-lisp.net</code>.
 </p>
 <p>If you&rsquo;re unsure about whether something is a bug, or for general discussion,
 use the asdf-devel mailing list (see <a href="#Mailing-list">Mailing list</a>).
@@ -4931,7 +4995,7 @@ If it returns <code>&quot;1.0&quot;</code>, then it can actually be
 any version before 1.77 or so, or some buggy variant of 1.x.
 If it returns anything older than <code>&quot;3.0.1&quot;</code>,
 you really need to upgrade your implementation or at least upgrade its ASDF.
-See <a href="#Replacing-your-implementation_0027s-ASDF">Replacing your implementation's ASDF</a>.
+See <a href="#Replacing-your-implementation_0027s-ASDF">Replacing your implementation&rsquo;s ASDF</a>.
 </p>
 
 
@@ -4961,7 +5025,9 @@ See <a href="#Miscellaneous-additional-functionality">system-relative-pathname</
 where you must now use an explicit pathname object:
 <code>(defsystem ... :pathname &quot;LOGICAL-HOST:PATH;TO;SYSTEM;&quot; ...)</code>
 must now be written with the <code>#p</code> syntax:
-<code>(defsystem ... :pathname #p&quot;LOGICAL-HOST:PATH;TO;SYSTEM;&quot; ...)</code>
+<code>(defsystem ... :pathname #p&quot;LOGICAL-HOST:PATH;TO;SYSTEM;&quot; ...)</code>.
+We recommend against using pathname objects in general and logical pathnames in particular.
+Your code will be much more portable using ASDF&rsquo;s pathname specifiers.
 </p>
 <p>See <a href="#Pathname-specifiers">Pathname specifiers</a>.
 </p>
@@ -5031,7 +5097,7 @@ and also allows for new magic, simpler and more powerful magic.
 to load a system,
 and similarly for <code>compile-op</code>, <code>test-op</code>.
 </p>
-<p>In ASDF 2, you can use shortcuts for the usual operations:
+<p>In ASDF 2 and later, you can use shortcuts for the usual operations:
 <code>(asdf:load-system :foo)</code>, and
 similarly for <code>compile-system</code>, <code>test-system</code>.
 </p>
@@ -5052,8 +5118,11 @@ with fundamental issues in the original model being fixed.
 Timestamps were not propagated at all, and now are.
 The internal model of how actions depend on each other
 is now both consistent and complete.
+As of ASDF 3.3, multiple phases of loading are well supported,
+wherein correctly interpreting &lsquo;defsystem&lsquo; statements in some &lsquo;.asd&lsquo; files
+itself depends on loading other systems, e.g. via &lsquo;:defsystem-depends-on&lsquo;.
 The <code>:version</code> and
-the <code>:force (system1 .. systemN)</code> feature have been fixed.
+the <code>:force (system1 .. systemN)</code> features have been fixed.
 
 </li><li> Performance has been notably improved for large systems
 (say with thousands of components) by using
@@ -5089,9 +5158,10 @@ People using or writing systems had to either make worst-case assumptions
 as to what features were available and worked,
 or take great pains to have the correct version of ASDF installed.
 </p>
-<p>With ASDF 2, we provide a new stable set of working features
+<p>With ASDF 2 and later, we provide a new stable set of working features
 that everyone can rely on from now on.
-Use <code>#+asdf2</code> to detect presence of ASDF 2,
+Use <code>#+asdf2</code>, <code>#+asdf3</code>, <code>#+asdf3.1</code> or <code>#+asdf3.3</code>
+to detect presence of relevant versions of ASDF and their features, or
 <code>(asdf:version-satisfies (asdf:asdf-version) &quot;2.345.67&quot;)</code>
 to check the availability of a version no earlier than required.
 </p>
@@ -5291,7 +5361,7 @@ or a commit on their public source code repository)
 provide ASDF 3.1 or later,
 the simple solution is just to use code as below in your setup,
 and when it fails, upgrade your implementation or replace its ASDF.
-(see <a href="#Replacing-your-implementation_0027s-ASDF">Replacing your implementation's ASDF</a>):
+(see <a href="#Replacing-your-implementation_0027s-ASDF">Replacing your implementation&rsquo;s ASDF</a>):
 <div class="example">
 <pre class="example">(require &quot;asdf&quot;)
 #-asdf3.1 (error &quot;ASDF 3.1 or bust&quot;)
@@ -5375,7 +5445,7 @@ See <a href="#Upgrading-ASDF">Upgrading ASDF</a>.
 </p>
 <p>If you have an old implementation that does not provide ASDF 3,
 we recommend you replace your implementation&rsquo;s ASDF.
-See <a href="#Replacing-your-implementation_0027s-ASDF">Replacing your implementation's ASDF</a>.
+See <a href="#Replacing-your-implementation_0027s-ASDF">Replacing your implementation&rsquo;s ASDF</a>.
 </p>
 
 <hr>
@@ -5556,7 +5626,7 @@ you believe that it should be able to.  There are a number of things you
 can do to debug such issues.
 </p>
 <span id="index-_002acentral_002dregistry_002a-1"></span>
-<p>If you are using <code>asdf:*central-registry*</code> (see <a href="#Configuring-ASDF-to-find-your-systems-_002d_002d_002d-old-style">Configuring ASDF to find your systems --- old style</a>),
+<p>If you are using <code>asdf:*central-registry*</code> (see <a href="#Configuring-ASDF-to-find-your-systems-_002d_002d_002d-old-style">Configuring ASDF to find your systems &mdash; old style</a>),
 you can
 simply look at the pathnames and namestrings in this variable, and use
 conventional tools such as <code>cl:probe-file</code> and <code>cl:directory</code>
@@ -5603,7 +5673,7 @@ a topic of considerable discussion on the
 <a href="http://common-lisp.net/cgi-bin/mailman/listinfo/asdf-devel">asdf-devel mailing list</a>
 (see <a href="#Mailing-list">Mailing list</a>),
 and on the
-<a href="https://launchpad.net/asdf">launchpad bug-tracker</a> (see <a href="#Where-do-I-report-a-bug_003f">Where do I report a bug?</a>).
+<a href="https://launchpad.net/asdf">launchpad bug-tracker</a> (see <a href="#Where-do-I-report-a-bug_003f">&ldquo;Where do I report a bug?&rdquo;</a>).
 We provide some guidelines in the discussion of <code>test-op</code>.
 </p>
 
@@ -6118,6 +6188,7 @@ see the <samp>TODO</samp> file in the source repository.
 <tr><td colspan="4"> <hr></td></tr>
 <tr><th id="Concept-Index_cp_letter-E">E</th><td></td><td></td></tr>
 <tr><td></td><td valign="top"><a href="#index-exclude-source-config-directive">exclude source config directive</a>:</td><td>&nbsp;</td><td valign="top"><a href="#Configuration-DSL">Configuration DSL</a></td></tr>
+<tr><td></td><td valign="top"><a href="#index-Extending-ASDF_0027s-defsystem-parser">Extending ASDF&rsquo;s defsystem parser</a>:</td><td>&nbsp;</td><td valign="top"><a href="#Parsing-system-definitions">Parsing system definitions</a></td></tr>
 <tr><td colspan="4"> <hr></td></tr>
 <tr><th id="Concept-Index_cp_letter-G">G</th><td></td><td></td></tr>
 <tr><td></td><td valign="top"><a href="#index-gitlab">gitlab</a>:</td><td>&nbsp;</td><td valign="top"><a href="#Where-do-I-report-a-bug_003f">Where do I report a bug?</a></td></tr>
@@ -6143,6 +6214,7 @@ see the <samp>TODO</samp> file in the source repository.
 <tr><th id="Concept-Index_cp_letter-P">P</th><td></td><td></td></tr>
 <tr><td></td><td valign="top"><a href="#index-Package-inferred-systems">Package inferred systems</a>:</td><td>&nbsp;</td><td valign="top"><a href="#The-package_002dinferred_002dsystem-extension">The package-inferred-system extension</a></td></tr>
 <tr><td></td><td valign="top"><a href="#index-Packages_002c-inferring-dependencies-from">Packages, inferring dependencies from</a>:</td><td>&nbsp;</td><td valign="top"><a href="#The-package_002dinferred_002dsystem-extension">The package-inferred-system extension</a></td></tr>
+<tr><td></td><td valign="top"><a href="#index-Parsing-system-definitions">Parsing system definitions</a>:</td><td>&nbsp;</td><td valign="top"><a href="#Parsing-system-definitions">Parsing system definitions</a></td></tr>
 <tr><td></td><td valign="top"><a href="#index-pathname-specifiers">pathname specifiers</a>:</td><td>&nbsp;</td><td valign="top"><a href="#The-defsystem-grammar">The defsystem grammar</a></td></tr>
 <tr><td></td><td valign="top"><a href="#index-Primary-system-name">Primary system name</a>:</td><td>&nbsp;</td><td valign="top"><a href="#Components">Components</a></td></tr>
 <tr><td colspan="4"> <hr></td></tr>
@@ -6248,6 +6320,7 @@ see the <samp>TODO</samp> file in the source repository.
 <tr><td></td><td valign="top"><a href="#index-asdf_002dversion"><code>asdf-version</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#How-do-I-detect-the-ASDF-version_003f">How do I detect the ASDF version?</a></td></tr>
 <tr><td colspan="4"> <hr></td></tr>
 <tr><th id="Function-and-Macro-Index_fn_letter-C">C</th><td></td><td></td></tr>
+<tr><td></td><td valign="top"><a href="#index-class_002dfor_002dtype"><code>class-for-type</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#Parsing-system-definitions">Parsing system definitions</a></td></tr>
 <tr><td></td><td valign="top"><a href="#index-clear_002dconfiguration"><code>clear-configuration</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#Resetting-the-ASDF-configuration">Resetting the ASDF configuration</a></td></tr>
 <tr><td></td><td valign="top"><a href="#index-clear_002doutput_002dtranslations"><code>clear-output-translations</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#Configuring-where-ASDF-stores-object-files">Configuring where ASDF stores object files</a></td></tr>
 <tr><td></td><td valign="top"><a href="#index-clear_002doutput_002dtranslations-1"><code>clear-output-translations</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#Output-location-API">Output location API</a></td></tr>
@@ -6260,6 +6333,7 @@ see the <samp>TODO</samp> file in the source repository.
 <tr><td></td><td valign="top"><a href="#index-compile_002dsystem"><code>compile-system</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#Convenience-Functions">Convenience Functions</a></td></tr>
 <tr><td></td><td valign="top"><a href="#index-component_002ddepends_002don"><code>component-depends-on</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#Creating-new-operations">Creating new operations</a></td></tr>
 <tr><td></td><td valign="top"><a href="#index-component_002dpathname"><code>component-pathname</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#Common-attributes-of-components">Common attributes of components</a></td></tr>
+<tr><td></td><td valign="top"><a href="#index-compute_002dcomponent_002dchildren"><code>compute-component-children</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#Parsing-system-definitions">Parsing system definitions</a></td></tr>
 <tr><td colspan="4"> <hr></td></tr>
 <tr><th id="Function-and-Macro-Index_fn_letter-D">D</th><td></td><td></td></tr>
 <tr><td></td><td valign="top"><a href="#index-define_002dpackage"><code>define-package</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#The-package_002dinferred_002dsystem-extension">The package-inferred-system extension</a></td></tr>
@@ -6306,6 +6380,7 @@ see the <samp>TODO</samp> file in the source repository.
 <tr><td colspan="4"> <hr></td></tr>
 <tr><th id="Function-and-Macro-Index_fn_letter-P">P</th><td></td><td></td></tr>
 <tr><td></td><td valign="top"><a href="#index-package_002dinferred_002dsystem"><code>package-inferred-system</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#The-package_002dinferred_002dsystem-extension">The package-inferred-system extension</a></td></tr>
+<tr><td></td><td valign="top"><a href="#index-parse_002dcomponent_002dform"><code>parse-component-form</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#Parsing-system-definitions">Parsing system definitions</a></td></tr>
 <tr><td></td><td valign="top"><a href="#index-parse_002dunix_002dnamestring"><code>parse-unix-namestring</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#Some-Utility-Functions">Some Utility Functions</a></td></tr>
 <tr><td></td><td valign="top"><a href="#index-perform"><code>perform</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#Creating-new-operations">Creating new operations</a></td></tr>
 <tr><td></td><td valign="top"><a href="#index-primary_002dsystem_002dname"><code>primary-system-name</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="#Components">Components</a></td></tr>
@@ -6542,12 +6617,12 @@ see the <samp>TODO</samp> file in the source repository.
 <hr>
 <h4 class="footnotes-heading">Footnotes</h4>
 
-<h5><a id="FOOT1" href="#DOCF1">(1)</a></h3>
+<h5><a id="FOOT1" href="#DOCF1">(1)</a></h5>
 <p>NB: all implementations except GNU CLISP also accept
 <code>(require &quot;ASDF&quot;)</code>, <code>(require 'asdf)</code> and <code>(require :asdf)</code>.
 For portability&rsquo;s sake, you should use <code>(require &quot;asdf&quot;)</code>.
 </p>
-<h5><a id="FOOT2" href="#DOCF2">(2)</a></h3>
+<h5><a id="FOOT2" href="#DOCF2">(2)</a></h5>
 <p><samp>~/common-lisp/</samp> is only included in
   the default configuration
   starting with ASDF 3.1.2 or later.
@@ -6555,7 +6630,7 @@ For portability&rsquo;s sake, you should use <code>(require &quot;asdf&quot;)</c
   you may need to explicitly configure it to use this path,
   as further explained.
 </p>
-<h5><a id="FOOT3" href="#DOCF3">(3)</a></h3>
+<h5><a id="FOOT3" href="#DOCF3">(3)</a></h5>
 <p>For Windows users, and starting with ASDF 3.1.5, start from your
   <samp>%LOCALAPPDATA%</samp>, which is usually <samp>~/AppData/Local/</samp>
   (but you can ask in a <code>CMD.EXE</code> terminal
@@ -6563,7 +6638,7 @@ For portability&rsquo;s sake, you should use <code>(require &quot;asdf&quot;)</c
   and underneath create a subpath
   <samp>config/common-lisp/source-registry.conf.d/</samp>.
 </p>
-<h5><a id="FOOT4" href="#DOCF4">(4)</a></h3>
+<h5><a id="FOOT4" href="#DOCF4">(4)</a></h5>
 <p>By requiring the <samp>.conf</samp>
   extension, and ignoring other files, ASDF allows you to have disabled files,
   editor backups, etc. in the same directory with your active
@@ -6575,14 +6650,14 @@ For portability&rsquo;s sake, you should use <code>(require &quot;asdf&quot;)</c
   sorting of the <code>conf</code> files in the source registry directory, and
   thus the order in which the directories will be scanned.
 </p>
-<h5><a id="FOOT5" href="#DOCF5">(5)</a></h3>
+<h5><a id="FOOT5" href="#DOCF5">(5)</a></h5>
 <p>It is possible to further customize
 the system definition file search.
 That&rsquo;s considered advanced use, and covered later:
 search forward for
 <code>*system-definition-search-functions*</code>.
 See <a href="#Defining-systems-with-defsystem">Defining systems with defsystem</a>.</p>
-<h5><a id="FOOT6" href="#DOCF6">(6)</a></h3>
+<h5><a id="FOOT6" href="#DOCF6">(6)</a></h5>
 <p>ASDF will indeed call <code>eval</code> on each entry.
 It will skip entries that evaluate to <code>nil</code>.
 </p>
@@ -6601,14 +6676,14 @@ and must evaluate to a directory to look in (or <code>nil</code>).
 By &ldquo;directory&rdquo;, we mean
 &ldquo;designator for a pathname with a non-empty DIRECTORY component&rdquo;.
 </p>
-<h5><a id="FOOT7" href="#DOCF7">(7)</a></h3>
+<h5><a id="FOOT7" href="#DOCF7">(7)</a></h5>
 <p>On Windows, you can use Windows shortcuts instead of POSIX symlinks.
   if you try aliases under MacOS, we are curious to hear about your experience.
 </p>
-<h5><a id="FOOT8" href="#DOCF8">(8)</a></h3>
+<h5><a id="FOOT8" href="#DOCF8">(8)</a></h5>
 <p>For the curious, the option is <code>:force-not (already-loaded-systems)</code>.
 </p>
-<h5><a id="FOOT9" href="#DOCF9">(9)</a></h3>
+<h5><a id="FOOT9" href="#DOCF9">(9)</a></h5>
 <p>ASDF 1 and 2 (up until 2.26)
   used to dynamically create and delete temporary packages <code>asdf<em>N</em></code>,
   one for each <samp>.asd</samp> file, in a misguided attempt to thereby reduce name clashes;
@@ -6621,7 +6696,7 @@ By &ldquo;directory&rdquo;, we mean
   deficiencies in more obscure Common Lisp implementations;
   but unless you care about Corman Lisp, GCL, Genera or MCL, you shouldn&rsquo;t be concerned.
 </p>
-<h5><a id="FOOT10" href="#DOCF10">(10)</a></h3>
+<h5><a id="FOOT10" href="#DOCF10">(10)</a></h5>
 <p>Historically, the function that built a plan was
   called <code>traverse</code>, and returned a list of actions;
   it was deprecated in favor of <code>make-plan</code> (that returns a plan object)
@@ -6629,7 +6704,7 @@ By &ldquo;directory&rdquo;, we mean
   the old function is kept for backward compatibility and debugging purposes only,
   and may be removed in the near future.
 </p>
-<h5><a id="FOOT11" href="#DOCF11">(11)</a></h3>
+<h5><a id="FOOT11" href="#DOCF11">(11)</a></h5>
 <p>The term <em>action</em>
   was used by Kent Pitman in his article, &ldquo;The Description of Large Systems,&rdquo;
   (see <a href="#Bibliography">Bibliography</a>),
@@ -6638,13 +6713,13 @@ By &ldquo;directory&rdquo;, we mean
   the concept was there since the very beginning of ASDF 1,
   just not clearly articulated.
 </p>
-<h5><a id="FOOT12" href="#DOCF12">(12)</a></h3>
+<h5><a id="FOOT12" href="#DOCF12">(12)</a></h5>
 <p>Note that between releases 2.27 and 3.0.3, only <code>UIOP/PACKAGE</code>,
 not all of <code>UIOP</code>, was used; if you want your code to work
 with releases earlier than 3.1.2, you may have to explicitly define a package
 that uses <code>UIOP</code>, or use proper package prefix to your symbols, as in
 <code>uiop:version&lt;</code>.</p>
-<h5><a id="FOOT13" href="#DOCF13">(13)</a></h3>
+<h5><a id="FOOT13" href="#DOCF13">(13)</a></h5>
 <p>ASDF 2.26 and earlier versions
 do not support this primary system name convention.
 With these versions of ASDF
@@ -6653,14 +6728,14 @@ before you can use system <var>foo/bar</var> defined therein,
 e.g. using <code>(asdf:find-system &quot;foo&quot;)</code>.
 We do not support ASDF 2, and recommend that you should upgrade to ASDF 3.
 </p>
-<h5><a id="FOOT14" href="#DOCF14">(14)</a></h3>
+<h5><a id="FOOT14" href="#DOCF14">(14)</a></h5>
 <p>&ldquo;FASL&rdquo; is short for &ldquo;FASt Loading.&rdquo;</p>
-<h5><a id="FOOT15" href="#DOCF15">(15)</a></h3>
+<h5><a id="FOOT15" href="#DOCF15">(15)</a></h5>
 <p>A <code>CLEAN-OP</code> would be a partial solution to this problem.</p>
-<h5><a id="FOOT16" href="#DOCF16">(16)</a></h3>
+<h5><a id="FOOT16" href="#DOCF16">(16)</a></h5>
 <p>Alternatively, you could touch <code>foo.asd</code> or
 remove the corresponding fasls from the output file cache.</p>
-<h5><a id="FOOT17" href="#DOCF17">(17)</a></h3>
+<h5><a id="FOOT17" href="#DOCF17">(17)</a></h5>
 <span id="index-_002aoldest_002dforward_002dcompatible_002dasdf_002dversion_002a"></span>
 <p>Forward incompatibility can be determined using the variable
 <code>asdf/upgrade::*oldest-forward-compatible-asdf-version*</code>,
diff --git a/src/contrib/asdf/doc/asdf.info b/src/contrib/asdf/doc/asdf.info
index 9f05deb27f779b208dd1b6b4977c1c169bb1a393..3a1f9ae8cf57ce5feba74f704b33254521374a34 100644
--- a/src/contrib/asdf/doc/asdf.info
+++ b/src/contrib/asdf/doc/asdf.info
@@ -1,4 +1,4 @@
-This is asdf.info, produced by makeinfo version 6.6dev from
+This is asdf.info, produced by makeinfo version 6.7dev from
 asdf.texinfo.
 
 This manual describes ASDF, a system definition facility for Common Lisp
@@ -44,7 +44,7 @@ File: asdf.info,  Node: Top,  Next: Introduction,  Prev: (dir),  Up: (dir)
 ASDF: Another System Definition Facility
 ****************************************
 
-Manual for Version 3.3.4
+Manual for Version 3.3.5
 
    This manual describes ASDF, a system definition facility for Common
 Lisp programs and libraries.
@@ -137,6 +137,7 @@ The Object model of ASDF
 * Components::
 * Dependencies::
 * Functions::
+* Parsing system definitions::
 
 Operations
 
@@ -149,7 +150,7 @@ Components
 * Pre-defined subclasses of component::
 * Creating new component types::
 
-properties
+Properties
 
 * Pre-defined subclasses of component::
 * Creating new component types::
@@ -1186,7 +1187,7 @@ File: asdf.info,  Node: The defsystem grammar,  Next: Other code in .asd files,
      # *note Complex component names: Complex component names.
      complex-component-name := STRING | SYMBOL
 
-     system-option := :defsystem-depends-on *note system-list: (system-list)rule-system-list.
+     system-option := :defsystem-depends-on *note dependency-def: (dependency-def)rule-dependency-def.
                     | :weakly-depends-on *note system-list: (system-list)rule-system-list.
                     | :class CLASS-NAME # *note System class names::
                     | :build-pathname *note pathname-specifier: (pathname-specifier)rule-pathname-specifier.
@@ -1867,6 +1868,7 @@ configured to customize the behaviour of existing _functions_.
 * Components::
 * Dependencies::
 * Functions::
+* Parsing system definitions::
 
    ---------- Footnotes ----------
 
@@ -1915,7 +1917,7 @@ in turn below.
 
    Operations are invoked on systems via ‘operate’.
  -- Generic function: operate OPERATION COMPONENT &rest INITARGS &key
-          ‘force’ ‘force-not’ ‘verbose’ &allow-other-keys
+          force force-not verbose &allow-other-keys
  -- Generic function: oos OPERATION COMPONENT &rest INITARGS &key
           &allow-other-keys
      ‘operate’ invokes OPERATION on SYSTEM.  ‘oos’ is a synonym for
@@ -2637,7 +2639,7 @@ systems with defsystem::.
                         (asdf:find-system "xmls") "xmls"))
           #P"/Users/rpg/lisp/xmls/xmls.lisp"
 
-7.2.1.6 properties
+7.2.1.6 Properties
 ..................
 
 This attribute is optional.
@@ -2793,7 +2795,7 @@ remain at the system level, and are not propagated along the hierarchy,
 but instead do something global on the system.
 
 
-File: asdf.info,  Node: Functions,  Prev: Dependencies,  Up: The object model of ASDF
+File: asdf.info,  Node: Functions,  Next: Parsing system definitions,  Prev: Dependencies,  Up: The object model of ASDF
 
 7.4 Functions
 =============
@@ -2826,6 +2828,59 @@ File: asdf.info,  Node: Functions,  Prev: Dependencies,  Up: The object model of
      to specify an exclusive upper bound for compatible versions as well
      as an inclusive lower bound.
 
+
+File: asdf.info,  Node: Parsing system definitions,  Prev: Functions,  Up: The object model of ASDF
+
+7.5 Parsing system definitions
+==============================
+
+Thanks to Eric Timmons, ASDF now provides hooks to extend how it parses
+‘defsystem’ forms.
+
+   *Warning!*  These interfaces are experimental, and as such are not
+exported from the ASDF package yet.  We plan to export them in ASDF
+3.4.0.  If you use them before they are exported, please subscribe to
+<https://gitlab.common-lisp.net/asdf/asdf/-/issues/76> so you are made
+aware of any changes.
+
+ -- Function: parse-component-form PARENT OPTIONS &key
+          PREVIOUS-SERIAL-COMPONENTS
+
+     This is the core function for parsing a system definition.  At the
+     moment, we do not expect ASDF extenders to modify this function.
+
+     When being called on a ‘component’ of type ‘system’ (i.e., inside
+     the ‘defsystem’ macro), PARENT will be ‘NIL’.
+
+ -- Generic function: compute-component-children COMPONENT COMPONENTS
+          SERIAL-P
+
+     This generic function provides standard means for computing
+     component children, but can be extended with additional methods by
+     a programmer.
+
+     Returns a list of children (of type ‘component’) for COMPONENT.
+     COMPONENTS is a list of the explicitly defined children
+     descriptions.  SERIAL-P is non-‘NIL’ if each child in COMPONENTS
+     should depend on the previous children.
+
+ -- Generic function: class-for-type PARENT TYPE-DESIGNATOR
+
+     Return a ‘class’ designator to be used to instantiate a component
+     whose type is specified by TYPE-DESIGNATOR in the context of
+     PARENT, which should be either a ‘parent-component’ – or subclass
+     thereof – or ‘nil’ (if the type designator is some class of
+     system).
+
+     This generic function provides a means for changing how ASDF
+     translates type-designators (like ‘:file’) into CLOS classes.  It
+     is intended for programmers to extend by adding new methods.
+
+     *Warning!*  Adding new methods for ‘class-for-type’ is typically
+     _not_ necessary: much can already be done by using
+     ‘:default-component-class’ and defining (and explicitly calling
+     for) new component types.
+
 
 File: asdf.info,  Node: Controlling where ASDF searches for systems,  Next: Controlling where ASDF saves compiled files,  Prev: The object model of ASDF,  Up: Top
 
@@ -4557,8 +4612,8 @@ File: asdf.info,  Node: Where do I report a bug?,  Next: Mailing list,  Prev: FA
 
 ASDF bugs are tracked on common-lisp.net’s gitlab::
 <https://gitlab.common-lisp.net/asdf/asdf/issues>.  Previously, we had
-done bug-tracking on ‘launchpad.net’, but we are now consolidating
-project management on ‘common-lisp.net’.
+done bug-tracking on <https://launchpad.net/asdf>, but we are now
+consolidating project management on ‘common-lisp.net’.
 
    If you’re unsure about whether something is a bug, or for general
 discussion, use the asdf-devel mailing list (*note Mailing list::).
@@ -4716,7 +4771,9 @@ additional functionality, ‘merge-pathnames*’, ‘coerce-pathname’.
 namestrings where you must now use an explicit pathname object:
 ‘(defsystem ... :pathname "LOGICAL-HOST:PATH;TO;SYSTEM;" ...)’ must now
 be written with the ‘#p’ syntax: ‘(defsystem ... :pathname
-#p"LOGICAL-HOST:PATH;TO;SYSTEM;" ...)’
+#p"LOGICAL-HOST:PATH;TO;SYSTEM;" ...)’.  We recommend against using
+pathname objects in general and logical pathnames in particular.  Your
+code will be much more portable using ASDF’s pathname specifiers.
 
    *Note Pathname specifiers::.
 
@@ -4786,7 +4843,7 @@ File: asdf.info,  Node: Usual operations are made easier to the user,  Next: Man
 In ASDF 1, you had to use the awkward syntax ‘(asdf:oos 'asdf:load-op
 :foo)’ to load a system, and similarly for ‘compile-op’, ‘test-op’.
 
-   In ASDF 2, you can use shortcuts for the usual operations:
+   In ASDF 2 and later, you can use shortcuts for the usual operations:
 ‘(asdf:load-system :foo)’, and similarly for ‘compile-system’,
 ‘test-system’.
 
@@ -4805,8 +4862,12 @@ The following issues and many others have been fixed:
      2.000 and ASDF 3, with fundamental issues in the original model
      being fixed.  Timestamps were not propagated at all, and now are.
      The internal model of how actions depend on each other is now both
-     consistent and complete.  The ‘:version’ and the ‘:force (system1
-     .. systemN)’ feature have been fixed.
+     consistent and complete.  As of ASDF 3.3, multiple phases of
+     loading are well supported, wherein correctly interpreting
+     ‘defsystem‘ statements in some ‘.asd‘ files itself depends on
+     loading other systems, e.g.  via ‘:defsystem-depends-on‘.  The
+     ‘:version’ and the ‘:force (system1 .. systemN)’ features have been
+     fixed.
 
    • Performance has been notably improved for large systems (say with
      thousands of components) by using hash-tables instead of linear
@@ -4841,10 +4902,12 @@ had to either make worst-case assumptions as to what features were
 available and worked, or take great pains to have the correct version of
 ASDF installed.
 
-   With ASDF 2, we provide a new stable set of working features that
-everyone can rely on from now on.  Use ‘#+asdf2’ to detect presence of
-ASDF 2, ‘(asdf:version-satisfies (asdf:asdf-version) "2.345.67")’ to
-check the availability of a version no earlier than required.
+   With ASDF 2 and later, we provide a new stable set of working
+features that everyone can rely on from now on.  Use ‘#+asdf2’,
+‘#+asdf3’, ‘#+asdf3.1’ or ‘#+asdf3.3’ to detect presence of relevant
+versions of ASDF and their features, or ‘(asdf:version-satisfies
+(asdf:asdf-version) "2.345.67")’ to check the availability of a version
+no earlier than required.
 
 
 File: asdf.info,  Node: ASDF can be upgraded,  Next: Decoupled release cycle,  Prev: ASDF itself is versioned,  Up: What has changed between ASDF 1 ASDF 2 and ASDF 3?
@@ -5817,6 +5880,8 @@ Concept Index
                                                               (line   6)
 * directory source config directive:     Configuration DSL.   (line   6)
 * exclude source config directive:       Configuration DSL.   (line   6)
+* Extending ASDF’s defsystem parser:     Parsing system definitions.
+                                                              (line   6)
 * gitlab:                                Where do I report a bug?.
                                                               (line   6)
 * ignore-invalid-entries source config directive: Configuration DSL.
@@ -5839,6 +5904,8 @@ Concept Index
                                                               (line   6)
 * Packages, inferring dependencies from: The package-inferred-system extension.
                                                               (line   6)
+* Parsing system definitions:            Parsing system definitions.
+                                                              (line   6)
 * pathname specifiers:                   The defsystem grammar.
                                                               (line 226)
 * Primary system name:                   Components.          (line  70)
@@ -5870,6 +5937,8 @@ Function and Macro Index
 * apply-output-translations:             Output location API. (line  36)
 * asdf-version:                          How do I detect the ASDF version?.
                                                               (line   6)
+* class-for-type:                        Parsing system definitions.
+                                                              (line  36)
 * clear-configuration:                   Resetting the ASDF configuration.
                                                               (line  10)
 * clear-output-translations:             Configuring where ASDF stores object files.
@@ -5891,6 +5960,8 @@ Function and Macro Index
                                                               (line  45)
 * component-pathname:                    Common attributes of components.
                                                               (line 154)
+* compute-component-children:            Parsing system definitions.
+                                                              (line  24)
 * define-package:                        The package-inferred-system extension.
                                                               (line  64)
 * defsystem:                             The defsystem form.  (line   6)
@@ -5938,6 +6009,8 @@ Function and Macro Index
                                                               (line  33)
 * package-inferred-system:               The package-inferred-system extension.
                                                               (line   6)
+* parse-component-form:                  Parsing system definitions.
+                                                              (line  15)
 * parse-unix-namestring:                 Some Utility Functions.
                                                               (line  13)
 * perform:                               Creating new operations.
@@ -6127,184 +6200,185 @@ Class and Type Index
 
 Tag Table:
 Node: Top1692
-Node: Introduction7878
-Node: Quick start summary10307
-Node: Loading ASDF12070
-Node: Loading a pre-installed ASDF12372
-Ref: Loading a pre-installed ASDF-Footnote-114207
-Node: Checking whether ASDF is loaded14407
-Node: Upgrading ASDF15321
-Node: Replacing your implementation's ASDF16319
-Node: Loading ASDF from source17771
-Node: Configuring ASDF18894
-Node: Configuring ASDF to find your systems19667
-Ref: Configuring ASDF to find your systems-Footnote-123068
-Ref: Configuring ASDF to find your systems-Footnote-223319
-Ref: Configuring ASDF to find your systems-Footnote-323621
-Node: Configuring ASDF to find your systems --- old style24094
-Ref: Configuring ASDF to find your systems --- old style-Footnote-127770
-Ref: Configuring ASDF to find your systems --- old style-Footnote-228008
-Ref: Configuring ASDF to find your systems --- old style-Footnote-328811
-Node: Configuring where ASDF stores object files28967
-Node: Resetting the ASDF configuration30376
-Node: Using ASDF31469
-Node: Loading a system31680
-Node: Convenience Functions32755
-Ref: Convenience Functions-Footnote-138232
-Node: Moving on38314
-Node: Defining systems with defsystem38687
-Node: The defsystem form39115
-Node: A more involved example42650
-Ref: A more involved example-Footnote-149903
-Node: The defsystem grammar50611
-Ref: rule-system-definition50816
-Ref: rule-system-designator50982
-Ref: rule-simple-component-name51303
-Ref: rule-complex-component-name51424
-Ref: rule-system-option51472
-Ref: rule-system-option/asdf352251
-Ref: rule-source-control52712
-Ref: rule-module-option52755
-Ref: rule-option52891
-Ref: rule-person-or-persons53879
-Ref: rule-system-list53927
-Ref: rule-component-list54033
-Ref: rule-component-def54118
-Ref: rule-component-type54320
-Ref: rule-other-component-type54454
-Ref: rule-dependency-def54626
-Ref: rule-dependency55235
-Ref: rule-requirement55362
-Ref: rule-dependent-op55456
-Ref: rule-required-op55536
-Ref: rule-pathname-specifier55729
-Ref: rule-version-specifier55784
-Ref: rule-line-specifier56171
-Ref: rule-form-specifier56218
-Ref: rule-method-form56273
-Ref: rule-qual56408
-Ref: rule-method-qualifier56487
-Ref: rule-feature-expression56540
-Ref: rule-operation-name56898
-Ref: Simple component names57193
-Ref: Complex component names58204
-Ref: Component types58920
-Ref: System class names59402
-Ref: Build-operation60611
-Ref: Pathname specifiers62197
-Ref: Version specifiers66233
-Ref: Feature dependencies68482
-Ref: Using logical pathnames69353
-Ref: if-feature option73994
-Ref: Entry point75131
-Ref: feature requirement75861
-Node: Other code in .asd files76279
-Node: The package-inferred-system extension77451
-Node: The object model of ASDF83216
-Ref: The object model of ASDF-Footnote-185603
-Ref: The object model of ASDF-Footnote-285967
-Node: Operations86302
-Ref: operate87429
-Ref: make-operation90227
-Node: Predefined operations of ASDF90672
-Ref: test-op92904
-Node: Creating new operations101145
-Node: Components106550
-Ref: System names110172
-Ref: Components-Footnote-1114990
-Ref: Components-Footnote-2115302
-Node: Common attributes of components115632
-Ref: required-features117154
-Node: Pre-defined subclasses of component123094
-Node: Creating new component types125594
-Node: Dependencies126902
-Node: Functions128831
-Node: Controlling where ASDF searches for systems130688
-Node: Configurations131310
-Node: Truenames and other dangers134877
-Node: XDG base directory136185
-Node: Backward Compatibility137631
-Node: Configuration DSL138362
-Node: Configuration Directories143925
-Node: The here directive145792
-Node: Shell-friendly syntax for configuration147719
-Node: Search Algorithm148794
-Node: Caching Results150688
-Node: Configuration API153996
-Node: Introspection156079
-Node: *source-registry-parameter* variable156343
-Node: Information about system dependencies156922
-Node: Status157842
-Node: Rejected ideas158305
-Node: TODO160758
-Node: Credits for the source-registry160945
-Node: Controlling where ASDF saves compiled files161481
-Ref: Controlling where ASDF saves compiled files-Footnote-1162911
-Node: Output Configurations162963
-Ref: Output Configurations-Footnote-1165852
-Node: Output Backward Compatibility165922
-Node: Output Configuration DSL168730
-Node: Output Configuration Directories174301
-Node: Output Shell-friendly syntax for configuration175890
-Node: Semantics of Output Translations177453
-Node: Output Caching Results179022
-Node: Output location API179502
-Node: Credits for output translations181970
-Node: Error handling182499
-Node: Miscellaneous additional functionality183360
-Node: Controlling file compilation183832
-Node: Controlling source file character encoding187170
-Node: Miscellaneous Functions194221
-Ref: system-relative-pathname194518
-Ref: Miscellaneous Functions-Footnote-1201080
-Node: Some Utility Functions201195
-Node: Getting the latest version212363
-Node: FAQ213326
-Node: Where do I report a bug?213721
-Node: Mailing list214267
-Node: What has changed between ASDF 1 ASDF 2 and ASDF 3?214606
-Node: What are ASDF 1 2 3?216801
-Node: How do I detect the ASDF version?217846
-Node: ASDF can portably name files in subdirectories220205
-Node: Output translations221764
-Node: Source Registry Configuration222807
-Node: Usual operations are made easier to the user224444
-Node: Many bugs have been fixed225054
-Node: ASDF itself is versioned226906
-Node: ASDF can be upgraded227789
-Node: Decoupled release cycle228943
-Node: Pitfalls of the transition to ASDF 2229874
-Node: Pitfalls of the upgrade to ASDF 3234264
-Ref: reinitializeASDFAfterUpgrade238016
-Ref: Pitfalls of the upgrade to ASDF 3-Footnote-1238892
-Node: What happened to the bundle operations239066
-Node: Issues with installing the proper version of ASDF240315
-Node: My Common Lisp implementation comes with an outdated version of ASDF. What to do?240878
-Node: I'm a Common Lisp implementation vendor. When and how should I upgrade ASDF?241817
-Node: After upgrading ASDF245843
-Node: Issues with configuring ASDF247504
-Node: How can I customize where fasl files are stored?247929
-Node: How can I wholly disable the compiler output cache?249051
-Node: How can I debug problems finding ASDF systems250512
-Node: Issues with using and extending ASDF to define systems251941
-Node: How can I cater for unit-testing in my system?252738
-Node: How can I cater for documentation generation in my system?253642
-Node: How can I maintain non-Lisp (e.g. C) source files?254171
-Ref: report-bugs254617
-Node: I want to put my module's files at the top level. How do I do this?254617
-Node: How do I create a system definition where all the source files have a .cl extension?257823
-Node: How do I mark a source file to be loaded only and not compiled?259828
-Node: How do I work with readtables?260830
-Node: How can I capture ASDF's output?264655
-Node: LOAD-PATHNAME has a weird value265136
-Node: ASDF development FAQs266650
-Node: How do I run the tests interactively in a REPL?266889
-Node: Ongoing Work268458
-Node: Bibliography268741
-Node: Concept Index274773
-Node: Function and Macro Index282504
-Node: Variable Index291309
-Node: Class and Type Index293630
+Node: Introduction7909
+Node: Quick start summary10338
+Node: Loading ASDF12101
+Node: Loading a pre-installed ASDF12403
+Ref: Loading a pre-installed ASDF-Footnote-114238
+Node: Checking whether ASDF is loaded14438
+Node: Upgrading ASDF15352
+Node: Replacing your implementation's ASDF16350
+Node: Loading ASDF from source17802
+Node: Configuring ASDF18925
+Node: Configuring ASDF to find your systems19698
+Ref: Configuring ASDF to find your systems-Footnote-123099
+Ref: Configuring ASDF to find your systems-Footnote-223350
+Ref: Configuring ASDF to find your systems-Footnote-323652
+Node: Configuring ASDF to find your systems --- old style24125
+Ref: Configuring ASDF to find your systems --- old style-Footnote-127801
+Ref: Configuring ASDF to find your systems --- old style-Footnote-228039
+Ref: Configuring ASDF to find your systems --- old style-Footnote-328842
+Node: Configuring where ASDF stores object files28998
+Node: Resetting the ASDF configuration30407
+Node: Using ASDF31500
+Node: Loading a system31711
+Node: Convenience Functions32786
+Ref: Convenience Functions-Footnote-138263
+Node: Moving on38345
+Node: Defining systems with defsystem38718
+Node: The defsystem form39146
+Node: A more involved example42681
+Ref: A more involved example-Footnote-149934
+Node: The defsystem grammar50642
+Ref: rule-system-definition50847
+Ref: rule-system-designator51013
+Ref: rule-simple-component-name51334
+Ref: rule-complex-component-name51455
+Ref: rule-system-option51503
+Ref: rule-system-option/asdf352291
+Ref: rule-source-control52752
+Ref: rule-module-option52795
+Ref: rule-option52931
+Ref: rule-person-or-persons53919
+Ref: rule-system-list53967
+Ref: rule-component-list54073
+Ref: rule-component-def54158
+Ref: rule-component-type54360
+Ref: rule-other-component-type54494
+Ref: rule-dependency-def54666
+Ref: rule-dependency55275
+Ref: rule-requirement55402
+Ref: rule-dependent-op55496
+Ref: rule-required-op55576
+Ref: rule-pathname-specifier55769
+Ref: rule-version-specifier55824
+Ref: rule-line-specifier56211
+Ref: rule-form-specifier56258
+Ref: rule-method-form56313
+Ref: rule-qual56448
+Ref: rule-method-qualifier56527
+Ref: rule-feature-expression56580
+Ref: rule-operation-name56938
+Ref: Simple component names57233
+Ref: Complex component names58244
+Ref: Component types58960
+Ref: System class names59442
+Ref: Build-operation60651
+Ref: Pathname specifiers62237
+Ref: Version specifiers66273
+Ref: Feature dependencies68522
+Ref: Using logical pathnames69393
+Ref: if-feature option74034
+Ref: Entry point75171
+Ref: feature requirement75901
+Node: Other code in .asd files76319
+Node: The package-inferred-system extension77491
+Node: The object model of ASDF83256
+Ref: The object model of ASDF-Footnote-185674
+Ref: The object model of ASDF-Footnote-286038
+Node: Operations86373
+Ref: operate87500
+Ref: make-operation90280
+Node: Predefined operations of ASDF90725
+Ref: test-op92957
+Node: Creating new operations101198
+Node: Components106603
+Ref: System names110225
+Ref: Components-Footnote-1115043
+Ref: Components-Footnote-2115355
+Node: Common attributes of components115685
+Ref: required-features117207
+Node: Pre-defined subclasses of component123147
+Node: Creating new component types125647
+Node: Dependencies126955
+Node: Functions128884
+Node: Parsing system definitions130776
+Node: Controlling where ASDF searches for systems133024
+Node: Configurations133646
+Node: Truenames and other dangers137213
+Node: XDG base directory138521
+Node: Backward Compatibility139967
+Node: Configuration DSL140698
+Node: Configuration Directories146261
+Node: The here directive148128
+Node: Shell-friendly syntax for configuration150055
+Node: Search Algorithm151130
+Node: Caching Results153024
+Node: Configuration API156332
+Node: Introspection158415
+Node: *source-registry-parameter* variable158679
+Node: Information about system dependencies159258
+Node: Status160178
+Node: Rejected ideas160641
+Node: TODO163094
+Node: Credits for the source-registry163281
+Node: Controlling where ASDF saves compiled files163817
+Ref: Controlling where ASDF saves compiled files-Footnote-1165247
+Node: Output Configurations165299
+Ref: Output Configurations-Footnote-1168188
+Node: Output Backward Compatibility168258
+Node: Output Configuration DSL171066
+Node: Output Configuration Directories176637
+Node: Output Shell-friendly syntax for configuration178226
+Node: Semantics of Output Translations179789
+Node: Output Caching Results181358
+Node: Output location API181838
+Node: Credits for output translations184306
+Node: Error handling184835
+Node: Miscellaneous additional functionality185696
+Node: Controlling file compilation186168
+Node: Controlling source file character encoding189506
+Node: Miscellaneous Functions196557
+Ref: system-relative-pathname196854
+Ref: Miscellaneous Functions-Footnote-1203416
+Node: Some Utility Functions203531
+Node: Getting the latest version214699
+Node: FAQ215662
+Node: Where do I report a bug?216057
+Node: Mailing list216612
+Node: What has changed between ASDF 1 ASDF 2 and ASDF 3?216951
+Node: What are ASDF 1 2 3?219146
+Node: How do I detect the ASDF version?220191
+Node: ASDF can portably name files in subdirectories222550
+Node: Output translations224277
+Node: Source Registry Configuration225320
+Node: Usual operations are made easier to the user226957
+Node: Many bugs have been fixed227577
+Node: ASDF itself is versioned229677
+Node: ASDF can be upgraded230662
+Node: Decoupled release cycle231816
+Node: Pitfalls of the transition to ASDF 2232747
+Node: Pitfalls of the upgrade to ASDF 3237137
+Ref: reinitializeASDFAfterUpgrade240889
+Ref: Pitfalls of the upgrade to ASDF 3-Footnote-1241765
+Node: What happened to the bundle operations241939
+Node: Issues with installing the proper version of ASDF243188
+Node: My Common Lisp implementation comes with an outdated version of ASDF. What to do?243751
+Node: I'm a Common Lisp implementation vendor. When and how should I upgrade ASDF?244690
+Node: After upgrading ASDF248716
+Node: Issues with configuring ASDF250377
+Node: How can I customize where fasl files are stored?250802
+Node: How can I wholly disable the compiler output cache?251924
+Node: How can I debug problems finding ASDF systems253385
+Node: Issues with using and extending ASDF to define systems254814
+Node: How can I cater for unit-testing in my system?255611
+Node: How can I cater for documentation generation in my system?256515
+Node: How can I maintain non-Lisp (e.g. C) source files?257044
+Ref: report-bugs257490
+Node: I want to put my module's files at the top level. How do I do this?257490
+Node: How do I create a system definition where all the source files have a .cl extension?260696
+Node: How do I mark a source file to be loaded only and not compiled?262701
+Node: How do I work with readtables?263703
+Node: How can I capture ASDF's output?267528
+Node: LOAD-PATHNAME has a weird value268009
+Node: ASDF development FAQs269523
+Node: How do I run the tests interactively in a REPL?269762
+Node: Ongoing Work271331
+Node: Bibliography271614
+Node: Concept Index277646
+Node: Function and Macro Index285663
+Node: Variable Index294894
+Node: Class and Type Index297215
 
 End Tag Table
 
diff --git a/src/contrib/asdf/doc/asdf.pdf b/src/contrib/asdf/doc/asdf.pdf
index cf04b427212e0a227fcf3c0751b78bd46f907c95..608da1201ef3817bca6bb1e8a3d07539e9609834 100644
Binary files a/src/contrib/asdf/doc/asdf.pdf and b/src/contrib/asdf/doc/asdf.pdf differ
diff --git a/src/general-info/release-21e.md b/src/general-info/release-21e.md
index 2d45fe07dfe90f05f5d683261c5dc9bd5fb50b4b..8b46026d78189901dd5d2b38a4c41226e1473478 100644
--- a/src/general-info/release-21e.md
+++ b/src/general-info/release-21e.md
@@ -21,7 +21,7 @@ public domain.
   * Known issues:
   * Feature enhancements
   * Changes
-    * Update to ASDF 3.3.4
+    * Update to ASDF 3.3.5
   * ANSI compliance fixes:
   * Bug fixes:
     * ~~#97~~ Fixes stepping through the source forms in the debugger.  This has been broken for quite some time, but it works now.
@@ -44,6 +44,7 @@ public domain.
     * ~~#100~~ ldb prints out unicode base-chars correctly instead of just the low 8 bits.
     * ~~#103~~ RANDOM-MT19937-UPDATE assembly routine still exists
     * ~~#107~~ Replace u_int8_t with uint8_t
+    * ~~#108~~ Update ASDF
   * Other changes:
   * Improvements to the PCL implementation of CLOS:
   * Changes to building procedure: