Predefined operations of asdf - asdf Manual
Description: asdf Manual

Next: Creating new operations, Previous: Operations, Up: Operations

#### 3.1.1 Predefined operations of asdf

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

         (asdf:operate 'asdf:operation-name 'system-name {operation-options ...})

— 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.