Next: Moving on, Previous: Loading a system, Up: Using ASDF [Contents][Index]
ASDF provides three commands for the most common system operations:
load-system, compile-system, and test-system.
ASDF also provides require-system, a variant of load-system
that skips loading systems that are already loaded. This is sometimes
useful, for example, in order to avoid re-loading libraries that come
pre-loaded into your lisp implementation.
ASDF also provides make, a way of allowing system developers to
choose a default operation for their systems. For example, a developer
who has created a system intended to format a specific document, might
make document-formatting the default operation invoked by make,
instead of loading. If the system developer doesn’t specify in the
system definition, the default operation will be loading.
Because ASDF is an extensible system
for defining operations on components,
it also provides a generic function operate,
so you may arbitrarily operate on your systems beyond the default operations.
(At the interactive REPL, users often use its shorter alias oos,
which stands for operate-on-system, a name inherited from mk-defsystem.)
You’ll use operate whenever you want to do something beyond
compiling, loading and testing.
Apply operate with the operation load-op, the
system, and any provided keyword arguments. Calling
load-system is the regular, recommended way to load a system
into the current image.
Apply operate with the operation compile-op,
the system, and any provided keyword arguments.
This will make sure all the files in the system are compiled,
but not necessarily load any of them in the current image;
on most systems, it will not load all compiled files in the current image.
This function exists for symmetry with load-system but is not recommended
unless you are writing build scripts and know what you’re doing.
But then, you might be interested in program-op rather than compile-op.
Apply operate with the operation test-op,
the system, and any provided keyword arguments.
See test-op.
Do “The Right Thing” with your system.
Starting with ASDF 3.1, this function make is also available.
The default behaviour is to load the system as if by load-system;
but system authors can override this default in their system definition
they may specify an alternate operation as the intended use of their system,
with a :build-operation option in the defsystem form
(see Build-operation),
and an intended output pathname for that operation with
:build-pathname.
This function is experimental and largely untested. Use at your own risk.
require-system skips any update to systems that have already been loaded,
in the spirit of cl:require.
It does it by calling load-system with a keyword option
excluding already loaded systems.8.
On actively maintained free software implementations
(namely recent versions of ABCL, Clozure CL, CMUCL, ECL, GNU CLISP, MKCL and SBCL),
once ASDF itself is loaded, cl:require too can load ASDF systems,
by falling back on require-system
for module names not recognized by the implementation.
(Note however that require-system does not fall back on cl:require;
that would introduce an “interesting” potential infinite loop to break somehow.)
cl:require and require-system are appropriate to load code
that is not being modified during the current programming session.
cl:require will notably load the implementation-provided extension modules;
require-system won’t, unless they are also defined as systems somehow,
which SBCL and MKCL do.
require-system may also be used to load any number of ASDF systems
that the user isn’t either developing or debugging,
for which a previously installed version is deemed to be satisfactory;
cl:require on the above-mentioned implementations will delegate to require-system
and may load them as well.
But for code that you are actively developing, debugging, or otherwise modifying,
you should use load-system, so ASDF will pick on your modifications
and transitively re-build the modified files and everything that depends on them
(that the requested system itself depends on —
ASDF itself never builds anything unless
it’s an explicitly requested system or the dependencies thereof).
Returns a list of names of the systems that have been successfully loaded so far.
Next: Moving on, Previous: Loading a system, Up: Using ASDF [Contents][Index]