Changeset 14636

Timestamp:

03/15/14 12:35:38 (9 years ago)

Author:

Mark Evenson

Message:

asdf 3.1.0.94

Location:

trunk/abcl

Files:

• doc/asdf/asdf.texinfo (modified) (67 diffs)
• src/org/armedbear/lisp/asdf.lisp (modified) (114 diffs)

trunk/abcl/doc/asdf/asdf.texinfo

@@ -82 +82 @@
 
 @node Top, Introduction, (dir), (dir)
-@top asdf: another system definition facility
+@top ASDF: Another System Definition Facility
 
 @insertcopying
@@ -88 +88 @@
 @menu
 * Introduction::
+* Quick start summary::
 * Loading ASDF::
 * Configuring ASDF::
@@ -99 +100 @@
 * Getting the latest version::
 * FAQ::
-* TODO list::
-* Inspiration::
+* Ongoing Work::
+* Bibliography::
 * Concept Index::
 * Function and Class Index::
-* Variable Index::
-
-@c @detailmenu
-@c  --- The Detailed Node Listing ---
-
-@c Defining systems with defsystem
-
-@c * The defsystem form::
-@c * A more involved example::
-@c * The defsystem grammar::
-@c * Other code in .asd files::
-
-@c The object model of ASDF
-
-@c * Operations::
-@c * Components::
-@c * Functions::
-
-@c Operations
-
-@c * Predefined operations of ASDF::
-@c * Creating new operations::
-
-@c Components
-
-@c * Common attributes of components::
-@c * Pre-defined subclasses of component::
-@c * Creating new component types::
-
-@c properties
-
-@c * Pre-defined subclasses of component::
-@c * Creating new component types::
-
-@c @end detailmenu
+* Variable Index::              @c @detailmenu
+@c 
+
+@detailmenu
+ --- The Detailed Node Listing ---
+
+Loading ASDF
+
+* Loading a pre-installed ASDF::
+* Checking whether ASDF is loaded::
+* Upgrading ASDF::
+* Loading an otherwise installed ASDF::
+
+Configuring ASDF
+
+* Configuring ASDF to find your systems::
+* Configuring where ASDF stores object files::
+
+Defining systems with defsystem
+
+* The defsystem form::
+* A more involved example::
+* The defsystem grammar::
+* Other code in .asd files::
+* The package-system extension::
+
+The object model of ASDF
+
+* Operations::
+* Components::
+* Functions::
+
+Operations
+
+* Predefined operations of ASDF::
+* Creating new operations::
+
+Components
+
+* Common attributes of components::
+* Pre-defined subclasses of component::
+* Creating new component types::
+
+properties
+
+* Pre-defined subclasses of component::
+* Creating new component types::
+
+FAQ
+
+* Where do I report a bug?::
+* What has changed between ASDF 1 and ASDF 2?::
+* Issues with installing the proper version of ASDF::
+* Issues with configuring ASDF::
+* Issues with using and extending ASDF to define systems::
+* ASDF development FAQs::
+
+``What has changed between ASDF 1 and ASDF 2?''
+
+* What are ASDF 1 2 3?::
+* ASDF can portably name files in subdirectories::
+* Output translations::
+* Source Registry Configuration::
+* Usual operations are made easier to the user::
+* Many bugs have been fixed::
+* ASDF itself is versioned::
+* ASDF can be upgraded::
+* Decoupled release cycle::
+* Pitfalls of the transition to ASDF 2::
+
+Issues with installing the proper version of ASDF
+
+* My Common Lisp implementation comes with an outdated version of ASDF. What to do?::
+* I'm a Common Lisp implementation vendor. When and how should I upgrade ASDF?::
+
+Issues with configuring ASDF
+
+* How can I customize where fasl files are stored?::
+* How can I wholly disable the compiler output cache?::
+
+Issues with using and extending ASDF to define systems
+
+* How can I cater for unit-testing in my system?::
+* How can I cater for documentation generation in my system?::
+* How can I maintain non-Lisp (e.g. C) source files?::
+* I want to put my module's files at the top level.  How do I do this?::
+* How do I create a system definition where all the source files have a .cl extension?::
+
+ASDF development FAQs
+
+* How do run the tests interactively in a REPL?::
+
+@end detailmenu
 @end menu
 
@@ -144 +203 @@
 @c -------------------
 
-@node Introduction, Loading ASDF, Top, Top
+@node Introduction, Quick start summary, Top, Top
 @comment  node-name,  next,  previous,  up
 @chapter Introduction
@@ -180 +239 @@
 and has been made to work with all actively used CL implementations and a few more.
 @xref{FAQ,,``What has changed between ASDF 1 and ASDF 2?''}.
-Furthermore, it is possible to upgrade from ASDF 1 to ASDF 2 or ASDF 3 on the fly.
+Furthermore, it is possible to upgrade from ASDF 1 to ASDF 2 or ASDF 3 on the fly
+(though we recommend instead upgrading your implementation or its ASDF module).
 For this reason, we have stopped supporting ASDF 1 and ASDF 2.
 If you are using ASDF 1 or ASDF 2 and are experiencing any kind of issues or limitations,
 we recommend you upgrade to ASDF 3
 --- and we explain how to do that. @xref{Loading ASDF}.
+(In the context of compatibility requirements,
+ASDF 2.27, released on Feb 1st 2013, and further 2.x releases up to 2.33,
+count as pre-releases of ASDF 3, and define the :asdf3 feature;
+still, please use the latest release).
 
 Also note that ASDF is not to be confused with ASDF-Install.
@@ -194 +258 @@
 so you may more easily modify it, we recommend clbuild.
 
-
-@node Loading ASDF, Configuring ASDF, Introduction, Top
+@node  Quick start summary, Loading ASDF, Introduction, Top
+@chapter Quick start summary
+
+@itemize
+
+@item To load an ASDF system:
+
+@itemize
+@item
+Load ASDF itself into your Lisp image, either through
+@code{(require "asdf")} (if it's supplied by your lisp implementation)
+or else through
+@code{(load "/path/to/asdf.lisp")}.  For more details, @ref{Loading ASDF}.
+
+@item
+Make sure ASDF can find system definitions
+through proper source-registry configuration.
+For more details, @xref{Configuring ASDF to find your systems}.
+The simplest way is simply to put all your lisp code in subdirectories of
+@file{~/.local/share/common-lisp/source/}.
+Such code will automatically be found.
+
+@item
+Load a system with @code{(asdf:load-system :system)}. @xref{Using ASDF}.
+
+@end itemize
+
+@item To make your own ASDF system:
+
+@itemize
+@item
+As above, load and configure ASDF.
+
+@item
+Make a new directory for your system, @code{my-system/} in a location
+where ASDF can find it (@pxref{Configuring ASDF to find your systems}).
+
+@item
+Create an ASDF system definition listing the dependencies of
+your system, its components, and their interdependencies,
+and put it in @file{my-system.asd}.
+This file must have the same name as your system.
+@xref{Defining systems with defsystem}.
+
+@item
+Use @code{(asdf:load-system :my-system)}
+to make sure it's all working properly. @xref{Using ASDF}.
+
+@end itemize
+@end itemize
+
+@c FIXME: (1) add a sample project that the user can cut and paste to
+@c get started.  (2) discuss the option of starting with Quicklisp.
+
+
+
+
+
+@node Loading ASDF, Configuring ASDF, Quick start summary, Top
 @comment  node-name,  next,  previous,  up
 @chapter Loading ASDF
-@vindex *central-registry*
-@cindex link farm
-@findex load-system
-@findex require-system
-@findex compile-system
-@findex test-system
-@cindex system directory designator
-@findex operate
-@findex oos
-
-@c @menu
-@c * Installing ASDF::
-@c @end menu
-
-
+
+@menu
+* Loading a pre-installed ASDF::
+* Checking whether ASDF is loaded::
+* Upgrading ASDF::
+* Loading an otherwise installed ASDF::
+@end menu
+
+@node  Loading a pre-installed ASDF, Checking whether ASDF is loaded, Loading ASDF, Loading ASDF
 @section Loading a pre-installed ASDF
 
-Most recent Lisp implementations include a copy of ASDF 2, and soon ASDF 3.
-You can usually load this copy using Common Lisp's @code{require} function:
+Most recent Lisp implementations include a copy of ASDF 3,
+or at least ASDF 2.
+You can usually load this copy using Common Lisp's @code{require} function.@footnote{
+NB: all implementations except GNU CLISP also accept
+@code{(require "ASDF")}, @code{(require 'asdf)} and @code{(require :asdf)}.
+For portability's sake, you should use @code{(require "asdf")}.
+}
 
 @lisp
@@ -223 +343 @@
 
 As of the writing of this manual,
-the following implementations provide ASDF 2 this way:
-abcl allegro ccl clisp cmucl ecl lispworks mkcl sbcl xcl.
-The following implementation doesn't provide it yet but will in an upcoming release:
-scl.
+the following implementations provide ASDF 3 this way:
+ABCL, Allegro CL, Clozure CL, CMUCL, ECL, GNU CLISP, mkcl, SBCL.
+The following implementations only provide ASDF 2:
+LispWorks, mocl, XCL.
+The following implementation doesn't provide ASDF yet but will in an upcoming release:
+SCL.
 The following implementations are obsolete, not actively maintained,
-and most probably will never bundle it:
-cormanlisp gcl genera mcl.
+and most probably will never bundle ASDF:
+Corman CL, GCL, Genera, MCL.
 
 If the implementation you are using doesn't provide ASDF 2 or ASDF 3,
@@ -237 +359 @@
 about their failing to provide ASDF.
 
-NB: all implementations except clisp also accept
-@code{(require "ASDF")}, @code{(require 'asdf)} and @code{(require :asdf)}.
-For portability's sake, you probably want to use @code{(require "asdf")}.
-
-
+@node Checking whether ASDF is loaded, Upgrading ASDF, Loading a pre-installed ASDF, Loading ASDF
 @section Checking whether ASDF is loaded
 
@@ -285 +403 @@
 before you contact us and raise an issue.
 
-
+@node  Upgrading ASDF, Loading an otherwise installed ASDF, Checking whether ASDF is loaded, Loading ASDF
 @section Upgrading ASDF
+@c FIXME: tighten this up a bit -- there's a lot of stuff here that
+@c doesn't matter to almost anyone.  Move discussion of updating antique
+@c versions of ASDF down, or encapsulate it.
+
+If you want to upgrade to a more recent ASDF version,
+you need to install and configure your ASDF just like any other system
+(@pxref{Configuring ASDF to find your systems}).
 
 If your implementation provides ASDF 3 or later,
@@ -292 +417 @@
 ASDF will automatically look whether an updated version of itself is available
 amongst the regularly configured systems, before it compiles anything else.
-See @pxref{Configuring ASDF} below.
-
-If your implementation does provide ASDF 2 or later,
-but not ASDF 3 or later,
-and you want to upgrade to a more recent version,
-you need to install and configure your ASDF as above,
-and additionally, you need to explicitly tell ASDF to load itself,
-right after you require your implementation's old ASDF 2:
+
+@subsection Notes about ASDF 1 and ASDF 2
+
+Most implementations provide ASDF 3 in their latest release,
+and we recommend upgrading your implementation rather than using ASDF 1 or 2.
+A few implementations only provide ASDF 2,
+that can be overridden by installing a fasl (see below).
+A few implementations don't provide ASDF,
+but a fasl can be installed to provide it.
+GCL so far is still lacking a usable @code{require} interface.
+
+If your implementation has no suitable upgrade available (yet),
+or somehow upgrading is not an option,
+we assume you're an expert deliberately using a legacy implementation,
+and are proficient enough to install this fasl.
+Still, the ASDF source repository contains a script
+@file{bin/install-asdf-as-module} that can help you do that.
+It relies on cl-launch 4 for command-line invocation,
+which may depend on ASDF being checked out in @file{~/cl/asdf/}
+if your implementation doesn't even have an ASDF 2;
+but you can run the code it manually if needs be.
+
+Finally, if your implementation only provides ASDF 2,
+and you can't or won't upgrade it or override its ASDF module,
+you may simply configure ASDF to find a proper upgrade;
+however, to avoid issues with a self-upgrade in mid-build,
+you @emph{must} make sure to upgrade ASDF immediately
+after requiring the builtin ASDF 2:
 
 @lisp
 (require "asdf")
+;; <--- insert programmatic configuration here if needed
 (asdf:load-system :asdf)
 @end lisp
 
-If on the other hand, your implementation only provides an old ASDF,
-you will require a special configuration step and an old-style loading.
-Take special attention to not omit the trailing directory separator
-@code{/} at the end of your pathname:
-
-@lisp
-(require "asdf")
-(push #p"@var{/path/to/new/asdf/}" asdf:*central-registry*)
-(asdf:oos 'asdf:load-op :asdf)
-@end lisp
-
-Note that ASDF 1 won't redirect its output files,
-or at least won't do it according to your usual ASDF 2 configuration.
-You therefore need write access on the directory
-where you install the new ASDF,
-and make sure you're not using it
-for multiple mutually incompatible implementations.
-At worst, you may have to have multiple copies of the new ASDF,
-e.g. one per implementation installation, to avoid clashes.
-Note that to our knowledge all implementations that provide ASDF
-provide ASDF 2 in their latest release, so
-you may want to upgrade your implementation rather than go through that hoop.
-
-Finally, if you are using an unmaintained implementation
-that does not provide ASDF at all,
-see @pxref{Loading ASDF,,Loading an otherwise installed ASDF} below.
+@subsection Issues with upgrading ASDF
 
 Note that there are some limitations to upgrading ASDF:
 @itemize
 @item
-Previously loaded ASDF extension becomes invalid, and will need to be reloaded.
-This applies to e.g. CFFI-Grovel, or to hacks used by ironclad, etc.
-Since it isn't possible to automatically detect what extensions are present
-that need to be invalidated,
-ASDF will actually invalidate all previously loaded systems
-when it is loaded on top of a different ASDF version,
-starting with ASDF 2.014.8 (as far as releases go, 2.015);
-and it will automatically attempt this self-upgrade as its very first step
-starting with ASDF 3.
-
-@item
-For this an many other reasons,
-it important reason to load, configure and upgrade ASDF (if needed)
+Previously loaded ASDF extensions become invalid, and will need to be reloaded.
+Examples include CFFI-Grovel, hacks used by ironclad, etc.
+Since it isn't possible to automatically detect what extensions
+need to be invalidated,
+ASDF will invalidate @emph{all} previously loaded systems
+when it is loaded on top of a forward-incompatible ASDF version.
+@footnote{
+@vindex *oldest-forward-compatible-asdf-version*
+Forward incompatibility can be determined using the variable
+@code{asdf/upgrade::*oldest-forward-compatible-asdf-version*},
+which is 2.33 at the time of this writing.}
+
+Starting with ASDF 3 (2.27 or later),
+this self-upgrade will be automatically attempted as the first step
+to any system operation, to avoid any possibility of
+a catastrophic attempt to self-upgrade in mid-build.
+
+@c FIXME: Fix grammar below.
+@item
+For this and many other reasons,
+you should load, configure and upgrade ASDF
 as one of the very first things done by your build and startup scripts.
-Until all implementations provide ASDF 3 or later,
-it is safer if you upgrade ASDF and its extensions as a special step
+It is safer if you upgrade ASDF and its extensions as a special step
 at the very beginning of whatever script you are running,
-before you start using ASDF to load anything else;
-even afterwards, it is still a good idea, to avoid having to
-load and reload code twice as it gets invalidated.
+before you start using ASDF to load anything else.
 
 @item
@@ -365 +491 @@
 when extensions are loaded into the new one.
 In the meantime, we recommend that your systems should @emph{not} specify
-@code{:depends-on (:asdf)}, or @code{:depends-on ((:version :asdf "2.010"))},
+@code{:depends-on (:asdf)}, or @code{:depends-on ((:version :asdf "3.0.1"))},
 but instead that they check that a recent enough ASDF is installed,
 with such code as:
@@ -382 +508 @@
 @end itemize
 
-
+@node Loading an otherwise installed ASDF,  , Upgrading ASDF, Loading ASDF
 @section Loading an otherwise installed ASDF
 
@@ -411 +537 @@
 @node Configuring ASDF, Using ASDF, Loading ASDF, Top
 @comment  node-name,  next,  previous,  up
-
 @chapter Configuring ASDF
 
+For standard use cases, ASDF should work pretty much out of the box.
+We recommend you skim the sections on configuring ASDF to find your systems
+and choose the method of installing Lisp software that works best for you.
+Then skip directly to @xref{Using ASDF}. That will probably be enough.
+You are unlikely to have to worry about the way ASDF stores object files,
+and resetting the ASDF configuration is usually only needed in corner cases.
+
+
+@menu
+* Configuring ASDF to find your systems::
+* Configuring ASDF to find your systems --- old style::
+* Configuring where ASDF stores object files::
+* Resetting the ASDF configuration::
+@end menu
+
+@node Configuring ASDF to find your systems, Configuring where ASDF stores object files, Configuring ASDF, Configuring ASDF
 @section Configuring ASDF to find your systems
 
-So it may compile and load your systems, ASDF must be configured to find
+In order to compile and load your systems, ASDF must be configured to find
 the @file{.asd} files that contain system definitions.
 
-Since ASDF 2, the preferred way to configure where ASDF finds your systems is
-the @code{source-registry} facility,
-fully described in its own chapter of this manual.
-@xref{Controlling where ASDF searches for systems}.
-
-The default location for a user to install Common Lisp software is under
+There are a number of different techniques for setting yourself up with
+ASDF, starting from easiest to the most complex:
+
+@itemize @bullet
+
+@item
+Put all of your systems in subdirectories of
 @file{~/.local/share/common-lisp/source/}.
 If you install software there (it can be a symlink),
 you don't need further configuration.
-If you're installing software yourself at a location that isn't standard,
-you have to tell ASDF where you installed it. See below.
+
+@item
 If you're using some tool to install software (e.g. Quicklisp),
 the authors of that tool should already have configured ASDF.
+
+@item
+If you have more specific desires about how to lay out your software on
+disk, the preferred way to configure where ASDF finds your systems is
+the @code{source-registry} facility,
+fully described in its own chapter of this manual.
+@xref{Controlling where ASDF searches for systems}.  Here is a quick
+recipe for getting started:
 
 The simplest way to add a path to your search path,
@@ -438 +588 @@
 @file{~/.config/common-lisp/source-registry.conf.d/}
 and there create a file with any name of your choice,
-and with the type @file{conf},
-for instance @file{42-asd-link-farm.conf}
+and with the type @file{conf}@footnote{By requiring the @file{.conf}
+extension, and ignoring other files, ASDF allows you to have disabled files,
+editor backups, etc. in the same directory with your active
+configuration files.
+
+ASDF will also ignore files whose names start with a @file{.} character.
+
+It is customary to start the filename with two digits, to control the
+sorting of the @code{conf} files in the source registry directory, and
+thus the order in which the directories will be scanned.},
+for instance @file{42-asd-link-farm.conf},
 containing the line:
 
@@ -449 +608 @@
 @kbd{(:tree "/home/luser/lisp/")}
 
-Note that your Operating System distribution or your system administrator
-may already have configured system-managed libraries for you.
-
-The required @file{.conf} extension allows you to have disabled files
-or editor backups (ending in @file{~}), and works portably
-(for instance, it is a pain to allow both empty and non-empty extension on CLISP).
-Excluded are files the name of which start with a @file{.} character.
-It is customary to start the filename with two digits
-that specify the order in which the directories will be scanned.
-
 ASDF will automatically read your configuration
 the first time you try to find a system.
-You can reset the source-registry configuration with:
+If necessary, you can reset the source-registry configuration with:
 
 @lisp
@@ -467 +616 @@
 @end lisp
 
-And you probably should do so before you dump your Lisp image,
-if the configuration may change
-between the machine where you save it at the time you save it
-and the machine you resume it at the time you resume it.
-Actually, you should use @code{(asdf:clear-configuration)}
-before you dump your Lisp image, which includes the above.
-
-
+@c FIXME: too specific.  Push this down to discussion of dumping an
+@c image?
+
+@c And you probably should do so before you dump your Lisp image,
+@c if the configuration may change
+@c between the machine where you save it at the time you save it
+@c and the machine you resume it at the time you resume it.
+@c Actually, you should use @code{(asdf:clear-configuration)}
+@c before you dump your Lisp image, which includes the above.
+
+@item
+In earlier versions of ASDF, the system source registry was configured
+using a global variable, @code{asdf:*central-registry*}.
+For more details about this, see the following section,
+@ref{Configuring ASDF to find your systems --- old style}.
+Unless you need to understand this,
+skip directly to @ref{Configuring where ASDF stores object files}.
+
+@end itemize
+
+Note that your Operating System distribution or your system administrator
+may already have configured system-managed libraries for you.
+
+
+
+@node Configuring ASDF to find your systems --- old style, Configuring where ASDF stores object files, Configuring ASDF to find your systems, Configuring ASDF
+
+@c FIXME: this section should be moved elsewhere.  The novice user
+@c should not be burdened with it. [2014/02/27:rpg]
 @section Configuring ASDF to find your systems --- old style
 
@@ -490 +660 @@
 The @code{asdf:*central-registry*} is empty by default in ASDF 2 or ASDF 3,
 but is still supported for compatibility with ASDF 1.
-When used, it takes precedence over the above source-registry@footnote{
+When used, it takes precedence over the above source-registry.@footnote{
 It is possible to further customize
 the system definition file search.
@@ -496 +666 @@
 search forward for
 @code{*system-definition-search-functions*}.
-@xref{Defining systems with defsystem}.}.
-
-For instance, if you wanted ASDF to find the @file{.asd} file
-@file{/home/me/src/foo/foo.asd} your initialization script
-could after it loads ASDF with @code{(require "asdf")}
-configure it with:
+@xref{Defining systems with defsystem}.}
+
+For example, let's say you want ASDF to find the @file{.asd} file
+@file{/home/me/src/foo/foo.asd}.
+In your lisp initialization file, you could have the following:
 
 @lisp
+(require "asdf")
 (push "/home/me/src/foo/" asdf:*central-registry*)
 @end lisp
@@ -509 +679 @@
 Note the trailing slash: when searching for a system,
 ASDF will evaluate each entry of the central registry
-and coerce the result to a pathname@footnote{
+and coerce the result to a pathname.@footnote{
 ASDF will indeed call @code{eval} on each entry.
-It will also skip entries that evaluate to @code{nil}.
+It will skip entries that evaluate to @code{nil}.
 
 Strings and pathname objects are self-evaluating,
 in which case the @code{eval} step does nothing;
-but you may push arbitrary SEXP onto the central registry,
-that will be evaluated to compute e.g. things that depend
+but you may push arbitrary s-expressions onto the central registry.
+These s-expressions may be evaluated to compute context-dependent
+entries, e.g. things that depend
 on the value of shell variables or the identity of the user.
 
@@ -523 +694 @@
 A @dfn{system directory designator} is a form
 which will be evaluated whenever a system is to be found,
-and must evaluate to a directory to look in.
-By ``directory'' here, we mean
-``designator for a pathname with a supplied DIRECTORY component''.
+and must evaluate to a directory to look in (or @code{NIL}).
+By ``directory'', we mean
+``designator for a pathname with a non-empty DIRECTORY component''.
 }
-at which point the presence of the trailing directory name separator
+The trailing directory name separator
 is necessary to tell Lisp that you're discussing a directory
-rather than a file.
-
-Typically, however, there are a lot of @file{.asd} files, and
-a common idiom was to have to put
-a bunch of @emph{symbolic links} to @file{.asd} files
+rather than a file.  If you leave it out, ASDF is likely to look in
+@code{/home/me/src/} instead of @code{/home/me/src/foo/} as you
+intended, and fail to find your system definition.
+
+Typically there are a lot of @file{.asd} files, and
+a common idiom was to put
+@emph{symbolic links} to all of one's @file{.asd} files
 in a common directory
 and push @emph{that} directory (the ``link farm'')
-to the
-@code{asdf:*central-registry*}
-instead of pushing each of the many involved directories
-to the @code{asdf:*central-registry*}.
-ASDF knows how to follow such @emph{symlinks}
-to the actual file location when resolving the paths of system components
-(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).
-
-For example, if @code{#p"/home/me/cl/systems/"} (note the trailing slash)
-is a member of @code{*central-registry*}, you could set up the
-system @var{foo} for loading with asdf with the following
-commands at the shell:
+onto
+@code{asdf:*central-registry*},
+instead of pushing each individual system directory.
+
+ASDF knows to follow @emph{symlinks}
+to the actual location of the systems.@footnote{
+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.}
+
+For example, if @code{#p"/home/me/cl/systems/"}
+is an element of @code{*central-registry*}, you could set up the
+system @var{foo} as follows:
 
 @example
@@ -560 +732 @@
 
 
+@node Configuring where ASDF stores object files,  , Configuring ASDF to find your systems, Configuring ASDF
 @section Configuring where ASDF stores object files
 @findex clear-output-translations
@@ -567 +740 @@
 you shouldn't normally have to worry about it.
 
-This allows the same source code repository may be shared
+This allows the same source code repository to be shared
 between several versions of several Common Lisp implementations,
-between several users using different compilation options
-and without write privileges on shared source directories, etc.
-This also allows to keep source directories uncluttered
-by plenty of object files.
+between several users using different compilation options,
+with users who lack write privileges on shared source directories, etc.
+This also keeps source directories from being cluttered
+with object/fasl files.
 
 Starting with ASDF 2, the @code{asdf-output-translations} facility
-was added to ASDF itself, that controls where object files will be stored.
+was added to ASDF itself.  This facility controls where object files will be stored.
 This facility is fully described in a chapter of this manual,
 @ref{Controlling where ASDF saves compiled files}.
 
-The simplest way to add a translation to your search path,
-say from @file{/foo/bar/baz/quux/}
-to @file{/where/i/want/my/fasls/}
-is to create the directory
-@file{~/.config/common-lisp/asdf-output-translations.conf.d/}
-and there create a file with any name of your choice and the type @file{conf},
-for instance @file{42-bazquux.conf}
-containing the line:
-
-@kbd{("/foo/bar/baz/quux/" "/where/i/want/my/fasls/")}
-
-To disable output translations for source under a given directory,
-say @file{/toto/tata/}
-you can create a file @file{40-disable-toto.conf}
-with the line:
-
-@kbd{("/toto/tata/")}
-
-To wholly disable output translations for all directories,
-you can create a file @file{00-disable.conf}
-with the line:
-
-@kbd{(t t)}
-
-Note that your Operating System distribution or your system administrator
-may already have configured translations for you.
-In absence of any configuration, the default is to redirect everything
-under an implementation-dependent subdirectory of @file{~/.cache/common-lisp/}.
-@xref{Controlling where ASDF searches for systems}, for full details.
-
-The required @file{.conf} extension allows you to have disabled files
-or editor backups (ending in @file{~}), and works portably
-(for instance, it is a pain to allow both empty and non-empty extension on CLISP).
-Excluded are files the name of which start with a @file{.} character.
-It is customary to start the filename with two digits
-that specify the order in which the directories will be scanned.
-
-ASDF will automatically read your configuration
-the first time you try to find a system.
-You can reset the source-registry configuration with:
-
-@lisp
-(asdf:clear-output-translations)
-@end lisp
-
-And you probably should do so before you dump your Lisp image,
-if the configuration may change
-between the machine where you save it at the time you save it
-and the machine you resume it at the time you resume it.
-(Once again, you should use @code{(asdf:clear-configuration)}
-before you dump your Lisp image, which includes the above.)
-
-Finally note that before ASDF 2,
+@c FIXME: possibly this should be moved elsewhere.  It's redundant here,
+@c and makes this section of the manual too long and daunting for the
+@c new user. [2014/02/27:rpg]
+@c The simplest way to add a translation to your search path,
+@c say from @file{/foo/bar/baz/quux/}
+@c to @file{/where/i/want/my/fasls/}
+@c is to create the directory
+@c @file{~/.config/common-lisp/asdf-output-translations.conf.d/}
+@c and there create a file with any name of your choice and the type @file{conf},
+@c for instance @file{42-bazquux.conf}
+@c containing the line:
+
+@c @kbd{("/foo/bar/baz/quux/" "/where/i/want/my/fasls/")}
+
+@c To disable output translations for source under a given directory,
+@c say @file{/toto/tata/}
+@c you can create a file @file{40-disable-toto.conf}
+@c with the line:
+
+@c @kbd{("/toto/tata/")}
+
+@c To wholly disable output translations for all directories,
+@c you can create a file @file{00-disable.conf}
+@c with the line:
+
+@c @kbd{(t t)}
+
+@c Note that your Operating System distribution or your system administrator
+@c may already have configured translations for you.
+@c In absence of any configuration, the default is to redirect everything
+@c under an implementation-dependent subdirectory of @file{~/.cache/common-lisp/}.
+@c @xref{Controlling where ASDF searches for systems}, for full details.
+
+@c The required @file{.conf} extension allows you to have disabled files
+@c or editor backups (ending in @file{~}), and works portably
+@c (for instance, it is a pain to allow both empty and non-empty extension on CLISP).
+@c Excluded are files the name of which start with a @file{.} character.
+@c It is customary to start the filename with two digits
+@c that specify the order in which the directories will be scanned.
+
+@c ASDF will automatically read your configuration
+@c the first time you try to find a system.
+@c You can reset the source-registry configuration with:
+
+@c @lisp
+@c (asdf:clear-output-translations)
+@c @end lisp
+
+@c And you probably should do so before you dump your Lisp image,
+@c if the configuration may change
+@c between the machine where you save it at the time you save it
+@c and the machine you resume it at the time you resume it.
+@c (Once again, you should use @code{(asdf:clear-configuration)}
+@c before you dump your Lisp image, which includes the above.)
+
+Note that before ASDF 2,
 other ASDF add-ons offered the same functionality,
 each in subtly different and incompatible ways:
@@ -637 +813 @@
 ASDF-Binary-Locations is now not needed anymore and should not be used.
 cl-launch 3.000 and common-lisp-controller 7.2 have been updated
-to just delegate this functionality to ASDF.
-
-@node Using ASDF, Defining systems with defsystem, Configuring ASDF, Top
-@comment  node-name,  next,  previous,  up
-
-
-@section Resetting Configuration
+to delegate object file placement to ASDF.
+
+@node Resetting the ASDF configuration,  , Configuring where ASDF stores object files, Configuring ASDF
+@c FIXME: this should probably be moved out of the "quickstart" part of
+@c the manual. [2014/02/27:rpg]
+@section Resetting the ASDF configuration
 
 When you dump and restore an image, or when you tweak your configuration,
@@ -668 +843 @@
 @code{(asdf:clear-configuration)} at an appropriate moment before dumping.
 
-
+@node  Using ASDF, Defining systems with defsystem, Configuring ASDF, Top
 @chapter Using ASDF
 
@@ -696 +871 @@
 @xref{Loading ASDF,,Loading an otherwise installed ASDF}.
 
-Note the name of a system is specified as a string or a symbol,
-typically a keyword.
+Note the name of a system is specified as a string or a symbol.
 If a symbol (including a keyword), its name is taken and lowercased.
 The name must be a suitable value for the @code{:name} initarg
-to @code{make-pathname} in whatever filesystem the system is to be found.
+to @code{make-pathname} in whatever filesystem the system is to be
+found.
+
 The lower-casing-symbols behaviour is unconventional,
 but was selected after some consideration.
-Observations suggest that the type of systems we want to support
-either have lowercase as customary case (unix, mac, windows)
-or silently convert lowercase to uppercase (lpns),
-so this makes more sense than attempting to use @code{:case :common},
-which is reported not to work on some implementations
+The type of systems we want to support
+either have lowercase as customary case (Unix, Mac, Windows)
+or silently convert lowercase to uppercase (lpns).
+@c so this makes more sense than attempting to use @code{:case :common},
+@c which is reported not to work on some implementations
 
 
@@ -724 +900 @@
 compiling, loading and testing.
 
-Output from ASDF and ASDF extensions are supposed to be sent
+Output from ASDF and ASDF extensions are sent
 to the CL stream @code{*standard-output*},
-and so rebinding that stream around calls to @code{asdf:operate}
+so rebinding that stream around calls to @code{asdf:operate}
 should redirect all output from ASDF operations.
 
-Reminder: before ASDF can operate on a system, however,
-it must be able to find and load that system's definition.
-@xref{Configuring ASDF,,Configuring ASDF to find your systems}.
-
+@c Reminder: before ASDF can operate on a system, however,
+@c it must be able to find and load that system's definition.
+@c @xref{Configuring ASDF,,Configuring ASDF to find your systems}.
+
+@c FIXME: the following is too complicated for here, especially since
+@c :force hasn't been defined yet.  Move it. [2014/02/27:rpg]
 @findex already-loaded-systems
 
-For the advanced users, note that
+For advanced users, note that
 @code{require-system} calls @code{load-system}
 with keyword arguments @code{:force-not (already-loaded-systems)}.
@@ -743 +921 @@
 the system, and any provided keyword arguments.
 
-@section Summary
-
-To use ASDF:
-
-@itemize
-@item
-Load ASDF itself into your Lisp image, either through
-@code{(require "asdf")} or else through
-@code{(load "/path/to/asdf.lisp")}.
-
-@item
-Make sure ASDF can find system definitions
-thanks to proper source-registry configuration.
-
-@item
-Load a system with @code{(asdf:load-system :my-system)}
-or use some other operation on some system of your choice.
-
-@end itemize
 
 @section Moving on
@@ -1000 +1159 @@
 # which is used in :in-order-to
 dependency-def := simple-component-name
-               | (feature @var{feature-name})
-               | ( :version simple-component-name version-specifier)
+               | ( :feature @var{feature-expression} dependency-def )
+               | ( :version simple-component-name version-specifier )
+               | ( :require module-name )
 
 # ``dependency'' is used in :in-order-to, as opposed to
@@ -1007 +1167 @@
 dependency := (dependent-op @var{requirement}+)
 requirement := (required-op @var{required-component}+)
-             | (:feature @var{feature-name})
 dependent-op := operation-name
 required-op := operation-name
@@ -1099 +1258 @@
 this anomalous behavior may be removed without warning.
 
-Finally, you might look into the @code{asdf-system-connections} extension,
-that will let you define additional code to be loaded
-when two systems are simultaneously loaded.
-It may or may not be considered good style, but at least it can be used
-in a way that has deterministic behavior independent of load order,
-unlike @code{weakly-depends-on}.
+@c Finally, you might look into the @code{asdf-system-connections} extension,
+@c that will let you define additional code to be loaded
+@c when two systems are simultaneously loaded.
+@c It may or may not be considered good style, but at least it can be used
+@c in a way that has deterministic behavior independent of load order,
+@c unlike @code{weakly-depends-on}.
 
 
@@ -1210 +1369 @@
 @xref{Common attributes of components}.
 
+@subsection Require
+@cindex :require dependencies
+
+Use the implementation's own @code{require} to load the @var{module-name}.
+
 
 @subsection Using logical pathnames
@@ -1338 +1502 @@
 
 @subsection if-feature option
+@cindex :if-feature component option
+@anchor{if-feature-option}      @c redo if this ever becomes a node in
+@c its own right...
+
 This option allows you to specify a feature expression to be evaluated
 as if by @code{#+} to conditionally include a component in your build.
@@ -1344 +1512 @@
 As compared to using @code{#+} which is expanded at read-time,
 this allows you to have an object in your component hierarchy
-that can be used for manipulations beside building your project.
-This option was added in ASDF 3.
+that can be used for manipulations beside building your project, and
+that is accessible to outside code that wishes to reason about system
+structure.
+
+Programmers should be careful to consider @strong{when} the
+@code{:if-feature} is evaluated.  Recall that ASDF first computes a
+build plan, and then executes that plan.  ASDF will check to see whether
+or not a feature is present @strong{at planning time}, not during the
+build.  It follows that one cannot use @code{:if-feature} to check
+features that are set during the course of the build.  It can only be
+used to check the state of features before any build operations have
+been performed.
+
+This option was added in ASDF 3.  For more information,
+@xref{required-features, Required features}.
 
 @subsection if-component-dep-fails option
+@cindex :if-component-dep-fails component option
 This option was removed in ASDF 3.
 Its semantics was limited in purpose and dubious to explain,
 and its implementation was breaking a hole into the ASDF object model.
 Please use the @code{if-feature} option instead.
+
+@subsection feature requirement
+This requirement was removed in ASDF 3.1.
+It used to ensure that a chain of component dependencies will raise an error,
+which in conjunction with if-component-dep-fails would offer
+a roundabout way to express conditional compilation.
+
 
 @node Other code in .asd files, The package-system extension, The defsystem grammar, Defining systems with defsystem
@@ -1560 +1749 @@
 There are a bunch of methods specialised on operation and component type
 that actually do the grunt work.
-
-The operation object contains whatever state is relevant for this purpose
-(perhaps a list of visited nodes, for example)
-but primarily is a nice thing to specialise operation methods on
-and easier than having them all be @code{EQL} methods.
+Operations are invoked on systems via @code{operate} (@pxref{operate}).
+
+ASDF contains a number of pre-defined @t{operation} classes for common,
+and even fairly uncommon tasks that you might want to do with it.
+In addition, ASDF contains ``abstract'' @t{operation} classes that
+programmers can use as building blocks to define ASDF extensions.  We
+discuss these in turn below.
+
+@c The operation object contains whatever state is relevant for this purpose
+@c (perhaps a list of visited nodes, for example)
+@c but primarily is a nice thing to specialise operation methods on
+@c and easier than having them all be @code{EQL} methods.
+
+@menu
+* Predefined operations of ASDF::
+* Creating new operations::
+@end menu
 
 Operations are invoked on systems via @code{operate}.
@@ -1593 +1794 @@
 If @var{force-not} is @code{:all}, then all systems
 are forced not to be recompiled even if modified since last compilation.
-If @var{force-not} is @code{t}, then only the system being loaded
-is forced not to be recompiled even if modified since last compilation,
-but other systems are not affected.
+If @var{force-not} is @code{t}, then all systems but the system being loaded
+are forced not to be recompiled even if modified since last compilation
+(note: this was changed in ASDF 3.1.1).
 If @var{force-not} is a list, then it specifies a list of systems that
 are forced not to be recompiled even if modified since last compilation.
-@var{force} takes precedences over @var{force-not};
-both of them apply to systems that are dependencies and were already compiled.
+
+Both @var{force} and @var{force-not} apply to systems that are dependencies and were already compiled.
+@var{force-not} takes precedences over @var{force},
+as it should, really, but unhappily only since ASDF 3.1.1.
+Moreover, systems the name of which is member of the set @var{*immutable-systems*}
+(represented as an equal hash-table) are always considered @var{forced-not}, and
+even their @file{.asd} is not refreshed from the filesystem.
 
 To see what @code{operate} would do, you can use:
@@ -1608 +1814 @@
 @end deffn
 
-@menu
-* Predefined operations of ASDF::
-* Creating new operations::
-@end menu
+
 
 @node Predefined operations of ASDF, Creating new operations, Operations, Operations
@@ -2080 +2283 @@
 
 @subsubsection Required features
+@anchor{required-features}
 
 Traditionally defsystem users have used @code{#+} reader conditionals
 to include or exclude specific per-implementation files.
-This means that any single implementation cannot read the entire system,
-which becomes a problem if it doesn't wish to compile it,
-but instead for example to create an archive file containing all the sources,
-as it will omit to process the system-dependent sources for other systems.
-
-Each component in an asdf system may therefore specify using @code{:if-feature}
-a feature expression using the same syntax as @code{#+} does,
-such that any reference to the component will be ignored
-during compilation, loading and/or linking if the expression evaluates to false.
+For example, CFFI, the portable C foreign function interface contained
+lines like:
+@lisp
+     #+sbcl       (:file "cffi-sbcl")
+@end lisp
+An unfortunate side effect of this approach is that no single
+implementation can read the entire system.
+This causes problems if, for example, one wished to design an @code{archive-op}
+that would create an archive file containing all the sources, since
+for example the file @code{cffi-sbcl.lisp} above would be invisible when
+running the @code{archive-op} on any implementation other than SBCL.
+
+Starting with ASDF 3,
+components may therefore have an @code{:if-feature} option.
+The value of this option should be
+a feature expression using the same syntax as @code{#+} does.
+If that feature expression evaluates to false, any reference to the component will be ignored
+during compilation, loading and/or linking.
 Since the expression is read by the normal reader,
 you must explicitly prefix your symbols with @code{:} so they be read as keywords;
@@ -2100 +2313 @@
 the given component is only to be compiled and loaded
 when the implementation is SBCL, CMUCL or Scieneer CL on an x86 machine.
-You can not write it as @code{:if-feature (and x86 (or sbcl cmu scl))}
-since the symbols would presumably fail to be read as keywords.
+You cannot write it as @code{:if-feature (and x86 (or sbcl cmu scl))}
+since the symbols would not be read as keywords.
+
+@xref{if-feature-option}.
 
 @subsubsection Dependencies
@@ -2272 +2487 @@
 @code{:if-component-dep-fails}
 This attribute was removed in ASDF 3. Do not use it.
-Use @code{:if-feature} instead.
+Use @code{:if-feature} instead (@pxref{required-features}, and @pxref{if-feature-option}).
 
 @item
@@ -2525 +2740 @@
 
 @section Configuration DSL
+@cindex :inherit-configuration source config directive
+@cindex inherit-configuration source config directive
+@cindex :ignore-invalid-entries source config directive
+@cindex ignore-invalid-entries source config directive
+@cindex :directory source config directive
+@cindex directory source config directive
+@cindex :tree source config directive
+@cindex tree source config directive
+@cindex :exclude source config directive
+@cindex exclude source config directive
+@cindex :also-exclude source config directive
+@cindex also-exclude source config directive
+@cindex :include source config directive
+@cindex include source config directive
+@cindex :default-registry source config directive
+@cindex default-registry source config directive
 
 Here is the grammar of the s-expression (SEXP) DSL for source-registry
@@ -2821 +3052 @@
 which will cause the initialization to happen next time around.
 
+@section Introspection
+
+@subsection *source-registry-parameter* variable
+@vindex *source-registry-parameter*
+
+We have made available the variable @code{*source-registry-parameter*}
+that can be used by code that wishes to introspect about the (past)
+configuration of ASDF's source registry.  @strong{This variable should
+never be set!}  It will be set as a side-effect of calling
+@code{initialize-source-registry}; user code should treat it as
+read-only.
+
+@subsection Information about system dependencies
+
+ASDF makes available three functions to read system interdependencies.
+These are intended to aid programmers who wish to perform dependency
+analyses.
+
+@defun system-defsystem-depends-on system
+@end defun
+
+@defun system-depends-on system
+@end defun
+
+@defun system-weakly-depends-on system
+Returns a list of names of systems that are weakly depended on by
+@var{system}.  Weakly depended on systems are optionally loaded only if
+ASDF can find them; failure to find such systems does @emph{not} cause an
+error in loading.
+
+Note that the return value for @code{system-weakly-depends-on} is simpler
+than the return values of the other two system dependency introspection
+functions.
+@end defun
 
 @section Status
@@ -2898 +3163 @@
 Thanks to Rommel Martinez for the initial implementation attempt.
 
-All bad design ideas and implementation bugs are to mine, not theirs.
+All bad design ideas and implementation bugs are mine, not theirs.
 But so are good design ideas and elegant implementation tricks.
 
@@ -3175 +3440 @@
 which by default is the same as using
 @code{(:home ".cache" "common-lisp" :implementation)}.
-@item
-@code{:system-cache} uses the contents of variable @code{asdf::*system-cache*}
-which by default is the same as using
-@code{("/var/cache/common-lisp" :uid :implementation-type)}
-(on Unix and cygwin), or something semi-sensible on Windows.
 @end itemize
 
@@ -3603 +3863 @@
 These functions are exported by ASDF for your convenience.
 
+@anchor{system-relative-pathname}
 @defun system-relative-pathname system name @Akey type
 
@@ -3942 +4203 @@
 
 
-@node FAQ, TODO list, Getting the latest version, Top
+@node FAQ, Ongoing Work, Getting the latest version, Top
 @comment  node-name,  next,  previous,  up
 @chapter FAQ
 
+@menu
+* Where do I report a bug?::
+* What has changed between ASDF 1 and ASDF 2?::
+* Issues with installing the proper version of ASDF::
+* Issues with configuring ASDF::
+* Issues with using and extending ASDF to define systems::
+* ASDF development FAQs::
+@end menu
+
+@node Where do I report a bug?, What has changed between ASDF 1 and ASDF 2?, FAQ, FAQ
 @section  ``Where do I report a bug?''
 
@@ -3954 +4225 @@
 
 
+@node What has changed between ASDF 1 and ASDF 2?, Issues with installing the proper version of ASDF, Where do I report a bug?, FAQ
 @section ``What has changed between ASDF 1 and ASDF 2?''
 
-@subsection What are ASDF 1 and ASDF 2?
-
-On May 31st 2010, we have released ASDF 2.
-ASDF 2 refers to release 2.000 and later.
-(Releases between 1.656 and 1.728 were development releases for ASDF 2.)
-ASDF 1 to any release earlier than 1.369 or so.
-If your ASDF doesn't sport a version, it's an old ASDF 1.
-
-ASDF 2 and its release candidates push
-@code{:asdf2} onto @code{*features*} so that if you are writing
-ASDF-dependent code you may check for this feature
-to see if the new API is present.
-@emph{All} versions of ASDF should have the @code{:asdf} feature.
-
-Additionally, all versions of ASDF 2
-define a function @code{(asdf:asdf-version)} you may use to query the version;
-and the source code of recent versions of ASDF 2 features the version number
-prominently on the second line of its source code.
-
-If you are experiencing problems or limitations of any sort with ASDF 1,
-we recommend that you should upgrade to ASDF 2,
-or whatever is the latest release.
-
-
+@menu
+* What are ASDF 1 2 3?::
+* ASDF can portably name files in subdirectories::
+* Output translations::
+* Source Registry Configuration::
+* Usual operations are made easier to the user::
+* Many bugs have been fixed::
+* ASDF itself is versioned::
+* ASDF can be upgraded::
+* Decoupled release cycle::
+* Pitfalls of the transition to ASDF 2::
+@end menu
+
+@node What are ASDF 1 2 3?, ASDF can portably name files in subdirectories, What has changed between ASDF 1 and ASDF 2?, What has changed between ASDF 1 and ASDF 2?
+@subsection What are ASDF 1, ASDF 2 and ASDF 3?
+
+ASDF 1 refers to any release earlier than 1.369 or so (from August 2001 to October 2009),
+and to any development revision earlier than 2.000 (May 2010).
+If your copy of ASDF doesn't even contain version information, it's an old ASDF 1.
+Revisions between 1.656 and 1.728 may count as development releases for ASDF 2.
+
+ASDF 2 refers to releases from 2.000 (May 31st 2010) to 2.26 (Oct 30 2012),
+and any development revision newer than ASDF 1 and older than 2.27 (Feb 1 2013).
+
+ASDF 3 refers to releases from 2.27 (Feb 1 2013) to 2.33 and 3.0.0 onward (May 15 2013).
+2.27 to 2.33 count as pre-releases to ASDF 3.
+
+All releases of ASDF
+push @code{:asdf} onto @code{*features*}.
+Releases starting with ASDF 2
+ push @code{:asdf2} onto @code{*features*}.
+Releases starting with ASDF 3 (including 2.27 and later pre-releases)
+push @code{:asdf3} onto @code{*features*}.
+Furthermore, releases starting with ASDF 3.1 (March 2014),
+though they count as ASDF 3, includes enough progress that they
+push @code{:asdf3.1} onto @code{*features*}.
+You may depend on the presence or absence of these features
+to write code that takes advantage of recent ASDF functionality
+but still works on older versions, or at least detects the old version and signals an error.
+
+Additionally, all releases starting with ASDF 2
+define a function @code{(asdf:asdf-version)} you may use to query the version.
+All releases starting with 2.013 display the version number prominently
+on the second line of the @file{asdf.lisp} source file.
+
+If you are experiencing problems or limitations of any sort with ASDF 1 or ASDF 2,
+we recommend that you should upgrade to the latest release, be it ASDF 3 or other.
+
+
+@node ASDF can portably name files in subdirectories, Output translations, What are ASDF 1 2 3?, What has changed between ASDF 1 and ASDF 2?
 @subsection ASDF can portably name files in subdirectories
 
@@ -3997 +4295 @@
 ASDF 2 implements its own portable syntax for strings as pathname specifiers.
 Naming files within a system definition becomes easy and portable again.
-@xref{Miscellaneous additional functionality,asdf:system-relative-pathname},
+@xref{Miscellaneous additional functionality,system-relative-pathname},
 @code{merge-pathnames*},
 @code{coerce-pathname}.
@@ -4010 +4308 @@
 
 
+@node Output translations, Source Registry Configuration, ASDF can portably name files in subdirectories, What has changed between ASDF 1 and ASDF 2?
 @subsection Output translations
 
@@ -4031 +4330 @@
 @xref{Controlling where ASDF saves compiled files}.
 
+@node Source Registry Configuration, Usual operations are made easier to the user, Output translations, What has changed between ASDF 1 and ASDF 2?
 @subsection Source Registry Configuration
 
@@ -4065 +4365 @@
 
 
+@node Usual operations are made easier to the user, Many bugs have been fixed, Source Registry Configuration, What has changed between ASDF 1 and ASDF 2?
 @subsection Usual operations are made easier to the user
 
@@ -4077 +4378 @@
 
 
+@node Many bugs have been fixed, ASDF itself is versioned, Usual operations are made easier to the user, What has changed between ASDF 1 and ASDF 2?
 @subsection Many bugs have been fixed
 
@@ -4093 +4395 @@
 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.
+The @code{:version} and
+the @code{:force (system1 .. systemN)} feature have been fixed.
 
 @item
@@ -4125 +4427 @@
 
 
+@node ASDF itself is versioned, ASDF can be upgraded, Many bugs have been fixed, What has changed between ASDF 1 and ASDF 2?
 @subsection ASDF itself is versioned
 
@@ -4141 +4444 @@
 
 
+@node ASDF can be upgraded, Decoupled release cycle, ASDF itself is versioned, What has changed between ASDF 1 and ASDF 2?
 @subsection ASDF can be upgraded
 
@@ -4165 +4469 @@
 you must also reload or upgrade all ASDF extensions.
 
+@node Decoupled release cycle, Pitfalls of the transition to ASDF 2, ASDF can be upgraded, What has changed between ASDF 1 and ASDF 2?
 @subsection Decoupled release cycle
 
@@ -4183 +4488 @@
 
 
+@node Pitfalls of the transition to ASDF 2,  , Decoupled release cycle, What has changed between ASDF 1 and ASDF 2?
 @subsection Pitfalls of the transition to ASDF 2
 
@@ -4278 +4584 @@
 
 
+@node Issues with installing the proper version of ASDF, Issues with configuring ASDF, What has changed between ASDF 1 and ASDF 2?, FAQ
 @section Issues with installing the proper version of ASDF
 
+@menu
+* My Common Lisp implementation comes with an outdated version of ASDF. What to do?::
+* I'm a Common Lisp implementation vendor. When and how should I upgrade ASDF?::
+@end menu
+
+@node My Common Lisp implementation comes with an outdated version of ASDF. What to do?, I'm a Common Lisp implementation vendor. When and how should I upgrade ASDF?, Issues with installing the proper version of ASDF, Issues with installing the proper version of ASDF
 @subsection ``My Common Lisp implementation comes with an outdated version of ASDF. What to do?''
 
@@ -4291 +4604 @@
 
 
+@node I'm a Common Lisp implementation vendor. When and how should I upgrade ASDF?,  , My Common Lisp implementation comes with an outdated version of ASDF. What to do?, Issues with installing the proper version of ASDF
 @subsection ``I'm a Common Lisp implementation vendor. When and how should I upgrade ASDF?''
 
@@ -4299 +4613 @@
 Though we do try to test ASDF releases against all implementations that we can,
 we may not be testing against all variants of your implementation,
-and we may not be running enough tetst;
+and we may not be running enough tests;
 we trust you to thoroughly test it with your own implementation
 before you release it.
@@ -4357 +4671 @@
 @item
 Since ASDF 3, the library UIOP comes transcluded in ASDF.
-But for extra brownies, you may package UIOP separately,
-so that one may @code{(require "uiop")} and not pull ASDF,
+But if you want to be nice to users who care for UIOP but not for ASDF,
+you may package UIOP separately,
+so that one may @code{(require "uiop")} and not load ASDF,
 or one may @code{(require "asdf")}
-and that would implicitly require the former.
+which would implicitly require and load the former.
 
 @item
@@ -4371 +4686 @@
 
 
+@node Issues with configuring ASDF, Issues with using and extending ASDF to define systems, Issues with installing the proper version of ASDF, FAQ
 @section Issues with configuring ASDF
 
+@menu
+* How can I customize where fasl files are stored?::
+* How can I wholly disable the compiler output cache?::
+@end menu
+
+@node How can I customize where fasl files are stored?, How can I wholly disable the compiler output cache?, Issues with configuring ASDF, Issues with configuring ASDF
 @subsection ``How can I customize where fasl files are stored?''
 
@@ -4393 +4715 @@
 whose pathname has been translated by the facility.
 
+@node How can I wholly disable the compiler output cache?,  , How can I customize where fasl files are stored?, Issues with configuring ASDF
 @subsection ``How can I wholly disable the compiler output cache?''
 
@@ -4424 +4747 @@
 @end example
 
+@node Issues with using and extending ASDF to define systems, ASDF development FAQs, Issues with configuring ASDF, FAQ
 @section Issues with using and extending ASDF to define systems
 
+@menu
+* How can I cater for unit-testing in my system?::
+* How can I cater for documentation generation in my system?::
+* How can I maintain non-Lisp (e.g. C) source files?::
+* I want to put my module's files at the top level.  How do I do this?::
+* How do I create a system definition where all the source files have a .cl extension?::
+@end menu
+
+@node How can I cater for unit-testing in my system?, How can I cater for documentation generation in my system?, Issues with using and extending ASDF to define systems, Issues with using and extending ASDF to define systems
 @subsection ``How can I cater for unit-testing in my system?''
 
@@ -4479 +4812 @@
 discussion.
 
+@node How can I cater for documentation generation in my system?, How can I maintain non-Lisp (e.g. C) source files?, How can I cater for unit-testing in my system?, Issues with using and extending ASDF to define systems
 @subsection ``How can I cater for documentation generation in my system?''
 
-The ASDF developers are currently working to add a @code{doc-op}
-to the set of predefined ASDF operations.
-@xref{Predefined operations of ASDF}.
+Various ASDF extensions provide some kind of @code{doc-op} operation.
 See also @url{https://bugs.launchpad.net/asdf/+bug/479470}.
 
 
-
+@node How can I maintain non-Lisp (e.g. C) source files?, I want to put my module's files at the top level.  How do I do this?, How can I cater for documentation generation in my system?, Issues with using and extending ASDF to define systems
 @subsection ``How can I maintain non-Lisp (e.g. C) source files?''
 
@@ -4495 +4827 @@
 
 
+@node I want to put my module's files at the top level.  How do I do this?, How do I create a system definition where all the source files have a .cl extension?, How can I maintain non-Lisp (e.g. C) source files?, Issues with using and extending ASDF to define systems
 @subsection ``I want to put my module's files at the top level.  How do I do this?''
 
@@ -4557 +4890 @@
 (if the component class doesn't specifies a pathname type).
 
+@node How do I create a system definition where all the source files have a .cl extension?,  , I want to put my module's files at the top level.  How do I do this?, Issues with using and extending ASDF to define systems
 @subsection How do I create a system definition where all the source files have a .cl extension?
 
@@ -4625 +4959 @@
 @end lisp
 
+@node ASDF development FAQs,  , Issues with using and extending ASDF to define systems, FAQ
+@section ASDF development FAQs
+
+@menu
+* How do run the tests interactively in a REPL?::
+@end menu
+
+@node How do run the tests interactively in a REPL?,  , ASDF development FAQs, ASDF development FAQs
+@subsection How do run the tests interactively in a REPL?
+
+This not-so-frequently asked question is primarily for ASDF developers,
+but those who encounter an unexpected error in some test may be
+interested, too.
+
+Here's the procedure for experimenting with tests in a REPL:
+@example
+(load "script-support.lisp")
+(in-package :asdf-test)
+(compile-load-asdf) ; there are a number of other functions to load ASDF
+;; experiment with test code from a .script file...
+@end example
+
+
 @comment FIXME: Add a FAQ about how to use a new system class...
 
-
-@node  TODO list, Inspiration, FAQ, Top
 @comment  node-name,  next,  previous,  up
-@chapter TODO list
-
-Here is an old list of things to do,
-in addition to the bugs that are now tracked on launchpad:
+@node  Ongoing Work, Bibliography, FAQ, Top
+@unnumbered Ongoing Work
+For an active list of things to be done,
+see the @file{TODO} file in the source repository.
+
+Also, bugs that are now tracked on launchpad:
 @url{https://launchpad.net/asdf}.
 
-@section Outstanding spec questions, things to add
-
-** packaging systems
-
-*** manual page component?
-
-** style guide for .asd files
-
-You should either use keywords or be careful
-with the package that you evaluate defsystem forms in.
-Otherwise @code{(defsystem partition ...)}
-being read in the @code{cl-user} package
-will intern a @code{cl-user:partition} symbol,
-which will then collide with the @code{partition:partition} symbol.
-
-Actually there's a hairier packages problem to think about too.
-@code{in-order-to} is not a keyword:
-if you read @code{defsystem} forms in a package that doesn't use ASDF,
-odd things might happen.
-
-
-** extending defsystem with new options
-
-You might not want to write a whole parser,
-but just to add options to the existing syntax.
-Reinstate @code{parse-option} or something akin.
-
-
-** Diagnostics
-
-A ``dry run'' of an operation can be made with the following form:
-
-@lisp
-(let ((asdf::*verbose-out* *standard-output*))
-  (loop :for (op . comp) :in
-    (asdf::traverse (make-instance '<operation-name> :force t)
-                    (asdf:find-system <system-name>))
-    :do (asdf:explain op comp)))
-@end lisp
-
-This uses unexported symbols.
-What would be a nice interface for this functionality?
-
-@section Missing bits in implementation
-
-** reuse the same scratch package whenever a system is reloaded from disk
-
-Have a package ASDF-USER instead of all these temporary packages?
-
-** proclamations probably aren't
-
-** A revert function
-
-Other possible interface: have a ``revert'' function akin to @code{make clean}.
-
-@lisp
-(asdf:revert 'asdf:compile-op 'araneida)
-@end lisp
-
-would delete any files produced by @code{(compile-system :araneida)}.
-Of course, it wouldn't be able to do much about stuff in the image itself.
-
-How would this work?
-
-@code{traverse}
-
-There's a difference between a module's dependencies (peers)
-and its components (children).
-Perhaps there's a similar difference in operations?
-For example, @code{(load "use") depends-on (load "macros")} is a peer,
-whereas @code{(load "use") depends-on (compile "use")}
-is more of a ``subservient'' relationship.
-
-@node  Inspiration, Concept Index, TODO list, Top
-@comment  node-name,  next,  previous,  up
-@chapter Inspiration
-
-@section mk-defsystem (defsystem-3.x)
-
-We aim to solve basically the same problems as @code{mk-defsystem} does.
-However, our architecture for extensibility
-better exploits CL language features (and is documented),
-and we intend to be portable rather than just widely-ported.
-No slight on the @code{mk-defsystem} authors and maintainers is intended here;
-that implementation has the unenviable task
-of supporting pre-ANSI implementations, which is no longer necessary.
-
-The surface defsystem syntax of asdf is more-or-less compatible with
-@code{mk-defsystem}, except that we do not support
-the @code{source-foo} and @code{binary-foo} prefixes
-for separating source and binary files, and
-we advise the removal of all options to specify pathnames.
-
-The @code{mk-defsystem} code for topologically sorting
-a module's dependency list was very useful.
-
-@section defsystem-4 proposal
-
-Marco and Peter's proposal for defsystem 4 served as the driver for
-many of the features in here.  Notable differences are:
+@node Bibliography, Concept Index, Ongoing Work, Top
+@unnumbered Bibliography
 
 @itemize
-@item
-We don't specify output files or output file extensions
-as part of the system.
-
-If you want to find out what files an operation would create,
-ask the operation.
-
-@item
-We don't deal with CL packages
-
-If you want to compile in a particular package, use an @code{in-package} form
-in that file (ilisp / SLIME will like you more if you do this anyway)
-
-@item
-There is no proposal here that @code{defsystem} does version control.
-
-A system has a given version which can be used to check dependencies,
-but that's all.
+@item Zach Beane:
+  ``Quicklisp'', 2011.
+  The Quicklisp blog and Xach's livejournal contain information on Quicklisp.
+  @url{http://blog.quicklisp.org/}
+  @url{http://xach.livejournal.com/}
+@item Francois-Rene Rideau and Robert Goldman:
+  ``Evolving ASDF: More Cooperation, Less Coordination'', 2010.
+  This article describes the main issues solved by ASDF 2.
+  @url{http://common-lisp.net/project/asdf/doc/ilc2010draft.pdf}
+  @url{http://www.common-lisp.org/gitweb?p=projects/asdf/ilc2010.git}
+@item Francois-Rene Rideau and Spencer Brody:
+  ``XCVB: an eXtensible Component Verifier and Builder for Common Lisp'', 2009.
+  This article describes XCVB, a proposed competitor for ASDF,
+  many ideas of which have been incorporated into ASDF 2 and 3,
+  though many other of which still haven't.
+  @url{http://common-lisp.net/projects/xcvb/}
+@item Dan Barlow: ``ASDF Manual'', 2004
+  Older versions of this document from the days of ASDF 1;
+  they include ideas laid down by Dan Barlow,
+  and comparisons with older defsystems (@code{mk-defsystem})
+  and defsystem (@code{defsystem-4}, kmp's Memo 801).
+@item Marco Antoniotti and Peter Van Eynde:
+ ``@code{DEFSYSTEM}: A @code{make} for Common Lisp, A Thoughtful Re-Implementation of an Old Idea'', 2002.
+  The @file{defsystem-4} proposal available in the CLOCC repository.
+@item Mark Kantrovitz: ``Defsystem: A Portable Make Facility for Common Lisp'', 1990.
+  The classic @file{mk-defsystem}, later variants of which
+  are available in the CLOCC repository as @code{defsystem-3.x}.
+@item Richard Elliot Robbins:
+  ``BUILD: A Tool for Maintaining Consistency in Modular Systems'', MIT AI TR 874, 1985.
+  @url{ftp://publications.ai.mit.edu/ai-publications/pdf/AITR-874.pdf}
+@item Kent M. Pitman (kmp): ``The Description of Large Systems'', MIT AI Memo 801, 1984.
+  Available in updated-for-CL form on the web at
+  @url{http://nhplace.com/kent/Papers/Large-Systems.html}
+@item Dan Weinreb and David Moon:
+  ``Lisp Machine Manual'', MIT, 1981.
+  The famous CHINE NUAL describes one of the earliest variants of DEFSYSTEM.
+  @url{https://bitsavers.trailing-edge.com/pdf/mit/cadr/chinual_4thEd_Jul81.pdf}
+@item Drew McDermott: ``A Framework for Maintaining the Coherence of a
+  Running Lisp,'' International Lisp Conference, 2005, available in
+  pre-print form at @url{http://www.cs.yale.edu/homes/dvm/papers/lisp05.pdf}.
 @end itemize
 
-The defsystem 4 proposal tends to look more at the external features,
-whereas this one centres on a protocol for system introspection.
-
-@section kmp's ``The Description of Large Systems'', MIT AI Memo 801
-
-Available in updated-for-CL form on the web at
-@url{http://nhplace.com/kent/Papers/Large-Systems.html}
-
-In our implementation we borrow kmp's overall @code{PROCESS-OPTIONS}
-and concept to deal with creating component trees
-from @code{defsystem} surface syntax.
-[ this is not true right now, though it used to be and
-probably will be again soon ]
-
-
-@c -------------------
-
-
-@node Concept Index, Function and Class Index, Inspiration, Top
+
+@node Concept Index, Function and Class Index, Bibliography, Top
 @unnumbered Concept Index
 

trunk/abcl/src/org/armedbear/lisp/asdf.lisp

@@ -1 +1 @@
 ;;; -*- mode: Common-Lisp; Base: 10 ; Syntax: ANSI-Common-Lisp ; buffer-read-only: t; -*-
-;;; This is ASDF 3.1.0.65: Another System Definition Facility.
+;;; This is ASDF 3.1.0.94: Another System Definition Facility.
 ;;;
 ;;; Feedback, bug reports, and patches are all welcome:
@@ -1043 +1043 @@
    #:first-char #:last-char #:split-string #:stripln #:+cr+ #:+lf+ #:+crlf+
    #:string-prefix-p #:string-enclosed-p #:string-suffix-p
-   #:find-class* ;; CLOS
+   #:coerce-class ;; CLOS
    #:stamp< #:stamps< #:stamp*< #:stamp<= ;; stamps
    #:earlier-stamp #:stamps-earliest #:earliest-stamp
@@ -1215 +1215 @@
 (with-upgradability () ;; base-char != character on ECL, LW, SBCL, Genera. LW also has SIMPLE-CHAR.
   (defconstant +non-base-chars-exist-p+ (not (subtypep 'character 'base-char)))
+  #-scl ;; In SCL, all characters seem to be 16-bit base-char, but this flag gets set somehow???
   (when +non-base-chars-exist-p+ (pushnew :non-base-chars-exist-p *features*)))
 
@@ -1351 +1352 @@
 ;;; CLOS
 (with-upgradability ()
-  (defun find-class* (x &optional (errorp t) environment)
-    (etypecase x
-      ((or standard-class built-in-class) x)
-      (symbol (find-class x errorp environment)))))
+  (defun coerce-class (class &key (package :cl) (super t) (error 'error))
+    "Coerce CLASS to a class that is subclass of SUPER if specified,
+or invoke ERROR handler as per CALL-FUNCTION.
+
+A keyword designates the name a symbol, which when found in PACKAGE, designates a class.
+A string is read as a symbol while in PACKAGE, the symbol designates a class.
+
+A class object designates itself.
+NIL designates itself (no class).
+A symbol otherwise designates a class by name."
+    (let* ((normalized
+             (typecase class
+              (keyword (find-symbol* class package nil))
+              (string (symbol-call :uiop :safe-read-from-string class :package package))
+              (t class)))
+           (found
+             (etypecase normalized
+               ((or standard-class built-in-class) normalized)
+               ((or null keyword) nil)
+               (symbol (find-class normalized nil nil)))))
+      (or (and found
+               (or (eq super t) (#-cormanlisp subtypep #+cormanlisp cl::subclassp found super))
+               found)
+          (call-function error "Can't coerce ~S to a ~@[class~;subclass of ~:*~S]" class super)))))
 
 
@@ -1398 +1419 @@
       (function fun)
       ((or boolean keyword character number pathname) (constantly fun))
+      (hash-table (lambda (x) (gethash x fun)))
       (symbol (fdefinition fun))
       (cons (if (eq 'lambda (car fun))
@@ -1859 +1881 @@
           #+lispworks (hcl:change-directory x)
           #+mkcl (mk-ext:chdir x)
-          #+sbcl (symbol-call :sb-posix :chdir (sb-ext:native-namestring x))
+          #+sbcl (progn (require :sb-posix) (symbol-call :sb-posix :chdir (sb-ext:native-namestring x)))
           (error "chdir not supported on your implementation")))))
 
@@ -2039 +2061 @@
   ;; This will be :unspecific if supported, or NIL if not.
   (defparameter *unspecific-pathname-type*
-    #+(or abcl allegro clozure cmu genera lispworks mkcl sbcl scl xcl) :unspecific
-    #+(or clisp ecl gcl #|These haven't been tested:|# cormanlisp mcl) nil
+    #+(or abcl allegro clozure cmu genera lispworks mkcl sbcl scl) :unspecific
+    #+(or clisp ecl gcl xcl #|These haven't been tested:|# cormanlisp mcl) nil
     "Unspecific type component to use with the underlying implementation's MAKE-PATHNAME")
 
@@ -2255 +2277 @@
       (let ((pathname (pathname pathname)))
         (flet ((check-one (x)
-                 (member x '(nil :unspecific "") :test 'equal)))
+                 (member x '(nil :unspecific) :test 'equal)))
           (and (not (wild-pathname-p pathname))
                (check-one (pathname-name pathname))
@@ -2431 +2453 @@
       (pathname
        (with-output-to-string (s)
-         (flet ((err () (error "Not a valid unix-namestring ~S" pathname)))
+         (flet ((err () #+lispworks (describe pathname) (error "Not a valid unix-namestring ~S" pathname)))
            (let* ((dir (normalize-pathname-directory-component (pathname-directory pathname)))
                   (name (pathname-name pathname))
+                  (name (and (not (eq name :unspecific)) name))
                   (type (pathname-type pathname))
                   (type (and (not (eq type :unspecific)) type)))
              (cond
-               ((eq dir ()))
+               ((member dir '(nil :unspecific)))
                ((eq dir '(:relative)) (princ "./" s))
                ((consp dir)
@@ -2453 +2476 @@
              (cond
                (name
-                (or (and (stringp name) (or (null type) (stringp type))) (err))
+                (unless (and (stringp name) (or (null type) (stringp type))) (err))
                 (format s "~A~@[.~A~]" name type))
                (t
@@ -2491 +2514 @@
                     ;; scheme-specific parts: port username password, not others:
                     . #.(or #+scl '(:parameters nil :query nil :fragment nil))))
-
-  (defun subpathp (maybe-subpath base-pathname)
-    "if MAYBE-SUBPATH is a pathname that is under BASE-PATHNAME, return a pathname object that
-when used with MERGE-PATHNAMES* with defaults BASE-PATHNAME, returns MAYBE-SUBPATH."
-    (and (pathnamep maybe-subpath) (pathnamep base-pathname)
-         (absolute-pathname-p maybe-subpath) (absolute-pathname-p base-pathname)
-         (directory-pathname-p base-pathname) (not (wild-pathname-p base-pathname))
-         (pathname-equal (pathname-root maybe-subpath) (pathname-root base-pathname))
-         (with-pathname-defaults ()
-           (let ((enough (enough-namestring maybe-subpath base-pathname)))
-             (and (relative-pathname-p enough) (pathname enough))))))
-
-  (defun enough-pathname (maybe-subpath base-pathname)
-    "if MAYBE-SUBPATH is a pathname that is under BASE-PATHNAME, return a pathname object that
-when used with MERGE-PATHNAMES* with defaults BASE-PATHNAME, returns MAYBE-SUBPATH."
-    (check-type maybe-subpath (or null pathname))
-    (check-type base-pathname (or null pathname))
-    (when (pathnamep base-pathname) (assert (absolute-pathname-p base-pathname)))
-    (or (and base-pathname (subpathp maybe-subpath base-pathname))
-        maybe-subpath))
-
-  (defun call-with-enough-pathname (maybe-subpath defaults-pathname thunk)
-    "In a context where *DEFAULT-PATHNAME-DEFAULTS* is bound to DEFAULTS-PATHNAME (if not null,
-or else to its current value), call THUNK with ENOUGH-PATHNAME for MAYBE-SUBPATH
-given DEFAULTS-PATHNAME as a base pathname."
-    (let ((enough (enough-pathname maybe-subpath defaults-pathname))
-          (*default-pathname-defaults* (or defaults-pathname *default-pathname-defaults*)))
-      (funcall thunk enough)))
-
-  (defmacro with-enough-pathname ((pathname-var &key (pathname pathname-var)
-                                                  (defaults *default-pathname-defaults*))
-                                  &body body)
-    "Shorthand syntax for CALL-WITH-ENOUGH-PATHNAME"
-    `(call-with-enough-pathname ,pathname ,defaults #'(lambda (,pathname-var) ,@body)))
 
   (defun ensure-absolute-pathname (path &optional defaults (on-error 'error))
@@ -2543 +2532 @@
       (t (call-function on-error
                         "Cannot ensure ~S is evaluated as an absolute pathname with defaults ~S"
-                        path defaults)))))
+                        path defaults))))
+
+  (defun subpathp (maybe-subpath base-pathname)
+    "if MAYBE-SUBPATH is a pathname that is under BASE-PATHNAME, return a pathname object that
+when used with MERGE-PATHNAMES* with defaults BASE-PATHNAME, returns MAYBE-SUBPATH."
+    (and (pathnamep maybe-subpath) (pathnamep base-pathname)
+         (absolute-pathname-p maybe-subpath) (absolute-pathname-p base-pathname)
+         (directory-pathname-p base-pathname) (not (wild-pathname-p base-pathname))
+         (pathname-equal (pathname-root maybe-subpath) (pathname-root base-pathname))
+         (with-pathname-defaults ()
+           (let ((enough (enough-namestring maybe-subpath base-pathname)))
+             (and (relative-pathname-p enough) (pathname enough))))))
+
+  (defun enough-pathname (maybe-subpath base-pathname)
+    "if MAYBE-SUBPATH is a pathname that is under BASE-PATHNAME, return a pathname object that
+when used with MERGE-PATHNAMES* with defaults BASE-PATHNAME, returns MAYBE-SUBPATH."
+    (let ((sub (when maybe-subpath (pathname maybe-subpath)))
+    (base (when base-pathname (ensure-absolute-pathname (pathname base-pathname)))))
+      (or (and base (subpathp sub base)) sub)))
+
+  (defun call-with-enough-pathname (maybe-subpath defaults-pathname thunk)
+    "In a context where *DEFAULT-PATHNAME-DEFAULTS* is bound to DEFAULTS-PATHNAME (if not null,
+or else to its current value), call THUNK with ENOUGH-PATHNAME for MAYBE-SUBPATH
+given DEFAULTS-PATHNAME as a base pathname."
+    (let ((enough (enough-pathname maybe-subpath defaults-pathname))
+          (*default-pathname-defaults* (or defaults-pathname *default-pathname-defaults*)))
+      (funcall thunk enough)))
+
+  (defmacro with-enough-pathname ((pathname-var &key (pathname pathname-var)
+                                                  (defaults *default-pathname-defaults*))
+                                  &body body)
+    "Shorthand syntax for CALL-WITH-ENOUGH-PATHNAME"
+    `(call-with-enough-pathname ,pathname ,defaults #'(lambda (,pathname-var) ,@body))))
 
 
@@ -2797 +2818 @@
                                    (truename foundtrue)
                                    (foundtrue p)))))
-                       (let* ((fs (find-symbol* '#:file-stat :posix nil))
+                       (let* ((fs (or #-os-windows (find-symbol* '#:file-stat :posix nil)))
                               (pp (find-symbol* '#:probe-pathname :ext nil))
                               (resolve (if pp
@@ -2893 +2914 @@
       (let* ((pat (merge-pathnames* pattern dir))
              (entries (append (ignore-errors (directory* pat))
-                              #+clisp
+                              #+(or clisp gcl)
                               (when (equal :wild (pathname-type pattern))
                                 (ignore-errors (directory* (make-pathname :type nil :defaults pat)))))))
@@ -3252 +3273 @@
     #-clisp
     (rename-file source target
-                 #+clozure :if-exists #+clozure :rename-and-delete))
+                 #+(or clozure ecl) :if-exists #+clozure :rename-and-delete #+ecl t))
 
   (defun delete-file-if-exists (x)
@@ -3502 +3523 @@
       (read-from-string string eof-error-p eof-value :start start :end end :preserve-whitespace preserve-whitespace))))
 
-;;; Output to a stream or string, FORMAT-style
-(with-upgradability ()
-  (defun call-with-output (output function)
-    "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 T, use *STANDARD-OUTPUT* as the stream.
-If OUTPUT is a string with a fill-pointer, use it as a string-output-stream.
-Otherwise, signal an error."
-    (etypecase output
-      (null
-       (with-output-to-string (stream) (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)))))
-
-  (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)))
-
-  (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
-(with-upgradability ()
-  (defun call-with-input (input function)
-    "Calls FUNCTION with an actual stream argument, interpreting
-stream designators like READ, but also coercing strings to STRING-INPUT-STREAM.
-If INPUT is a STREAM, use it as the stream.
-If INPUT is NIL, use a *STANDARD-INPUT* as the stream.
-If INPUT is T, use *TERMINAL-IO* as the stream.
-As an extension, if INPUT is a string, use it as a string-input-stream.
-Otherwise, signal an error."
-    (etypecase input
-      (null (funcall function *standard-input*))
-      ((eql t) (funcall function *terminal-io*))
-      (stream (funcall function input))
-      (string (with-input-from-string (stream input) (funcall function stream)))))
-
-  (defmacro with-input ((input-var &optional (value input-var)) &body body)
-    "Bind INPUT-VAR to an input stream, coercing VALUE (default: previous binding of INPUT-VAR)
-as per CALL-WITH-INPUT, and evaluate BODY within the scope of this binding."
-    `(call-with-input ,value #'(lambda (,input-var) ,@body)))
-
-  (defun call-with-input-file (pathname thunk
-                               &key
-                                 (element-type *default-stream-element-type*)
-                                 (external-format *utf-8-external-format*)
-                                 (if-does-not-exist :error))
-    "Open FILE for input with given recognizes options, call THUNK with the resulting stream.
-Other keys are accepted but discarded."
-    (with-open-file (s pathname :direction :input
-                                :element-type element-type
-                                :external-format external-format
-                                :if-does-not-exist if-does-not-exist)
-      (funcall thunk s)))
-
-  (defmacro with-input-file ((var pathname &rest keys
-                              &key element-type external-format if-does-not-exist)
-                             &body body)
-    (declare (ignore element-type external-format if-does-not-exist))
-    `(call-with-input-file ,pathname #'(lambda (,var) ,@body) ,@keys))
-
+;;; Output helpers
+(with-upgradability ()
   (defun call-with-output-file (pathname thunk
                                 &key
@@ -3594 +3544 @@
                               &body body)
     (declare (ignore element-type external-format if-exists if-does-not-exist))
-    `(call-with-output-file ,pathname #'(lambda (,var) ,@body) ,@keys)))
+    `(call-with-output-file ,pathname #'(lambda (,var) ,@body) ,@keys))
+
+  (defun call-with-output (output function &key keys)
+    "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 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
+-- this latter as an extension since ASDF 3.1.
+Otherwise, signal an error."
+    (etypecase output
+      (null
+       (with-output-to-string (stream) (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)))
+      (pathname
+       (apply 'call-with-output-file output function keys))))
+
+  (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)))
+
+  (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
+(with-upgradability ()
+  (defun call-with-input-file (pathname thunk
+                               &key
+                                 (element-type *default-stream-element-type*)
+                                 (external-format *utf-8-external-format*)
+                                 (if-does-not-exist :error))
+    "Open FILE for input with given recognizes options, call THUNK with the resulting stream.
+Other keys are accepted but discarded."
+    (with-open-file (s pathname :direction :input
+                                :element-type element-type
+                                :external-format external-format
+                                :if-does-not-exist if-does-not-exist)
+      (funcall thunk s)))
+
+  (defmacro with-input-file ((var pathname &rest keys
+                              &key element-type external-format if-does-not-exist)
+                             &body body)
+    (declare (ignore element-type external-format if-does-not-exist))
+    `(call-with-input-file ,pathname #'(lambda (,var) ,@body) ,@keys))
+
+  (defun call-with-input (input function &key keys)
+    "Calls FUNCTION with an actual stream argument, interpreting
+stream designators like READ, but also coercing strings to STRING-INPUT-STREAM,
+and PATHNAME to FILE-STREAM.
+If INPUT is a STREAM, use it as the stream.
+If INPUT is NIL, use a *STANDARD-INPUT* as the stream.
+If INPUT is T, use *TERMINAL-IO* as the stream.
+If INPUT is a STRING, use it as a string-input-stream.
+If INPUT is a PATHNAME, open it, passing KEYS to WITH-INPUT-FILE
+-- the latter is an extension since ASDF 3.1.
+Otherwise, signal an error."
+    (etypecase input
+      (null (funcall function *standard-input*))
+      ((eql t) (funcall function *terminal-io*))
+      (stream (funcall function input))
+      (string (with-input-from-string (stream input) (funcall function stream)))
+      (pathname (apply 'call-with-input-file input function keys))))
+
+  (defmacro with-input ((input-var &optional (value input-var)) &body body)
+    "Bind INPUT-VAR to an input stream, coercing VALUE (default: previous binding of INPUT-VAR)
+as per CALL-WITH-INPUT, and evaluate BODY within the scope of this binding."
+    `(call-with-input ,value #'(lambda (,input-var) ,@body))))
+
 
 ;;; Null device
@@ -3841 +3871 @@
   (defun println (x &optional (stream *standard-output*))
     "Variant of PRINC that also calls TERPRI afterwards"
-    (princ x stream) (terpri stream) (values))
+    (princ x stream) (terpri stream) (finish-output stream) (values))
 
   (defun writeln (x &rest keys &key (stream *standard-output*) &allow-other-keys)
     "Variant of WRITE that also calls TERPRI afterwards"
-    (apply 'write x keys) (terpri stream) (values)))
+    (apply 'write x keys) (terpri stream) (finish-output stream) (values)))
 
 
@@ -3896 +3926 @@
 If AFTER is defined, its results are returned, otherwise, the results of THUNK are returned.
 Finally, the file will be deleted, unless the KEEP argument when CALL-FUNCTION'ed returns true."
+    #+xcl (declare (ignorable typep))
     (check-type direction (member :output :io))
     (assert (or want-stream-p want-pathname-p))
@@ -4022 +4053 @@
   (:export
    #:*image-dumped-p* #:raw-command-line-arguments #:*command-line-arguments*
-   #:command-line-arguments #:raw-command-line-arguments #:setup-command-line-arguments
+   #:command-line-arguments #:raw-command-line-arguments #:setup-command-line-arguments #:argv0
    #:*lisp-interaction*
    #:*fatal-conditions* #:fatal-condition-p #:handle-fatal-condition
@@ -4257 +4288 @@
 Assume the calling conventions of a generated script that uses --
 if we are not called from a directly executable image."
-    #+abcl arguments
-    #-abcl
-    (let* (#-(or sbcl allegro)
-           (arguments
-             (if (eq *image-dumped-p* :executable)
-                 arguments
-                 (member "--" arguments :test 'string-equal))))
+    (block nil
+      #+abcl (return arguments)
+      ;; SBCL and Allegro already separate user arguments from implementation arguments.
+      #-(or sbcl allegro)
+      (unless (eq *image-dumped-p* :executable)
+  ;; LispWorks command-line processing isn't transparent to the user
+  ;; unless you create a standalone executable; in that case,
+  ;; we rely on cl-launch or some other script to set the arguments for us.
+  #+lispworks (return *command-line-arguments*)
+  ;; On other implementations, on non-standalone executables,
+  ;; we trust cl-launch or whichever script starts the program
+  ;; to use -- as a delimiter between implementation arguments and user arguments.
+  #-lispworks (setf arguments (member "--" arguments :test 'string-equal)))
       (rest arguments)))
+
+  (defun argv0 ()
+    "On supported implementations (most that matter), or when invoked by a proper wrapper script,
+return a string that for the name with which the program was invoked, i.e. argv[0] in C.
+Otherwise, return NIL."
+    (cond
+      ((eq *image-dumped-p* :executable) ; yes, this ARGV0 is our argv0 !
+       ;; NB: not currently available on ABCL, Corman, Genera, MCL, MKCL
+       (or #+(or allegro clisp clozure cmu gcl lispworks sbcl scl xcl)
+           (first (raw-command-line-arguments))
+           #+ecl (si:argv 0)))
+      (t ;; argv[0] is the name of the interpreter.
+       ;; The wrapper script can export __CL_ARGV0. cl-launch does as of 4.0.1.8.
+       (getenvp "__CL_ARGV0"))))
 
   (defun setup-command-line-arguments ()
@@ -4276 +4327 @@
                           (if-already-restored '(cerror "RUN RESTORE-IMAGE ANYWAY")))
     "From a freshly restarted Lisp image, restore the saved Lisp environment
-by setting appropriate variables, running various hooks, and calling any specified entry point."
+by setting appropriate variables, running various hooks, and calling any specified entry point.
+
+If the image has already been restored or is already being restored, as per *IMAGE-RESTORED-P*,
+call the IF-ALREADY-RESTORED error handler (by default, a continuable error), and do return
+immediately to the surrounding restore process if allowed to continue.
+
+Then, comes the restore process itself:
+First, call each function in the RESTORE-HOOK,
+in the order they were registered with REGISTER-RESTORE-HOOK.
+Second, evaluate the prelude, which is often Lisp text that is read,
+as per EVAL-INPUT.
+Third, call the ENTRY-POINT function, if any is specified, with no argument.
+
+The restore process happens in a WITH-FATAL-CONDITION-HANDLER, so that if LISP-INTERACTION is NIL,
+any unhandled error leads to a backtrace and an exit with an error status.
+If LISP-INTERACTION is NIL, the process also exits when no error occurs:
+if neither restart nor entry function is provided, the program will exit with status 0 (success);
+if a function was provided, the program will exit after the function returns (if it returns),
+with status 0 if and only if the primary return value of result is generalized boolean true,
+and with status 1 if this value is NIL.
+
+If LISP-INTERACTION is true, unhandled errors will take you to the debugger, and the result
+of the function will be returned rather than interpreted as a boolean designating an exit code."
     (when *image-restored-p*
       (if if-already-restored
@@ -4308 +4381 @@
                                 #+sbcl compression
                                 #+(and sbcl windows) application-type)
-    "Dump an image of the current Lisp environment at pathname FILENAME, with various options"
+    "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.
+
+If EXECUTABLE is true, create an standalone executable program that calls RESTORE-IMAGE on startup.
+
+Pass various implementation-defined options, such as PREPEND-SYMBOLS and PURITY on CCL,
+or COMPRESSION on SBCL, and APPLICATION-TYPE on SBCL/Windows."
     ;; Note: at least SBCL saves only global values of variables in the heap image,
     ;; so make sure things you want to dump are NOT just local bindings shadowing the global values.
@@ -4392 +4473 @@
     #-ecl (error "~S not implemented for your implementation (yet)" 'create-image)
     #+ecl
-    (progn
-      (check-type kind (member :binary :dll :lib :static-library :program :object :fasl :program))
+    (let ((epilogue-forms
+            (append
+             (when epilogue-code `(,epilogue-code))
+             (when postludep `((setf *image-postlude* ',postlude)))
+             (when preludep `((setf *image-prelude* ',prelude)))
+             (when entry-point-p `((setf *image-entry-point* ',entry-point)))
+             (case kind
+               ((:image)
+                (setf kind :program) ;; to ECL, it's just another program.
+                `((setf *image-dumped-p* t)
+                  ;; fall through should be equivalent to: (si::top-level t) (quit)
+                  ))
+               ((:program)
+                `((setf *image-dumped-p* :executable)
+                  (shell-boolean-exit
+                   (restore-image))))))))
+      (check-type kind (member :dll :lib :static-library :program :object :fasl :program))
       (apply 'c::builder
              kind (pathname destination)
@@ -4399 +4495 @@
              :init-name (c::compute-init-name (or output-name destination) :kind kind)
              :prologue-code prologue-code
-             :epilogue-code
-             `(progn
-                ,epilogue-code
-                ,@(when (eq kind :program)
-                    `((setf *image-dumped-p* :executable)
-                      (restore-image ;; default behavior would be (si::top-level)
-                       ,@(when preludep `(:prelude ',prelude))
-                       ,@(when entry-point-p `(:entry-point ',entry-point))))))
+             :epilogue-code (when epilogue-forms `(progn ,@epilogue-forms))
              build-args))))
 
@@ -4422 +4511 @@
   (:nicknames :asdf/run-program)
   (:recycle :uiop/run-program :asdf/run-program :xcvb-driver)
-  (:use :uiop/common-lisp :uiop/utility :uiop/pathname :uiop/os :uiop/filesystem :uiop/stream)
+  (:use :uiop/common-lisp :uiop/package :uiop/utility
+   :uiop/pathname :uiop/os :uiop/filesystem :uiop/stream)
   (:export
    ;;; Escaping the command invocation madness
@@ -4828 +4918 @@
     (declare (ignorable if-input-does-not-exist if-output-exists if-error-output-exists))
     (assert (not (and wait (member :stream (list input output error-output)))))
-    #-(or allegro clozure cmu (and lispworks os-unix) sbcl scl)
+    #-(or allegro clisp clozure cmu (and lispworks os-unix) sbcl scl)
     (progn command keys directory
            (error "run-program not available"))
@@ -4853 +4943 @@
              (with-current-directory (#-sbcl directory)
                #+clisp
-               (flet ((run (f &rest args)
+               (flet ((run (f x &rest args)
                         (multiple-value-list
-                         (apply f :input %input :output %output
-                                  :allow-other-keys t `(,@args ,@keys)))))
+                         (apply f x :input %input :output %output
+                                    :allow-other-keys t `(,@args ,@keys)))))
                  (assert (eq %error-output :terminal))
                  ;;; since we now always return a code, we can't use this code path, anyway!
@@ -5176 +5266 @@
          (append
           before (redirect in " <") (redirect out " >") (redirect err " 2>")
-          (when (and directory (os-unix-p))
+          (when (and directory (os-unix-p)) ;; NB: unless on Unix, %system uses with-current-directory
             `(" ; cd " ,(escape-shell-token (native-namestring directory))))
           after)))))
@@ -5187 +5277 @@
     (%wait-process-result
      (apply '%run-program (%normalize-system-command command) :wait t keys))
-    #+(or abcl clisp cormanlisp ecl gcl (and lispworks os-windows) mkcl xcl)
+    #+(or abcl cormanlisp clisp ecl gcl (and lispworks os-windows) mkcl xcl)
     (let ((%command (%redirected-system-command command input output error-output directory)))
       #+(and lispworks os-windows)
       (system:call-system %command :current-directory directory :wait t)
-      #-(and lispworks os-windows)
+      #+clisp
+      (%wait-process-result
+       (apply '%run-program %command :wait t
+              :input :interactive :output :interactive :error-output :interactive keys))
+      #-(or clisp (and lispworks os-windows))
       (with-current-directory ((unless (os-unix-p) directory))
         #+abcl (ext:run-shell-command %command)
-        #+clisp (clisp-exit-code (ext:shell %command))
         #+cormanlisp (win32:system %command)
         #+ecl (let ((*standard-input* *stdin*)
@@ -6481 +6574 @@
   (defvar *post-upgrade-cleanup-hook* ())
   (defvar *post-upgrade-restart-hook* ())
-  (defun upgrading-p ()
-    (and *previous-asdf-versions* (not (equal *asdf-version* (first *previous-asdf-versions*)))))
-  (defmacro when-upgrading ((&key (upgrading-p '(upgrading-p)) when) &body body)
+  (defun upgrading-p (&optional (oldest-compatible-version *oldest-forward-compatible-asdf-version*))
+    (and *previous-asdf-versions*
+         (version< (first *previous-asdf-versions*) oldest-compatible-version)))
+  (defmacro when-upgrading ((&key (version *oldest-forward-compatible-asdf-version*)
+                               (upgrading-p `(upgrading-p ,version)) when) &body body)
     "A wrapper macro for code that should only be run when upgrading a
 previously-loaded version of ASDF."
@@ -6499 +6594 @@
          ;; "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.1.0.65")
+         (asdf-version "3.1.0.94")
          (existing-version (asdf-version)))
     (setf *asdf-version* asdf-version)
@@ -6511 +6606 @@
 (when-upgrading ()
   (let ((redefined-functions ;; gf signature and/or semantics changed incompatibly. Oops.
+    ;; NB: it's too late to do anything about functions in UIOP!
+    ;; If you introduce some critically incompatibility there, you must change name.
           '(#:component-relative-pathname #:component-parent-pathname ;; component
             #:source-file-type
             #:find-system #:system-source-file #:system-relative-pathname ;; system
-             #:find-component ;; find-component
-             #:explain #:perform #:perform-with-restarts #:input-files #:output-files ;; action
-             #:component-depends-on #:operation-done-p #:component-depends-on
-             #:traverse ;; backward-interface
-             #:operate  ;; operate
-             #:parse-component-form ;; defsystem
-             #:apply-output-translations ;; output-translations
-             #:process-output-translations-directive
-             #:inherit-source-registry #:process-source-registry ;; source-registry
-             #:process-source-registry-directive
-             #:trivial-system-p ;; bundle
-             ;; NB: it's too late to do anything about uiop functions!
-             ))
-         (uninterned-symbols
-           '(#:*asdf-revision* #:around #:asdf-method-combination
-             #:split #:make-collector #:do-dep #:do-one-dep
-             #:component-self-dependencies
-             #:resolve-relative-location-component #:resolve-absolute-location-component
-             #:output-files-for-system-and-operation))) ; obsolete ASDF-BINARY-LOCATION function
+      #:find-component ;; find-component
+      #:explain #:perform #:perform-with-restarts #:input-files #:output-files ;; action
+      #:component-depends-on #:operation-done-p #:component-depends-on
+      #:traverse ;; backward-interface
+            #:map-direct-dependencies #:reduce-direct-dependencies #:direct-dependencies ;; plan
+      #:operate  ;; operate
+      #:parse-component-form ;; defsystem
+      #:apply-output-translations ;; output-translations
+      #:process-output-translations-directive
+      #:inherit-source-registry #:process-source-registry ;; source-registry
+      #:process-source-registry-directive
+      #:trivial-system-p)) ;; bundle
+  (redefined-classes
+          ;; redefining the classes causes interim circularities
+    ;; with the old ASDF during upgrade, and many implementations bork
+          '((#:compile-concatenated-source-op (#:operation) ()))))
     (loop :for name :in redefined-functions
           :for sym = (find-symbol* name :asdf nil) :do
@@ -6538 +6632 @@
               ;; On CLISP we seem to be unable to fmakunbound and define a function in the same fasl. Sigh.
               #-clisp (fmakunbound sym)))
-    (loop :with asdf = (find-package :asdf)
-          :for name :in uninterned-symbols
-          :for sym = (find-symbol* name :asdf nil)
-          :for base-pkg = (and sym (symbol-package sym)) :do
-            (when sym
-              (cond
-                ((or (eq base-pkg asdf) (not base-pkg))
-                 (unintern* sym asdf)
-                 (intern* sym asdf))
-                (t
-                 (unintern* sym base-pkg)
-                 (let ((new (intern* sym base-pkg)))
-                   (shadowing-import new asdf))))))))
+    (labels ((asym (x) (multiple-value-bind (s p) (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)))))))
 
 
@@ -6626 +6714 @@
    ;; Internals we'd like to share with the ASDF package, especially for upgrade purposes
    #:name #:version #:description #:long-description #:author #:maintainer #:licence
-   #:components-by-name #:components
-   #:children #:children-by-name #:default-component-class
-   #:author #:maintainer #:licence #:source-file #:defsystem-depends-on
+   #:components-by-name #:components #:children #:children-by-name
+   #:default-component-class #:source-file
+   #:defsystem-depends-on ; This symbol retained for backward compatibility.
    #:sideway-dependencies #:if-feature #:in-order-to #:inline-methods
    #:relative-pathname #:absolute-pathname #:operation-times #:around-compile
@@ -6899 +6987 @@
    #:system-description #:system-long-description
    #:system-author #:system-maintainer #:system-licence #:system-license
-   #:system-defsystem-depends-on
+   #:system-defsystem-depends-on #:system-depends-on #:system-weakly-depends-on
    #:component-build-pathname #:build-pathname
    #:component-entry-point #:entry-point
@@ -6951 +7039 @@
       :initform nil :initarg :entry-point :accessor component-entry-point)
      (source-file :initform nil :initarg :source-file :accessor system-source-file)
-     (defsystem-depends-on :reader system-defsystem-depends-on :initarg :defsystem-depends-on)))
+     (defsystem-depends-on :reader system-defsystem-depends-on :initarg :defsystem-depends-on
+                           :initform nil)
+     ;; these two are specially set in parse-component-form, so have no :INITARGs.
+     (depends-on :reader system-depends-on :initform nil)
+     (weakly-depends-on :reader system-weakly-depends-on :initform nil)))
 
   (defun reset-system (system &rest keys &key &allow-other-keys)
@@ -7082 +7174 @@
    #:sysdef-preloaded-system-search #:register-preloaded-system #:*preloaded-systems*
    #:clear-defined-systems #:*defined-systems*
+   #:*immutable-systems*
    ;; defined in source-registry, but specially mentioned here:
    #:initialize-source-registry #:sysdef-source-registry-search))
@@ -7203 +7296 @@
       (flet ((try (f) (if-let ((x (funcall f name))) (return-from search-for-system-definition x))))
         (try 'find-system-if-being-defined)
+        (try 'sysdef-immutable-system-search)
         (map () #'try *system-definition-search-functions*)
         (try 'sysdef-preloaded-system-search))))
@@ -7406 +7500 @@
              nil))))) ;; only issue the warning the first time, but always return nil
 
+  (defvar *immutable-systems* nil
+    "An hash-set (equal hash-table mapping keys to T) of systems that are immutable,
+i.e. already loaded in memory and not to be refreshed from the filesystem.
+They will be treated specially by find-system, and passed as :force-not argument to make-plan.
+
+If you deliver an image with many systems precompiled, *and* do not want to check the filesystem
+for them every time a user loads an extension, what more risk a problematic upgrade or catastrophic
+downgrade, before you dump an image, use:
+   (setf asdf::*immutable-systems* (uiop:list-to-hash-set (asdf:already-loaded-systems)))")
+
+  (defun sysdef-immutable-system-search (requested)
+    (let ((name (coerce-name requested)))
+      (when (and *immutable-systems* (gethash name *immutable-systems*))
+        (or (cdr (system-registered-p requested))
+            (error 'formatted-system-definition-error
+                   :format-control "Requested system ~A is in the *immutable-systems* set, ~
+but not loaded in memory"
+                   :format-arguments (list name))))))
+
   (defun locate-system (name)
     "Given a system NAME designator, try to locate where to load the system from.
@@ -7449 +7562 @@
             (multiple-value-bind (foundp found-system pathname previous previous-time)
                 (locate-system name)
+              (when (and found-system (eq found-system previous)
+                         (or (gethash name *systems-being-defined*)
+                             (and *immutable-systems* (gethash name *immutable-systems*))))
+                (return found-system))
               (assert (eq foundp (and (or found-system pathname previous) t)))
               (let ((previous-pathname (and previous (system-source-file previous)))
@@ -7614 +7731 @@
 (uiop/package:define-package :asdf/operation
   (:recycle :asdf/operation :asdf/action :asdf) ;; asdf/action for FEATURE pre 2.31.5.
-  (:use :uiop/common-lisp :uiop :asdf/upgrade)
+  (:use :uiop/common-lisp :uiop :asdf/upgrade :asdf/find-system)
   (:export
    #:operation
    #:operation-original-initargs #:original-initargs ;; backward-compatibility only. DO NOT USE.
-   #:*operations* #:make-operation #:find-operation #:feature))
+   #:*operations* #:make-operation #:find-operation
+   #:feature)) ;; TODO: stop exporting the deprecated FEATURE feature.
 (in-package :asdf/operation)
 
@@ -7652 +7770 @@
 
   (defun make-operation (operation-class &rest initargs)
-    (ensure-gethash (cons operation-class initargs) *operations*
-                    (list* 'make-instance operation-class initargs)))
+    (let ((class (coerce-class operation-class
+                               :package :asdf/interface :super 'operation :error 'sysdef-error)))
+      (ensure-gethash (cons class initargs) *operations*
+                      (list* 'make-instance class initargs))))
 
   (defgeneric find-operation (context spec)
@@ -7660 +7780 @@
     spec)
   (defmethod find-operation (context (spec symbol))
-    (unless (member spec '(nil feature))
-      ;; NIL designates itself, i.e. absence of operation
-      ;; FEATURE is the ASDF1 misfeature that comes with IF-COMPONENT-DEP-FAILS
+    (when spec ;; NIL designates itself, i.e. absence of operation
       (apply 'make-operation spec (operation-original-initargs context))))
+  (defmethod find-operation (context (spec string))
+    (apply 'make-operation spec (operation-original-initargs context)))
   (defmethod operation-original-initargs ((context symbol))
     (declare (ignorable context))
@@ -7688 +7808 @@
    #:action-path #:find-action #:stamp #:done-p
    #:operation-definition-warning #:operation-definition-error ;; condition
-   #:build-op ;; THE generic operation
    ))
 (in-package :asdf/action)
@@ -7727 +7846 @@
            (opix (position operation formals))
            (coix (position component formals))
+
            (prefix (subseq formals 0 opix))
            (suffix (subseq formals (1+ coix) len))
@@ -7736 +7856 @@
                    `(,function ,@prefix ,o ,c ,@suffix))))
         `(progn
-           (defmethod ,function (,@prefix (,operation symbol) component ,@suffix ,@more-args)
+           (defmethod ,function (,@prefix (,operation string) ,component ,@suffix ,@more-args)
+             (let ((,component (find-component () ,component))) ;; do it first, for defsystem-depends-on
+               ,(next-method `(safe-read-from-string ,operation :package :asdf/interface) component)))
+           (defmethod ,function (,@prefix (,operation symbol) ,component ,@suffix ,@more-args)
              (if ,operation
                  ,(next-method
@@ -7791 +7914 @@
         a component name or a component object.  Also note that, the degenerate
         case of (<operation>) is a no-op.]
-
-      or
-
-      (FEATURE <feature>), which means that the component depends
-        on the <feature> expression satisfying FEATUREP.
-        (This is DEPRECATED -- use :IF-FEATURE instead.)
 
     Methods specialized on subclasses of existing component types
@@ -7898 +8015 @@
 
   (defmethod initialize-instance :before ((o operation) &key)
-    ;; build-op is a special case.
     (unless (typep o '(or downward-operation upward-operation sideway-operation
                           selfward-operation non-propagating-operation))
@@ -7923 +8039 @@
       ,@(unless (typep o '(or downward-operation upward-operation sideway-operation
                               selfward-operation non-propagating-operation))
-          `(,@(downward-operation-depends-on o c)
-            ,@(sideway-operation-depends-on o c)))))
+          `(,@(sideway-operation-depends-on o c)
+            ,@(when (typep c 'parent-component) (downward-operation-depends-on o c))))))
 
   (defmethod downward-operation ((o operation)) nil)
@@ -8047 +8163 @@
     nil)
   (defmethod perform ((o operation) (c source-file))
-    (sysdef-error
-     (compatfmt "~@<Required method PERFORM not implemented for operation ~A, component ~A~@:>")
-     (class-of o) (class-of c)))
+    ;; For backward compatibility, don't error on operations that don't specify propagation.
+    (when (typep o '(or downward-operation upward-operation sideway-operation
+                     selfward-operation non-propagating-operation))
+      (sysdef-error
+       (compatfmt "~@<Required method ~S not implemented for ~/asdf-action:format-action/~@:>")
+       'perform (cons o c))))
 
   (defmethod perform-with-restarts (operation component)
@@ -8072 +8191 @@
           (mark-operation-done operation component)
           (return))))))
-
-;;; Generic build operation
-(with-upgradability ()
-  ;; BUILD-OP was intended to be the default "master" operation to invoke on a system in ASDF3
-  ;; (LOAD-OP typically serves that function now).
-  ;; This feature has not yet been fully implemented yet, and is not used by anyone yet.
-  ;; This is a path forward, and its default below is to backward compatibly depend on LOAD-OP.
-  ;; [2014/01/26:rpg]
-  (defclass build-op (non-propagating-operation) ())
-  (defmethod component-depends-on ((o build-op) (c component))
-    `((,(or (component-build-operation c) 'load-op) ,c))))
-
 ;;;; -------------------------------------------------------------------------
 ;;;; Actions to build Common Lisp software
@@ -8313 +8420 @@
   (:export
    #:component-operation-time #:mark-operation-done
-   #:plan-traversal #:sequential-plan #:*default-plan-class*
+   #:plan #:plan-traversal #:sequential-plan #:*default-plan-class*
    #:planned-action-status #:plan-action-status #:action-already-done-p
    #:circular-dependency #:circular-dependency-actions
@@ -8321 +8428 @@
    #:normalize-forced-systems #:action-forced-p #:action-forced-not-p
    #:map-direct-dependencies #:reduce-direct-dependencies #:direct-dependencies
-   #:visit-dependencies #:compute-action-stamp #:traverse-action
+   #:compute-action-stamp #:traverse-action
    #:circular-dependency #:circular-dependency-actions
    #:call-while-visiting-action #:while-visiting-action
@@ -8336 +8443 @@
 ;;;; Generic plan traversal class
 (with-upgradability ()
-  (defclass plan-traversal ()
+  (defclass plan () ())
+  (defclass plan-traversal (plan)
     ((system :initform nil :initarg :system :accessor plan-system)
      (forced :initform nil :initarg :force :accessor plan-forced)
@@ -8403 +8511 @@
   (defun normalize-forced-systems (x system)
     (etypecase x
-      ((member nil :all) x)
+      ((or (member nil :all) hash-table function) x)
       (cons (list-to-hash-set (mapcar #'coerce-name x)))
       ((eql t) (when system (list-to-hash-set (list (coerce-name system)))))))
 
+  (defun normalize-forced-not-systems (x system)
+    (let ((requested
+            (etypecase x
+              ((or (member nil :all) hash-table function) x)
+              (cons (list-to-hash-set (mapcar #'coerce-name x)))
+              ((eql t) (if system (let ((name (coerce-name system)))
+                                    #'(lambda (x) (not (equal x name))))
+                           t)))))
+      (if (and *immutable-systems* requested)
+          #'(lambda (x) (or (call-function requested x) (call-function *immutable-systems* x)))
+          (or *immutable-systems* requested))))
+
   (defun action-override-p (plan operation component override-accessor)
     (declare (ignore operation))
-    (let* ((override (funcall override-accessor plan)))
-      (and override
-           (if (typep override 'hash-table)
-               (gethash (coerce-name (component-system (find-component () component))) override)
-               t))))
+    (call-function (funcall override-accessor plan)
+                   (coerce-name (component-system (find-component () component)))))
 
   (defmethod action-forced-p (plan operation component)
@@ -8426 +8543 @@
 
   (defmethod action-forced-not-p (plan operation component)
-    (and
-     ;; Did the user ask us to not re-perform the action?
-     (action-override-p plan operation component 'plan-forced-not)
-     ;; Force takes precedence over force-not
-     (not (action-forced-p plan operation component))))
+    ;; Did the user ask us to not re-perform the action?
+    ;; NB: force-not takes precedence over force, as it should
+    (action-override-p plan operation component 'plan-forced-not))
 
   (defmethod action-forced-p ((plan null) (operation operation) (component component))
@@ -8443 +8558 @@
   (defgeneric action-valid-p (plan operation component)
     (:documentation "Is this action valid to include amongst dependencies?"))
-  (defmethod action-valid-p ((plan plan-traversal) (o operation) (c component))
+  (defmethod action-valid-p ((plan t) (o operation) (c component))
     (if-let (it (component-if-feature c)) (featurep it) t))
   (defmethod action-valid-p ((plan t) (o null) (c t)) nil)
   (defmethod action-valid-p ((plan t) (o t) (c null)) nil)
   (defmethod action-valid-p ((plan null) (o operation) (c component)) t))
-
 
 ;;;; Is the action needed in this image?
@@ -8466 +8580 @@
 ;;;; Visiting dependencies of an action and computing action stamps
 (with-upgradability ()
-  (defun map-direct-dependencies (operation component fun)
+  (defun (map-direct-dependencies) (plan operation component fun)
     (loop* :for (dep-o-spec . dep-c-specs) :in (component-depends-on operation component)
            :for dep-o = (find-operation operation dep-o-spec)
@@ -8472 +8586 @@
            :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 dep-c
+                     :when (and dep-c (action-valid-p plan dep-o dep-c))
                        :do (funcall fun dep-o dep-c))))
 
-  (defun reduce-direct-dependencies (operation component combinator seed)
+  (defun (reduce-direct-dependencies) (plan operation component combinator seed)
     (map-direct-dependencies
-     operation component
+     plan operation component
      #'(lambda (dep-o dep-c)
          (setf seed (funcall combinator dep-o dep-c seed))))
     seed)
 
-  (defun direct-dependencies (operation component)
-    (reduce-direct-dependencies operation component #'acons nil))
+  (defun (direct-dependencies) (plan operation component)
+    (reduce-direct-dependencies plan operation component #'acons nil))
 
   ;; In a distant future, get-file-stamp, component-operation-time and latest-stamp
@@ -8489 +8603 @@
   ;; so they need not refer to the state of the filesystem,
   ;; and the stamps could be cryptographic checksums rather than timestamps.
-  ;; Such a change remarkably would only affect VISIT-DEPENDENCIES and COMPUTE-ACTION-STAMP.
-
-  (defun visit-dependencies (plan operation component dependency-stamper &aux stamp)
-    (map-direct-dependencies
-     operation component
-     #'(lambda (dep-o dep-c)
-         (when (action-valid-p plan dep-o dep-c)
-           (latest-stamp-f stamp (funcall dependency-stamper dep-o dep-c)))))
-    stamp)
+  ;; Such a change remarkably would only affect COMPUTE-ACTION-STAMP.
 
   (defmethod compute-action-stamp (plan (o operation) (c component) &key just-done)
@@ -8510 +8616 @@
     ;; hasn't been done in the current image yet, then it can have a non-T timestamp,
     ;; yet a NIL done-in-image-p flag.
-    (let* ((stamp-lookup #'(lambda (o c)
-                             (if-let (it (plan-action-status plan o c)) (action-stamp it) t)))
-           (out-files (output-files o c))
-           (in-files (input-files o c))
-           ;; Three kinds of actions:
-           (out-op (and out-files t)) ; those that create files on the filesystem
-           ;;(image-op (and in-files (null out-files))) ; those that load stuff into the image
-           ;;(null-op (and (null out-files) (null in-files))) ; placeholders that do nothing
-           ;; When was the thing last actually done? (Now, or ask.)
-           (op-time (or just-done (component-operation-time o c)))
-           ;; Accumulated timestamp from dependencies (or T if forced or out-of-date)
-           (dep-stamp (visit-dependencies plan o c stamp-lookup))
-           ;; Time stamps from the files at hand, and whether any is missing
-           (out-stamps (mapcar (if just-done 'register-file-stamp 'get-file-stamp) out-files))
-           (in-stamps (mapcar #'get-file-stamp in-files))
-           (missing-in
-             (loop :for f :in in-files :for s :in in-stamps :unless s :collect f))
-           (missing-out
-             (loop :for f :in out-files :for s :in out-stamps :unless s :collect f))
-           (all-present (not (or missing-in missing-out)))
-           ;; Has any input changed since we last generated the files?
-           (earliest-out (stamps-earliest out-stamps))
-           (latest-in (stamps-latest (cons dep-stamp in-stamps)))
-           (up-to-date-p (stamp<= latest-in earliest-out))
-           ;; If everything is up to date, the latest of inputs and outputs is our stamp
-           (done-stamp (stamps-latest (cons latest-in out-stamps))))
-      ;; Warn if some files are missing:
-      ;; either our model is wrong or some other process is messing with our files.
-      (when (and just-done (not all-present))
-        (warn "~A completed without ~:[~*~;~*its input file~:p~2:*~{ ~S~}~*~]~
-             ~:[~; or ~]~:[~*~;~*its output file~:p~2:*~{ ~S~}~*~]"
-              (action-description o c)
-              missing-in (length missing-in) (and missing-in missing-out)
-              missing-out (length missing-out)))
-      ;; Note that we use stamp<= instead of stamp< to play nice with generated files.
-      ;; Any race condition is intrinsic to the limited timestamp resolution.
-      (if (or just-done ;; The done-stamp is valid: if we're just done, or
-              ;; if all filesystem effects are up-to-date and there's no invalidating reason.
-              (and all-present up-to-date-p (operation-done-p o c) (not (action-forced-p plan o c))))
-          (values done-stamp ;; return the hard-earned timestamp
-                  (or just-done
-                      out-op ;; a file-creating op is done when all files are up to date
-                      ;; a image-effecting a placeholder op is done when it was actually run,
-                      (and op-time (eql op-time done-stamp)))) ;; with the matching stamp
-          ;; done-stamp invalid: return a timestamp in an indefinite future, action not done yet
-          (values t nil)))))
+    (nest
+     (block ())
+     (let ((dep-stamp ; collect timestamp from dependencies (or T if forced or out-of-date)
+             (reduce-direct-dependencies
+              plan o c
+              #'(lambda (o c stamp)
+                  (if-let (it (plan-action-status plan o c))
+                    (latest-stamp stamp (action-stamp it))
+                    t))
+              nil)))
+       ;; out-of-date dependency: don't bother expensively querying the filesystem
+       (when (and (eq dep-stamp t) (not just-done)) (return (values t nil))))
+     ;; collect timestamps from inputs, and exit early if any is missing
+     (let* ((in-files (input-files o c))
+            (in-stamps (mapcar #'get-file-stamp in-files))
+            (missing-in (loop :for f :in in-files :for s :in in-stamps :unless s :collect f))
+            (latest-in (stamps-latest (cons dep-stamp in-stamps))))
+       (when (and missing-in (not just-done)) (return (values t nil))))
+     ;; collect timestamps from outputs, and exit early if any is missing
+     (let* ((out-files (output-files o c))
+            (out-stamps (mapcar (if just-done 'register-file-stamp 'get-file-stamp) out-files))
+            (missing-out (loop :for f :in out-files :for s :in out-stamps :unless s :collect f))
+            (earliest-out (stamps-earliest out-stamps)))
+       (when (and missing-out (not just-done)) (return (values t nil))))
+     (let* (;; There are three kinds of actions:
+            (out-op (and out-files t)) ; those that create files on the filesystem
+            ;;(image-op (and in-files (null out-files))) ; those that load stuff into the image
+            ;;(null-op (and (null out-files) (null in-files))) ; placeholders that do nothing
+            ;; When was the thing last actually done? (Now, or ask.)
+            (op-time (or just-done (component-operation-time o c)))
+            ;; Time stamps from the files at hand, and whether any is missing
+            (all-present (not (or missing-in missing-out)))
+            ;; Has any input changed since we last generated the files?
+            (up-to-date-p (stamp<= latest-in earliest-out))
+            ;; If everything is up to date, the latest of inputs and outputs is our stamp
+            (done-stamp (stamps-latest (cons latest-in out-stamps))))
+       ;; Warn if some files are missing:
+       ;; either our model is wrong or some other process is messing with our files.
+       (when (and just-done (not all-present))
+         (warn "~A completed without ~:[~*~;~*its input file~:p~2:*~{ ~S~}~*~]~
+                ~:[~; or ~]~:[~*~;~*its output file~:p~2:*~{ ~S~}~*~]"
+               (action-description o c)
+               missing-in (length missing-in) (and missing-in missing-out)
+               missing-out (length missing-out))))
+     ;; Note that we use stamp<= instead of stamp< to play nice with generated files.
+     ;; Any race condition is intrinsic to the limited timestamp resolution.
+     (if (or just-done ;; The done-stamp is valid: if we're just done, or
+             ;; if all filesystem effects are up-to-date and there's no invalidating reason.
+             (and all-present up-to-date-p (operation-done-p o c) (not (action-forced-p plan o c))))
+         (values done-stamp ;; return the hard-earned timestamp
+                 (or just-done
+                     out-op ;; a file-creating op is done when all files are up to date
+                     ;; a image-effecting a placeholder op is done when it was actually run,
+                     (and op-time (eql op-time done-stamp)))) ;; with the matching stamp
+         ;; done-stamp invalid: return a timestamp in an indefinite future, action not done yet
+         (values t nil)))))
 
 
@@ -8566 +8682 @@
 
   (defmethod initialize-instance :after ((plan plan-traversal)
-                                         &key (force () fp) (force-not () fnp) system
+                                         &key force force-not system
                                          &allow-other-keys)
     (with-slots (forced forced-not) plan
-      (when fp (setf forced (normalize-forced-systems force system)))
-      (when fnp (setf forced-not (normalize-forced-systems force-not system)))))
+      (setf forced (normalize-forced-systems force system))
+      (setf forced-not (normalize-forced-not-systems force-not system))))
 
   (defmethod (setf plan-action-status) (new-status (plan plan-traversal) (o operation) (c component))
@@ -8642 +8758 @@
           (return (action-stamp status))) ; Already visited with sufficient need-in-image level!
         (labels ((visit-action (niip) ; We may visit the action twice, once with niip NIL, then T
-                   (visit-dependencies plan operation component ; recursively traverse dependencies
-                                       #'(lambda (o c) (traverse-action plan o c niip)))
+                   (map-direct-dependencies ; recursively traverse dependencies
+                    plan operation component #'(lambda (o c) (traverse-action plan o c niip)))
                    (multiple-value-bind (stamp done-p) ; AFTER dependencies have been traversed,
                        (compute-action-stamp plan operation component) ; compute action stamp
@@ -8688 +8804 @@
       (push (cons o c) (plan-actions-r p)))))
 
-
-;;;; high-level interface: traverse, perform-plan, plan-operates-on-p
+;;;; High-level interface: traverse, perform-plan, plan-operates-on-p
 (with-upgradability ()
   (defgeneric make-plan (plan-class operation component &key &allow-other-keys)
@@ -8702 +8817 @@
 
   (defmethod make-plan (plan-class (o operation) (c component) &rest keys &key &allow-other-keys)
-    (let ((plan (apply 'make-instance
-                       (or plan-class *default-plan-class*)
+    (let ((plan (apply 'make-instance (or plan-class *default-plan-class*)
                        :system (component-system c) keys)))
       (traverse-action plan o c t)
@@ -8709 +8823 @@
 
   (defmethod perform-plan :around ((plan t) &key)
+    #+xcl (declare (ignorable plan))
     (let ((*package* *package*)
           (*readtable* *readtable*))
@@ -8742 +8857 @@
 
   (defmethod initialize-instance :after ((plan filtered-sequential-plan)
-                                         &key (force () fp) (force-not () fnp)
+                                         &key force force-not
                                            other-systems)
     (declare (ignore force force-not))
     (with-slots (forced forced-not action-filter system) plan
-      (unless fp (setf forced (normalize-forced-systems (if other-systems :all t) system)))
-      (unless fnp (setf forced-not (normalize-forced-systems (if other-systems nil :all) system)))
+      (setf forced (normalize-forced-systems (if other-systems :all t) system))
+      (setf forced-not (normalize-forced-not-systems (if other-systems nil t) system))
       (setf action-filter (ensure-function action-filter))))
 
@@ -8761 +8876 @@
 
   (define-convenience-action-methods traverse-sub-actions (operation component &key))
-  (defmethod traverse-sub-actions ((operation operation) (component component) &rest keys &key &allow-other-keys)
-    (apply 'traverse-actions (direct-dependencies operation component)
+  (defmethod traverse-sub-actions ((operation operation) (component component)
+                                   &rest keys &key &allow-other-keys)
+    (apply 'traverse-actions (direct-dependencies t operation component)
            :system (component-system component) keys))
 
@@ -8789 +8905 @@
    #:operate #:oos
    #:*systems-being-operated*
-   #:build-system
+   #:build-op #:build
    #:load-system #:load-systems #:load-systems*
    #:compile-system #:test-system #:require-system
@@ -8835 +8951 @@
     (let* ((systems-being-operated *systems-being-operated*)
            (*systems-being-operated* (or systems-being-operated (make-hash-table :test 'equal)))
-           (operation-name (reify-symbol (etypecase operation
-                                           (operation (type-of operation))
-                                           (symbol operation))))
-           (component-path (typecase component
+           (operation-remaker ;; how to remake the operation after ASDF was upgraded (if it was)
+             (etypecase operation
+               (operation (let ((name (type-of operation))
+                                (initargs (operation-original-initargs operation)))
+                            #'(lambda () (make-operation name :original-initargs initargs initargs))))
+               ((or symbol string) (constantly operation))))
+           (component-path (typecase component ;; to remake the component after ASDF upgrade
                              (component (component-find-path component))
                              (t component))))
@@ -8848 +8967 @@
           ;; its function may have been redefined, its symbol uninterned, its package deleted.
           (return-from operate
-            (apply (find-symbol* 'operate :asdf)
-                   (unreify-symbol operation-name)
-                   component-path keys))))
+            (apply 'operate (funcall operation-remaker) component-path keys))))
       ;; Setup proper bindings around any operate call.
       (with-system-definitions ()
@@ -8883 +9000 @@
   (defvar *load-system-operation* 'load-op
     "Operation used by ASDF:LOAD-SYSTEM. By default, ASDF:LOAD-OP.
-You may override it with e.g. ASDF:LOAD-FASL-OP from asdf-bundle,
+You may override it with e.g. ASDF:LOAD-FASL-OP from asdf-bundle
 or ASDF:LOAD-SOURCE-OP if your fasl loading is somehow broken.
 
-This may change in the future as we will implement component-based strategy
-for how to load or compile stuff")
-
-  (defun build-system (system &rest keys)
-    "Shorthand for `(operate 'asdf:build-op system)`."
+The default operation may change in the future if we implement a
+component-directed strategy for how to load or compile systems.")
+
+  (defclass build-op (non-propagating-operation) ()
+    (:documentation "Since ASDF3, BUILD-OP is the recommended 'master' operation,
+to operate by default on a system or component, via the function BUILD.
+Its meaning is configurable via the :BUILD-OPERATION option of a component.
+which typically specifies the name of a specific operation to which to delegate the build,
+as a symbol or as a string later read as a symbol (after loading the defsystem-depends-on);
+if NIL is specified (the default), BUILD-OP falls back to the *LOAD-SYSTEM-OPERATION*
+that will load the system in the current image, and its typically LOAD-OP."))
+  (defmethod component-depends-on ((o build-op) (c component))
+    `((,(or (component-build-operation c) *load-system-operation*) ,c)))
+
+  (defun build (system &rest keys)
+    "The recommended way to interact with ASDF3.1 is via (ASDF:BUILD :FOO).
+It will build system FOO using the operation BUILD-OP,
+the meaning of which is configurable by the system, and
+defaults to *LOAD-SYSTEM-OPERATION*, usually LOAD-OP,
+to load it in current image."
     (apply 'operate 'build-op system keys)
     t)
@@ -8936 +9068 @@
 
   (defclass require-system (system)
-    ((module :initarg :module :initform nil :accessor required-module)))
+    ((module :initarg :module :initform nil :accessor required-module))
+    (:documentation "A SYSTEM subclass whose processing is handled by
+the implementation's REQUIRE rather than by internal ASDF mechanisms."))
 
   (defmethod perform ((o compile-op) (c require-system))
@@ -9628 +9762 @@
    #:load-sysdef #:make-temporary-package
    #:%refresh-component-inline-methods
-   #:%resolve-if-component-dep-fails
    #:make-sub-operation
    #:load-sysdef #:make-temporary-package))
@@ -9668 +9801 @@
     (%define-component-inline-methods component rest)))
 
-;;;; PARTIAL SUPPORT for the :if-component-dep-fails component attribute
-;; and the companion asdf:feature pseudo-dependency.
-;; This won't recurse into dependencies to accumulate feature conditions.
-;; Therefore it will accept the SB-ROTATE-BYTE of an old SBCL
-;; (older than 1.1.2.20-fe6da9f) but won't suffice to load an old nibbles.
-(with-upgradability ()
-  (defun %resolve-if-component-dep-fails (if-component-dep-fails component)
-    (asdf-message "The system definition for ~S uses deprecated ~
-                 ASDF option :IF-COMPONENT-DEP-DAILS. ~
-                 Starting with ASDF 3, please use :IF-FEATURE instead"
-                  (coerce-name (component-system component)))
-    ;; This only supports the pattern of use of the "feature" seen in the wild
-    (check-type component parent-component)
-    (check-type if-component-dep-fails (member :fail :ignore :try-next))
-    (unless (eq if-component-dep-fails :fail)
-      (loop :with o = (make-operation 'compile-op)
-            :for c :in (component-children component) :do
-              (loop* :for (feature? feature) :in (component-depends-on o c)
-                     :when (eq feature? 'feature) :do
-                     (setf (component-if-feature c) feature))))))
-
 (when-upgrading (:when (fboundp 'make-sub-operation))
   (defun make-sub-operation (c o dep-c dep-o)
@@ -9700 +9812 @@
 
   (defun make-temporary-package ()
-    ;; For loading a .asd file, we dont't make a temporary package anymore,
+    ;; For loading a .asd file, we don't make a temporary package anymore,
     ;; but use ASDF-USER. I'd like to have this function do this,
     ;; but since whoever uses it is likely to delete-package the result afterwards,
@@ -9717 +9829 @@
    :asdf/find-system :asdf/find-component :asdf/lisp-action :asdf/operate
    :asdf/backward-internals)
+  (:import-from :asdf/system #:depends-on #:weakly-depends-on)
   (:export
    #:defsystem #:register-system-definition
@@ -9756 +9869 @@
 
   (defun class-for-type (parent type)
-    (or (loop :for symbol :in (list
-                               type
-                               (find-symbol* type *package* nil)
-                               (find-symbol* type :asdf/interface nil)
-                               (and (stringp type) (safe-read-from-string type :package :asdf/interface)))
-              :for class = (and symbol (symbolp symbol) (find-class* symbol nil))
-              :when (and class
-                         (#-cormanlisp subtypep #+cormanlisp cl::subclassp
-                          class (find-class* 'component)))
-                :return class)
-        (and (eq type :file)
-             (find-class*
-              (or (loop :for p = parent :then (component-parent p) :while p
-                        :thereis (module-default-component-class p))
-                  *default-component-class*) nil))
-        (sysdef-error "don't recognize component type ~A" 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))))
 
 
@@ -9812 +9917 @@
                      form component parent pathname continuation))
              (invalid-parse (control &rest args)
-               (unless (builtin-system-p (find-component parent component))
+               (unless (if-let (target (find-component parent component)) (builtin-system-p target))
                  (apply 'warn control args)
                  (invalid))))
@@ -9841 +9946 @@
 ;;; Main parsing function
 (with-upgradability ()
+  (defun* parse-dependency-def (dd)
+    (if (listp dd)
+        (case (first dd)
+          (:feature
+           (unless (= (length dd) 3)
+             (sysdef-error "Ill-formed feature dependency: ~s" dd))
+           (let ((embedded (parse-dependency-def (third dd))))
+             `(:feature ,(second dd) ,embedded)))
+          (feature
+           (sysdef-error "`feature' has been removed from the dependency spec language of ASDF. Use :feature instead in ~s." dd))
+          (:require
+           (unless (= (length dd) 2)
+             (sysdef-error "Ill-formed require dependency: ~s" dd))
+           dd)
+          (:version
+           (unless (= (length dd) 3)
+             (sysdef-error "Ill-formed version dependency: ~s" dd))
+           `(:version ,(coerce-name (second dd)) ,(third dd)))
+          (otherwise (sysdef-error "Ill-formed dependency: ~s" dd)))
+      (coerce-name dd)))
+
+  (defun* parse-dependency-defs (dd-list)
+    "Parse the dependency defs in DD-LIST into canonical form by translating all
+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)
     (destructuring-bind
@@ -9878 +10009 @@
             (setf component (apply 'make-instance class args)))
         (component-pathname component) ; eagerly compute the absolute pathname
+        (when (typep component 'system)
+          ;; cache information for introspection
+          (setf (slot-value component 'depends-on)
+                (parse-dependency-defs depends-on)
+                (slot-value component 'weakly-depends-on)
+                ;; these must be a list of systems, cannot be features or versioned systems
+                (mapcar 'coerce-name weakly-depends-on)))
         (let ((sysfile (system-source-file (component-system component)))) ;; requires the previous
           (when (and (typep component 'system) (not bspp))
@@ -9906 +10044 @@
         (%refresh-component-inline-methods component rest)
         (when if-component-dep-fails
-          (%resolve-if-component-dep-fails if-component-dep-fails component))
+          (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))))
         component)))
 
@@ -9928 +10069 @@
              (system (reset-system (cdr registered!)
                                    :name name :source-file source-file))
-             (component-options (remove-plist-key :class options))
+             (component-options
+              (remove-plist-keys '(:defsystem-depends-on :class) options))
              (defsystem-dependencies (loop :for spec :in defsystem-depends-on :collect
                                            (resolve-dependency-spec nil spec))))
+        ;; cache defsystem-depends-on in canonical form
+        (when defsystem-depends-on
+          (setf component-options
+                (append `(:defsystem-depends-on ,(parse-dependency-defs defsystem-depends-on))
+                        component-options)))
         (setf (gethash name *systems-being-defined*) system)
         (load-systems* defsystem-dependencies)
@@ -9963 +10110 @@
    #:lib-op #:monolithic-lib-op
    #:dll-op #:monolithic-dll-op
-   #:binary-op #:monolithic-binary-op
-   #:program-op #:compiled-file #:precompiled-system #:prebuilt-system
+   #:deliver-asd-op #:monolithic-deliver-asd-op
+   #:program-op #:image-op #:compiled-file #:precompiled-system #:prebuilt-system
    #:user-system-p #:user-system #:trivial-system-p
    #+ecl #:make-build
@@ -9972 +10119 @@
 
 (with-upgradability ()
-  (defclass bundle-op (operation)
+  (defclass bundle-op (basic-compile-op)
     ((build-args :initarg :args :initform nil :accessor bundle-op-build-args)
      (name-suffix :initarg :name-suffix :initform nil)
@@ -9980 +10127 @@
      #+mkcl (do-static-library :initarg :do-static-library :initform t :reader bundle-op-do-static-library-p)))
 
-  (defclass bundle-compile-op (bundle-op basic-compile-op)
-    ()
-    (:documentation "Abstract operation for ways to bundle the outputs of compiling *Lisp* files"))
-
-  ;; create a single fasl for the entire library
-  (defclass basic-fasl-op (bundle-compile-op)
-    ((bundle-type :initform :fasl)))
-  (defclass prepare-fasl-op (sideway-operation)
-    ((sideway-operation :initform 'load-fasl-op :allocation :class)))
-  (defclass fasl-op (basic-fasl-op selfward-operation)
-    ((selfward-operation :initform '(prepare-fasl-op #+ecl lib-op) :allocation :class)))
-  (defclass load-fasl-op (basic-load-op selfward-operation)
-    ((selfward-operation :initform '(prepare-op fasl-op) :allocation :class)))
-
-  ;; NB: since the monolithic-op's can't be sideway-operation's,
-  ;; if we wanted lib-op, dll-op, binary-op to be sideway-operation's,
-  ;; we'd have to have the monolithic-op not inherit from the main op,
-  ;; but instead inherit from a basic-FOO-op as with basic-fasl-op above.
-
-  (defclass no-ld-flags-op (operation) ())
-
-  (defclass lib-op (bundle-compile-op no-ld-flags-op non-propagating-operation)
-    ((bundle-type :initform #+(or ecl mkcl) :lib #-(or ecl mkcl) :no-output-file))
-    (:documentation #+(or ecl mkcl) "compile the system and produce linkable (.a) library for it."
-     #-(or ecl mkcl) "just compile the system"))
-
-  (defclass dll-op (bundle-compile-op no-ld-flags-op non-propagating-operation)
-    ((bundle-type :initform :dll))
-    (:documentation "compile the system and produce dynamic (.so/.dll) library for it."))
-
-  (defclass binary-op (basic-compile-op selfward-operation)
-    ((selfward-operation :initform '(fasl-op lib-op) :allocation :class))
-    (:documentation "produce fasl and asd files for the system"))
-
   (defclass monolithic-op (operation) ()
     (:documentation "A MONOLITHIC operation operates on a system *and all of its
@@ -10022 +10135 @@
 
   (defclass monolithic-bundle-op (monolithic-op bundle-op)
-    ((prologue-code :accessor monolithic-op-prologue-code)
-     (epilogue-code :accessor monolithic-op-epilogue-code)))
-
-  (defclass monolithic-bundle-compile-op (monolithic-bundle-op bundle-compile-op)
-    ()
-    (:documentation "Abstract operation for ways to bundle the outputs of compiling
-*Lisp* files over a system, and all of its dependencies."))
-
-  (defclass monolithic-binary-op (monolithic-op binary-op)
-    ((selfward-operation :initform '(monolithic-fasl-op monolithic-lib-op) :allocation :class))
+    ;; Old style way of specifying prologue and epilogue on ECL: in the monolithic operation
+    ((prologue-code :accessor prologue-code)
+     (epilogue-code :accessor epilogue-code)))
+
+  (defclass bundle-system (system)
+    ;; New style (ASDF3.1) way of specifying prologue and epilogue on ECL: in the system
+    ((prologue-code :accessor prologue-code)
+     (epilogue-code :accessor epilogue-code)))
+
+  (defmethod prologue-code ((x t)) nil)
+  (defmethod epilogue-code ((x t)) nil)
+
+  (defclass link-op (bundle-op) ()
+    (:documentation "Abstract operation for linking files together"))
+
+  (defclass gather-op (bundle-op)
+    ((gather-op :initform nil :allocation :class :reader gather-op))
+    (:documentation "Abstract operation for gathering many input files from a system"))
+
+  (defun operation-monolithic-p (op)
+    (typep op 'monolithic-op))
+
+  (defmethod component-depends-on ((o gather-op) (s system))
+    (let* ((mono (operation-monolithic-p o))
+           (deps
+             (required-components
+              s :other-systems mono :component-type (if mono 'system '(not system))
+                :goal-operation (find-operation o 'load-op)
+                :keep-operation 'compile-op)))
+      ;; NB: the explicit make-operation on ECL and MKCL
+      ;; ensures that we drop the original-initargs and its magic flags when recursing.
+      `((,(make-operation (or (gather-op o) (if mono 'lib-op 'compile-op))) ,@deps)
+        ,@(call-next-method))))
+
+  ;; create a single fasl for the entire library
+  (defclass basic-fasl-op (bundle-op)
+    ((bundle-type :initform :fasl)))
+
+  (defclass prepare-fasl-op (sideway-operation)
+    ((sideway-operation :initform #+ecl 'load-fasl-op #-ecl 'load-op :allocation :class)))
+
+  (defclass lib-op (link-op gather-op non-propagating-operation)
+    ((bundle-type :initform :lib))
+    (:documentation "compile the system and produce linkable (.a) library for it."))
+
+  (defclass fasl-op (basic-fasl-op selfward-operation #+ecl link-op #-ecl gather-op)
+    ((selfward-operation :initform '(prepare-fasl-op #+ecl lib-op) :allocation :class)))
+
+  (defclass load-fasl-op (basic-load-op selfward-operation)
+    ((selfward-operation :initform '(prepare-op fasl-op) :allocation :class)))
+
+  ;; NB: since the monolithic-op's can't be sideway-operation's,
+  ;; if we wanted lib-op, dll-op, deliver-asd-op to be sideway-operation's,
+  ;; we'd have to have the monolithic-op not inherit from the main op,
+  ;; but instead inherit from a basic-FOO-op as with basic-fasl-op above.
+
+  (defclass dll-op (link-op gather-op non-propagating-operation)
+    ((bundle-type :initform :dll))
+    (:documentation "compile the system and produce dynamic (.so/.dll) library for it."))
+
+  (defclass deliver-asd-op (basic-compile-op selfward-operation)
+    ((selfward-operation :initform '(fasl-op #+(or ecl mkcl) lib-op) :allocation :class))
+    (:documentation "produce an asd file for delivering the system as a single fasl"))
+
+
+  (defclass monolithic-deliver-asd-op (monolithic-bundle-op deliver-asd-op)
+    ((selfward-operation :initform '(monolithic-fasl-op #+(or ecl mkcl) monolithic-lib-op)
+                         :allocation :class))
     (:documentation "produce fasl and asd files for combined system and dependencies."))
 
-  (defclass monolithic-fasl-op (monolithic-bundle-compile-op basic-fasl-op non-propagating-operation) ()
+  (defclass monolithic-fasl-op (monolithic-bundle-op basic-fasl-op
+                                #+ecl link-op gather-op non-propagating-operation)
+    ((gather-op :initform #+(or ecl mkcl) 'lib-op #-(or ecl mkcl) 'fasl-op :allocation :class))
     (:documentation "Create a single fasl for the system and its dependencies."))
 
-  (defclass monolithic-lib-op (monolithic-bundle-compile-op non-propagating-operation no-ld-flags-op)
-    ((bundle-type :initform #+(or ecl mkcl) :lib #-(or ecl mkcl) :no-output-file))
-    (:documentation #+(or ecl mkcl) "Create a single linkable library for the system and its dependencies."
-     #-(or ecl mkcl) "Compile a system and its dependencies."))
-
-  (defclass monolithic-dll-op (monolithic-bundle-compile-op non-propagating-operation no-ld-flags-op)
+  (defclass monolithic-lib-op (monolithic-bundle-op lib-op non-propagating-operation) ()
+    (:documentation "Create a single linkable library for the system and its dependencies."))
+
+  (defclass monolithic-dll-op (monolithic-bundle-op dll-op non-propagating-operation)
     ((bundle-type :initform :dll))
     (:documentation "Create a single dynamic (.so/.dll) library for the system and its dependencies."))
 
-  ;; Fare reports that the PROGRAM-OP doesn't need any propagation on MKCL or
-  ;; ECL because the necessary dependency wrangling is done by other, earlier
-  ;; operations. [2014/01/20:rpg]
-  (defclass program-op #+(or mkcl ecl) (monolithic-bundle-compile-op non-propagating-operation)
-            #-(or mkcl ecl) (monolithic-bundle-op selfward-operation)
-    ((bundle-type :initform :program)
-     #-(or mkcl ecl) (selfward-operation :initform 'load-op))
+  (defclass image-op (monolithic-bundle-op selfward-operation
+                      #+ecl link-op #+(or ecl mkcl) gather-op)
+    ((bundle-type :initform :image)
+     (selfward-operation :initform '(#-ecl load-op) :allocation :class))
+    (:documentation "create an image file from the system and its dependencies"))
+
+  (defclass program-op (image-op)
+    ((bundle-type :initform :program))
     (:documentation "create an executable file from the system and its dependencies"))
 
@@ -10061 +10233 @@
       ((eql :fasl) #-(or ecl mkcl) (compile-file-type) #+(or ecl mkcl) "fasb")
       #+ecl
-      ((member :binary :dll :lib :shared-library :static-library :program :object :program)
+      ((member :dll :lib :shared-library :static-library :program :object :program)
        (compile-file-type :type bundle-type))
-      ((eql :binary) "image")
+      ((member :image) "image")
       ((eql :dll) (cond ((os-macosx-p) "dylib") ((os-unix-p) "so") ((os-windows-p) "dll")))
       ((member :lib :static-library) (cond ((os-unix-p) "a") ((os-windows-p) "lib")))
@@ -10069 +10241 @@
 
   (defun bundle-output-files (o c)
-    (when (input-files o c)
-      (let ((bundle-type (bundle-type o)))
-        (unless (eq bundle-type :no-output-file) ;; NIL already means something regarding type.
-          (let ((name (or (component-build-pathname c)
-                          (format nil "~A~@[~A~]" (component-name c) (slot-value o 'name-suffix))))
-                (type (bundle-pathname-type bundle-type)))
-            (values (list (subpathname (component-pathname c) name :type type))
-                    (eq (type-of o) (component-build-operation c))))))))
+    (let ((bundle-type (bundle-type o)))
+      (unless (or (eq bundle-type :no-output-file) ;; NIL already means something regarding type.
+                  (and (null (input-files o c)) (not (member bundle-type '(:image :program)))))
+        (let ((name (or (component-build-pathname c)
+                        (format nil "~A~@[~A~]" (component-name c) (slot-value o 'name-suffix))))
+              (type (bundle-pathname-type bundle-type)))
+          (values (list (subpathname (component-pathname c) name :type type))
+                  (eq (type-of o) (component-build-operation c)))))))
 
   (defmethod output-files ((o bundle-op) (c system))
@@ -10107 +10279 @@
 ;;;
 (with-upgradability ()
-  (defun operation-monolithic-p (op)
-    (typep op 'monolithic-op))
-
   (defmethod initialize-instance :after ((instance bundle-op) &rest initargs
                                          &key (name-suffix nil name-suffix-p)
@@ -10119 +10288 @@
               (if (operation-monolithic-p instance) "--all-systems" #-ecl "--system")))) ; . no good for Logical Pathnames
     (when (typep instance 'monolithic-bundle-op)
-      (destructuring-bind (&rest original-initargs
-                           &key lisp-files prologue-code epilogue-code
+      (destructuring-bind (&key lisp-files prologue-code epilogue-code
                            &allow-other-keys)
           (operation-original-initargs instance)
-        (setf (operation-original-initargs instance)
-              (remove-plist-keys '(:lisp-files :epilogue-code :prologue-code) original-initargs)
-              (monolithic-op-prologue-code instance) prologue-code
-              (monolithic-op-epilogue-code instance) epilogue-code)
+        (setf (prologue-code instance) prologue-code
+              (epilogue-code instance) epilogue-code)
         #-ecl (assert (null (or lisp-files epilogue-code prologue-code)))
         #+ecl (setf (bundle-op-lisp-files instance) lisp-files)))
     (setf (bundle-op-build-args instance)
-          (remove-plist-keys '(:type :monolithic :name-suffix)
-                             (operation-original-initargs instance))))
-
-  (defmethod bundle-op-build-args :around ((o no-ld-flags-op))
-    (let ((args (call-next-method)))
-      (remf args :ld-flags)
-      args))
+          (remove-plist-keys
+           '(:type :monolithic :name-suffix :epilogue-code :prologue-code :lisp-files)
+           (operation-original-initargs instance))))
 
   (defun bundlable-file-p (pathname)
@@ -10165 +10327 @@
 ;;;
 (with-upgradability ()
-  (defmethod component-depends-on ((o bundle-compile-op) (c system))
-    `(,(if (operation-monolithic-p o)
-           `(#-(or ecl mkcl) fasl-op #+(or ecl mkcl) lib-op
-               ,@(required-components c :other-systems t :component-type 'system
-                                        :goal-operation (find-operation o 'load-op)
-                                        :keep-operation 'compile-op))
-           `(compile-op
-             ,@(required-components c :other-systems nil :component-type '(not system)
-                                      :goal-operation (find-operation o 'load-op)
-                                      :keep-operation 'compile-op)))
-      ,@(call-next-method)))
-
   (defmethod component-depends-on :around ((o bundle-op) (c component))
     (if-let (op (and (eq (type-of o) 'bundle-op) (component-build-operation c)))
@@ -10187 +10337 @@
     (while-collecting (collect)
       (map-direct-dependencies
-       o c #'(lambda (sub-o sub-c)
-               (loop :for f :in (funcall key sub-o sub-c)
-                     :when (funcall test f) :do (collect f))))))
-
-  (defmethod input-files ((o bundle-compile-op) (c system))
+       t o c #'(lambda (sub-o sub-c)
+                 (loop :for f :in (funcall key sub-o sub-c)
+                       :when (funcall test f) :do (collect f))))))
+
+  (defmethod input-files ((o gather-op) (c system))
     (unless (eq (bundle-type o) :no-output-file)
       (direct-dependency-files o c :test 'bundlable-file-p :key 'output-files)))
@@ -10197 +10347 @@
   (defun select-bundle-operation (type &optional monolithic)
     (ecase type
-      ((:binary)
-       (if monolithic 'monolithic-binary-op 'binary-op))
       ((:dll :shared-library)
        (if monolithic 'monolithic-dll-op 'dll-op))
@@ -10205 +10353 @@
       ((:fasl)
        (if monolithic 'monolithic-fasl-op 'fasl-op))
+      ((:image)
+       'image-op)
       ((:program)
        'program-op)))
 
+  ;; This is originally from asdf-ecl.lisp. Does anyone use it?
   (defun make-build (system &rest args &key (monolithic nil) (type :fasl)
                              (move-here nil move-here-p)
@@ -10222 +10373 @@
            (files (and system (output-files operation system))))
       (if (or move-here (and (null move-here-p)
-                             (member operation-name '(:program :binary))))
+                             (member operation-name '(:program :image))))
           (loop :with dest-path = (resolve-symlinks* (ensure-directories-exist move-here-path))
                 :for f :in files
@@ -10266 +10417 @@
 
   (defmethod input-files ((o operation) (c compiled-file))
-    (component-pathname c))
+    (list (component-pathname c)))
   (defmethod perform ((o load-op) (c compiled-file))
     (perform-lisp-load-fasl o c))
@@ -10297 +10448 @@
 ;;;
 (with-upgradability ()
-  (defmethod output-files ((o binary-op) (s system))
+  (defmethod output-files ((o deliver-asd-op) (s system))
     (list (make-pathname :name (component-name s) :type "asd"
                          :defaults (component-pathname s))))
 
-  (defmethod perform ((o binary-op) (s system))
+  (defmethod perform ((o deliver-asd-op) (s system))
     (let* ((inputs (input-files o s))
            (fasl (first inputs))
@@ -10314 +10465 @@
                  (while-collecting (x) ;; resolve the sideway-dependencies of s
                    (map-direct-dependencies
-                    'load-op s
+                    t 'load-op s
                     #'(lambda (o c)
                         (when (and (typep o 'load-op) (typep c 'system))
@@ -10343 +10494 @@
 
   #-(or ecl mkcl)
-  (defmethod perform ((o bundle-compile-op) (c system))
+  (defmethod perform ((o basic-fasl-op) (c system))
     (let* ((input-files (input-files o c))
            (fasl-files (remove (compile-file-type) input-files :key #'pathname-type :test-not #'equalp))
@@ -10354 +10505 @@
           (error "On ~A, asdf/bundle can only bundle FASL files, but these were also produced: ~S"
                  (implementation-type) non-fasl-files))
-        (when (and (typep o 'monolithic-bundle-op)
-                   (or (monolithic-op-prologue-code o) (monolithic-op-epilogue-code o)))
+        (when (or (prologue-code o) (epilogue-code o)
+                  (prologue-code c) (epilogue-code c))
           (error "prologue-code and epilogue-code are not supported on ~A"
                  (implementation-type)))
@@ -10368 +10519 @@
 
   (defmethod component-depends-on ((o load-fasl-op) (s precompiled-system))
+    #+xcl (declare (ignorable o))
     `((load-op ,s) ,@(call-next-method))))
 
-  #| ;; Example use:
+#| ;; Example use:
 (asdf:defsystem :precompiled-asdf-utils :class asdf::precompiled-system :fasl (asdf:apply-output-translations (asdf:system-relative-pathname :asdf-utils "asdf-utils.system.fasl")))
 (asdf:load-system :precompiled-asdf-utils)
@@ -10387 +10539 @@
     (let ((files (call-next-method))
           (plan (traverse-sub-actions o c :plan-class 'sequential-plan)))
-      (unless (or (and (find-system :uiop nil)
-                       (system-source-directory :uiop)
+      (unless (or (and (system-source-directory :uiop)
                        (plan-operates-on-p plan '("uiop")))
                   (and (system-source-directory :asdf)
@@ -10400 +10551 @@
 #+ecl
 (with-upgradability ()
-  (defmethod perform ((o bundle-compile-op) (c system))
+  ;; I think that Juanjo intended for this to be.
+  ;; But it might break systems with missing dependencies,
+  ;; and there is a weird bug in test-xach-update-bug.script
+  ;;(unless (use-ecl-byte-compiler-p)
+  ;;  (setf *load-system-operation* 'load-fasl-op))
+
+  (defmethod perform ((o link-op) (c system))
     (let* ((object-files (input-files o c))
            (output (output-files o c))
            (bundle (first output))
+           (targetp (eq (type-of o) (component-build-operation c)))
            (kind (bundle-type o)))
       (when output
-        (create-image
-         bundle (append object-files (bundle-op-lisp-files o))
-         :kind kind
-         :entry-point (component-entry-point c)
-         :prologue-code
-         (when (typep o 'monolithic-bundle-op)
-           (monolithic-op-prologue-code o))
-         :epilogue-code
-         (when (typep o 'monolithic-bundle-op)
-           (monolithic-op-epilogue-code o))
-         :build-args (bundle-op-build-args o))))))
+        (apply 'create-image
+               bundle (append object-files (bundle-op-lisp-files o))
+               :kind kind
+               :prologue-code (or (prologue-code o) (when targetp (prologue-code c)))
+               :epilogue-code (or (epilogue-code o) (when targetp (epilogue-code c)))
+               :build-args (bundle-op-build-args o)
+               (when targetp `(:entry-point ,(component-entry-point c))))))))
 
 #+mkcl
@@ -10430 +10584 @@
   (defun bundle-system (system &rest args &key force (verbose t) version &allow-other-keys)
     (declare (ignore force verbose version))
-    (apply #'operate 'binary-op system args)))
+    (apply #'operate 'deliver-asd-op system args)))
 
 #+(and (not asdf-use-unsafe-mac-bundle-op)
@@ -10858 +11012 @@
    #:upward-operation #:downward-operation #:sideway-operation #:selfward-operation
                       #:non-propagating-operation
-   #:build-system #:build-op
+   #:build-op #:build
    #:load-op #:prepare-op #:compile-op
    #:prepare-source-op #:load-source-op #:test-op
@@ -10871 +11025 @@
    #+ecl #:make-build
    #:basic-fasl-op #:prepare-fasl-op #:fasl-op #:load-fasl-op #:monolithic-fasl-op
-   #:lib-op #:dll-op #:binary-op #:program-op
-   #:monolithic-lib-op #:monolithic-dll-op #:monolithic-binary-op
+   #:lib-op #:dll-op #:deliver-asd-op #:program-op #:image-op
+   #:monolithic-lib-op #:monolithic-dll-op #:monolithic-deliver-asd-op
    #:concatenate-source-op
    #:load-concatenated-source-op
@@ -10925 +11079 @@
    #:system-source-control
    #:map-systems
+   #:system-defsystem-depends-on
+   #:system-depends-on
+   #:system-weakly-depends-on
 
    #:*system-definition-search-functions*   ; variables
@@ -10931 +11088 @@
    #:*compile-file-failure-behaviour*
    #:*resolve-symlinks*
-   #:*load-system-operation*
+   #:*load-system-operation* #:*immutable-systems*
    #:*asdf-verbose* ;; unused. For backward-compatibility only.
    #:*verbose-out*
@@ -11001 +11158 @@
 (uiop/package:define-package :asdf/user
   (:nicknames :asdf-user)
-  ;; TODO: it would be nice to have :UIOP in the list,
-  ;; but we need test compatibility with cl-test-grid first.
-  (:use :uiop/common-lisp :uiop/package :asdf/interface))
+  ;; NB: releases before 3.1.1 this :use'd only uiop/package instead of uiop below.
+  ;; They also :use'd uiop/common-lisp, that reexports common-lisp and is not included in uiop.
+  ;; ASDF3 releases from 2.27 to 2.31 called uiop asdf-driver and asdf/foo uiop/foo.
+  ;; ASDF1 and ASDF2 releases (2.26 and earlier) create a temporary package
+  ;; that only :use's :cl and :asdf
+  (:use :uiop/common-lisp :uiop :asdf/interface))
 ;;;; -----------------------------------------------------------------------
 ;;;; ASDF Footer: last words and cleanup
@@ -11013 +11173 @@
 
 ;;;; Hook ASDF into the implementation's REQUIRE and other entry points.
-
-(with-upgradability ()
-  #+(or abcl clisp clozure cmu ecl mkcl sbcl)
+#+(or abcl clisp clozure cmu ecl mkcl sbcl)
+(with-upgradability ()
   (if-let (x (and #+clisp (find-symbol* '#:*module-provider-functions* :custom nil)))
     (eval `(pushnew 'module-provide-asdf
@@ -11043 +11202 @@
                           (values-list l))))))))
 
-#+cmu
+#+cmu ;; Hook into the CMUCL herald.
 (with-upgradability ()
   (defun herald-asdf (stream)
@@ -11058 +11217 @@
   (dolist (f '(:asdf :asdf2 :asdf3 :asdf3.1 :asdf-package-system)) (pushnew f *features*))
 
-  (provide "asdf") (provide "ASDF") ;; do it both ways to satisfy more people.
+  ;; Provide both lowercase and uppercase, to satisfy more people, especially LispWorks users.
+  (provide "asdf") (provide "ASDF")
 
   (cleanup-upgraded-asdf))