;;;; -*- Mode: Lisp; Syntax: ANSI-Common-Lisp; Base: 10 -*-

这将保证开启正确的语法支持，它是必须的，因为默认情况下emacs不知道任何.asd文件。

之后，cow.asd 可能书写如下:

(defpackage #:cow-asd

(:use :cl :asdf))

(in-package :cow-asd)

(defsystem cow:name "cow":version "0.0.0":maintainer "T. God":author "Desmon Table":licence "BSD sans advertising clause (see file COPYING for details)":description "Cow":long-description "Lisp implementation of our favorite ruminant"

     system-definition := ( defsystem system-designator system-option* )system-option := :defsystem-depends-on system-list| :weakly-depends-on system-list| :class class-name (see discussion below)| module-option| optionmodule-option := :components component-list| :serial [ t | nil ]| :if-component-dep-fails component-dep-fail-optionoption :=| :pathname pathname-specifier| :default-component-class class-name| :perform method-form| :explain method-form| :output-files method-form| :operation-done-p method-form| :depends-on ( dependency-def* )| :in-order-to ( dependency+ )system-list := ( simple-component-name* )component-list := ( component-def* )component-def  := ( component-type simple-component-name option* )component-type := :system | :module | :file | :static-file | other-component-typeother-component-type := symbol-by-name (see Component types)dependency-def := simple-component-name| ( :feature name )| ( :version simple-component-name version-specifier)dependency := (dependent-op requirement+)requirement := (required-op required-component+)| (feature feature-name)dependent-op := operation-namerequired-op := operation-name | featuresimple-component-name := string|  symbolpathname-specifier := pathname | string | symbolmethod-form := (operation-name qual lambda-list &rest body)qual := method qualifiercomponent-dep-fail-option := :fail | :try-next | :ignore

  ;;; (Optional items omitted):serial t ;; the dependencies are linear.:components ((:file "defpackage")(:file "legs")(:file "tail")(:file "head")))

  ;;; (Optional items omitted):components ((:file "tail":depends-on ("package" "legs"))(:file "legs":depends-on ("package"))(:file "head":depends-on ("package"))(:file "package")))

(defsystem cow:components ((:file "head" :depends-on ("package"))(:file "tail" :depends-on ("package"circulation))(:file "package")(:module circulation:components ((:file "water":depends-on"package")(:file "assorted-solids":depends-on"package")(:file "package")))(:module respiratory:pathname "breathing":components (...))))

(defsystem cow;;; ...:components (...):depends-on ("other-system"))

(setf asdf:*central-registry*;; Default directories, usually just the ``current directory'''(*default-pathname-defaults*;; Additional places where ASDF can find;; system definition files#p"/home/foo/lisp/systems/"#p"/usr/share/common-lisp/systems/"))

构建和加载系统cow的命令如下：

如果cow.asd碰巧在你当前的工作目录，那么构建和加载过程将会从这个开始。如果没有的话，ASDF将会搜索cetral registry的目录，寻找cow.asd的系统定义文件或者软链接。如果找到的软连接的话，它将跟随它会找到原文件，运行构建过程在相应的目录。如果找到文件的话，它将在此目录运行构建过程。

所以，如果你做了一个符号链接/home/foo/lisp/system到cow的系统定义文件，例如：

$ ln -s /home/foo/code/cow/cow.asd

(asdf:operate 'asdf:load-op 'cow)

  (:use #:common-lisp))

Getting started with ASDF

Mario S. Mommer <mommer@common-lisp.net>

Last modified: April 05, 2006.

Contents

ContentsIntroduction

Purpose of this documentWhat problem does ASDF solve?Legal matters

Defining systems with ASDF

The base caseA more complex exampleA system with modulesA system that depends on other systems

How to use system definition files

Introduction

Purpose of this document

The aim of this document is to give a brief introduction to the use ofASDF, Another System Definition Facility. It is not about the arcane tricks and tips, and is not about the design ofASDFitself nor about system definition tools in general.

A system definition file is nothing else than a description of dependencies between files of source code in such a way that they can be compiled and loaded in the right order. A fileA.lispdepends on a fileB.lispif the latter contains definitions and/or code that is used byA.lisp¹.

What problem doesASDFsolve?

When you download the source code of some software from the Internet, or get it from some other source, you usually do not get an amorphous bunch of files, but instead get a system of components that depend on each other in some particular way. The consequence of this is that, if you want to build the software (be it a library, or be it an application), you will probably have to build these components, and the components of these components in order, perhaps giving some special treatment to some of them. You would, of course, be very grateful if the developer had prepared everything, and you could trigger the build process by a single command.

If you are a developer working in a project with a few components, you will probably want some mechanism that keeps track of the dependencies between these components, so that if you change one component, triggering a rebuild only recompiles and reloads the components which are affected.

Finally, you probably want a consistent way of dealing with the dependencies between components and of building and loading software systems, simply because it saves everyone time when installing software and using software.

ASDFis, roughly speaking, an extensible facility for defining the dependencies between software components, and specifying eventual details of the build process. It is also in fairly wide use, so that you can assume that your system definition will be understood by many others.

This work is licensed under aCreative Commons Attribution 2.5 License.

Defining systems withASDF

The system definition file should be calledcow.asd, and, at least in the usual scenarios, should reside in the same directory as your source code. If you use emacs, you might want to put the following as the first line incow.asd.

;;;; -*- Mode: Lisp; Syntax: ANSI-Common-Lisp; Base: 10 -*-

This makes sure that the proper syntax support is turned on, which is necessary because by default emacs knows nothing about.asdfiles.

After that,cow.asdshould start with the following code (preceded or followed perhaps by comments; goes almost without saying)

(defpackage #:cow-asd(:use :cl :asdf))(in-package :cow-asd)

The next thing is to write adefsystemform, together with some (optional) extra information.

(defsystem cow:name "cow":version "0.0.0":maintainer "T. God":author "Desmon Table":licence "BSD sans advertising clause (see file COPYING for details)":description "Cow":long-description "Lisp implementation of our favorite ruminant"

     system-definition := ( defsystem system-designator system-option* )system-option := :defsystem-depends-on system-list| :weakly-depends-on system-list| :class class-name (see discussion below)| module-option| optionmodule-option := :components component-list| :serial [ t | nil ]| :if-component-dep-fails component-dep-fail-optionoption :=| :pathname pathname-specifier| :default-component-class class-name| :perform method-form| :explain method-form| :output-files method-form| :operation-done-p method-form| :depends-on ( dependency-def* )| :in-order-to ( dependency+ )system-list := ( simple-component-name* )component-list := ( component-def* )component-def  := ( component-type simple-component-name option* )component-type := :system | :module | :file | :static-file | other-component-typeother-component-type := symbol-by-name (see Component types)dependency-def := simple-component-name| ( :feature name )| ( :version simple-component-name version-specifier)dependency := (dependent-op requirement+)requirement := (required-op required-component+)| (feature feature-name)dependent-op := operation-namerequired-op := operation-name | featuresimple-component-name := string|  symbolpathname-specifier := pathname | string | symbolmethod-form := (operation-name qual lambda-list &rest body)qual := method qualifiercomponent-dep-fail-option := :fail | :try-next | :ignore

The base case

In the simplest case you have a directory with a few files. And the absolutely simplest case is when the dependency of your files is linear. That is, you can make a list of the files such that the first one should be loaded first, the second second, etc.

In such a case, thedefsystemform can look like this.

(defsystem cow;;; (Optional items omitted):serial t ;; the dependencies are linear.:components ((:file "defpackage")(:file "legs")(:file "tail")(:file "head")))

A more complex example

Suppose that we have the same files as before, but would like to specify the dependencies more accurately. There is a file calleddefpackage.lisp, from which everything else depends. And we have that, for some mysterious reason,tail.lispdepends onlegs.lisp. Thedefsystemform for this project could look as follows.

(defsystem cow;;; (Optional items omitted):components ((:file "tail":depends-on ("package" "legs"))(:file "legs":depends-on ("package"))(:file "head":depends-on ("package"))(:file "package")))

In this case you would keep the filecow.asdin the same directory as the source files. If you want to try out our nicecowsystem, you can jump directly to the pertinentsection.

A system with modules

Suppose that we have the following, more involved structure. We have ahead.lisp, andlegs.lisp. But we also have a subsystem calledrespiratory, which consists of a few more files, and lives in its own subdirectory calledbreathing(this is a subdirectory of the directory wherecow.asdlives). Similarly, we have another subsystem calledcirculation. Thedefsystem formcould look more or less like this.

(defsystem cow:components ((:file "head" :depends-on ("package"))(:file "tail" :depends-on ("package"circulation))(:file "package")(:module circulation:components ((:file "water":depends-on"package")(:file "assorted-solids":depends-on"package")(:file "package")))(:module respiratory:pathname "breathing":components (...))))

Note that the files in the modulecirculationall live in the subdirectorycirculation. Thus the filepackage.lispin the modulecirculationis a different one than that a level higher.

A module can have as components both files and other modules, which in turn can have files and modules as components. It is important to note that dependencies can only be definedinside a given set of components. So, the filetail.lispcannot depend on the fileassorted-solids, which is a component of a submodule.

A system that depends on other systems

A system that depends on other systems will look exactly like a regular one, except for an additional:depends-onoption. It looks like this.

(defsystem cow;;; ...:components (...):depends-on ("other-system"))

How to use system definition files

System definition files live in the directory where the corresponding piece of software lives. However, you do not need to have that directory as your working directory to be able to build and load said software. You only need to put asymbolic linkto the system definition file in a directory whereASDFsearches.

The usual setup is as follows. To begin with, you need to haveASDFloaded. In some implementationsASDFis already loadad. In others, it is just a matter of writing

  (require 'asdf)

Now, somewhere in the init file of your Common Lisp implementation (for CMUCL it would be.cmucl-init.lispin your home directory) a variation of the following passage should appear.

(load "/home/foo/lisp/utils/asdf")(setf asdf:*central-registry*;; Default directories, usually just the ``current directory'''(*default-pathname-defaults*;; Additional places where ASDF can find;; system definition files#p"/home/foo/lisp/systems/"#p"/usr/share/common-lisp/systems/"))

The command to build and load system cow is

(asdf:operate 'asdf:load-op 'cow)

If the filecow.asdhappens to be in the current working directory, the build and load process will start there. If not, ASDF will search through the directories in the central registry, and look for a system definition file namedcow.asd, or for a symbolic link to one. If it finds the latter, it will follow the link to the original file, and run the build process in the corresponding directory. If it finds the file, it will run the build process in the directory where it finds it.

So, if you make a symbolic link in/home/foo/lisp/systems/to thecowsystem definition file, by executing (for example)

$ cd <where-your-system-defs-are>
$ ln -s /home/foo/code/cow/cow.asd

Then you can build and load the cow software without having to be in the directory where this software lives simply by issuing the command

(asdf:operate 'asdf:load-op 'cow)