Predefined operations of asdf

All the operations described in this section are in the asdf package. They are invoked via the operate generic function.

— Operation: compile-op &key proclamations

This operation compiles the specified component. If proclamations are supplied, they will be proclaimed. This is a good place to specify optimization settings.
When creating a new component type, you should provide methods for compile-op.
When compile-op is invoked, component dependencies often cause some parts of the system to be loaded as well as compiled. Invoking compile-op does not necessarily load all the parts of the system, though; use load-op to load a system.

— Operation: load-op &key proclamations

This operation loads a system.
The default methods for load-op compile files before loading them. For parity, your own methods on new component types should probably do so too.

— Operation: load-source-op

This operation will load the source for the files in a module even if the source files have been compiled. Systems sometimes have knotty dependencies which require that sources are loaded before they can be compiled. This is how you do that.
If you are creating a component type, you need to implement this operation - at least, where meaningful.

— Operation: test-system-version &key minimum

Asks the system whether it satisfies a version requirement.
The default method accepts a string, which is expected to contain of a number of integers separated by #\. characters. The method is not recursive. The component satisfies the version dependency if it has the same major number as required and each of its sub-versions is greater than or equal to the sub-version number required.
          (defun version-satisfies (x y)
            (labels ((bigger (x y)
          	     (cond ((not y) t)
          		   ((not x) nil)
          		   ((> (car x) (car y)) t)
          		   ((= (car x) (car y))
          		    (bigger (cdr x) (cdr y))))))
              (and (= (car x) (car y))
          	 (or (not (cdr y)) (bigger (cdr x) (cdr y))))))
     
If that doesn't work for your system, you can override it. I hope you have as much fun writing the new method as #lisp did reimplementing this one.

— Operation: feature-dependent-op

An instance of feature-dependent-op will ignore any components which have a features attribute, unless the feature combination it designates is satisfied by *features*. This operation is not intended to be instantiated directly, but other operations may inherit from it.

3.1.1 Predefined operations of asdf