~ubuntu-branches/ubuntu/vivid/cl-asdf/vivid

     

     

     

@node Top, Using asdf to load systems, (dir), (dir)

     

* Using asdf to load systems::  

* Defining systems with defsystem::  

* The object model of asdf::    

* Error handling::              

* Compilation error and warning handling::  

* Getting the latest version::  

* TODO list::                   

* missing bits in implementation::  

* Inspiration::                 

* Concept Index::               

* Function and Class Index::    

* Variable Index::              

* The defsystem form::          

* A more involved example::     

* The defsystem grammar::       

* Operations::                  

* Components::                  

* Predefined operations of asdf::  

* Creating new operations::     

* Common attributes of components::  

* Pre-defined subclasses of component::  

* Creating new component types::  

* Pre-defined subclasses of component::  

* Creating new component types::  

 

@node  Using asdf to load systems, Defining systems with defsystem, Top, Top

@comment  node-name,  next,  previous,  up

@chapter Using asdf to load systems

@vindex *central-registry*

 

This chapter describes how to use asdf to compile and load ready-made

Lisp programs and libraries.

 

@section Downloading asdf

 

Some Lisp implementations (such as SBCL and OpenMCL) come with asdf

included already, so you don't need to download it separately.

Consult your Lisp system's documentation.  If you need to download

asdf and install it by hand, the canonical source is the cCLan CVS

repository at

@url{http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/cclan/asdf/}.

 

@section Setting up asdf

@section Setting up a system to be loaded

 

To compile and load a system, you need to ensure that a symbolic link to its

system definition is in one of the directories in

@code{*central-registry*}@footnote{It is possible to customize the

system definition file search.  That's considered advanced use, and

covered later: search forward for

@code{*system-definition-search-functions*}.  @xref{Defining systems

with defsystem}.}.

 

For example, if @code{#p"/home/me/cl/systems/"} (note the trailing

slash) is a member of @code{*central-registry*}, you would set up a

system @var{foo} that is stored in a directory

@file{/home/me/src/foo/} for loading with asdf with the following

commands at the shell (this has to be done only once):

 

@example

$ cd /home/me/cl/systems/

$ ln -s ~/src/foo/foo.asd .

@end example

 

(asdf:operate 'asdf:load-op '@var{foo})

definitions for Lisp software you write yourself.

* The defsystem form::          

* A more involved example::     

* The defsystem grammar::       

pollution and so is considered good form. 

  :components ((:module "foo" :components ((:file "bar") (:file"baz") 

                :perform (compile-op :after (op c)

                          (do-something c))

                :explain (compile-op :after (op c)

                          (explain-something c)))

                :perform (compile-op :after (op c)

                          (do-something c))

                :explain (compile-op :after (op c)

                          (explain-something c))

           (do-something c))

           (explain-something c))

@node  The defsystem grammar,  Other code in .asd files, A more involved example, Defining systems with defsystem

        | :perform method-form 

        | :output-files  method-form

        | :depends-on ( {dependency-def}* ) 

        | :serial [ t | nil ]

                

:components ((:file "a") 

             (:file "b" :depends-on ("a"))

             (:file "c" :depends-on ("a" "b")))

@node Other code in .asd files, , The defsystem grammar, Defining systems with defsystem

@node The object model of asdf, Error handling, Defining systems with defsystem, Top

* Operations::                  

* Components::                  

* Predefined operations of asdf::  

* Creating new operations::     

@deffn 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.

 

@lisp

(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))))))

@end lisp

 

If that doesn't work for your system, you can override it.  I hope

you have as much fun writing the new method as @verb{|#lisp|} did

reimplementing this one.

@end deffn

 

@deffn Operation feature-dependent-op

 

An instance of @code{feature-dependent-op} will ignore any components

which have a @code{features} attribute, unless the feature combination

it designates is satisfied by @code{*features*}.  This operation is

not intended to be instantiated directly, but other operations may

inherit from it.

 

@end deffn

* Common attributes of components::  

* Pre-defined subclasses of component::  

* Creating new component types::  

work on some implementations

              (load-op (load-op "foo")))

  (compile b) depends on (load a) 

for completely overriding the default dependencies

(If it weren't for CLISP, we'd be using a @code{LIST} method

your fixes)

The answer to the frequently asked question "how do I create a system 

* Pre-defined subclasses of component::  

* Creating new component types::  

generate from other components of the system. 

@node  Error handling, Compilation error and warning handling, The object model of asdf, Top

ASDF includes several additional features that are generally 

system-relative-pathname 

It's often handy to locate a file relative to some system. The system-relative-pathname function meets this need. It takes two arguments: the name of a system and a relative pathname. It returns a pathname built from the 

@enumerate

@item

 

@item

Check it out from sourceforge cCLan CVS:

 

@kbd{cvs -d:pserver:anonymous@@cvs.cclan.sourceforge.net:/cvsroot/cclan login}

 

(no password: just press @key{Enter})

 

@kbd{cvs -z3 -d:pserver:anonymous@@cvs.cclan.sourceforge.net:/cvsroot/cclan co -r RELEASE asdf}

 

or for the bleeding edge, instead

 

@kbd{cvs -z3 -d:pserver:anonymous@@cvs.cclan.sourceforge.net:/cvsroot/cclan co -A asdf}

 

@end enumerate

 

If you are tracking the bleeding edge, you may want to subscribe to

the cclan-commits mailing list (see

@url{http://sourceforge.net/mail/?group_id=28536}) to receive commit

messages and diffs whenever changes are made.

 

For more CVS information, look at

@url{http://sourceforge.net/cvs/?group_id=28536}.

 

 

 

        (oos 'compile-op :araneida :force t)

(asdf:revert 'asdf:compile-op 'araneida) 

unenviable task of supporting pre-ANSI implementations, which is 

@code{binary-foo} prefixes for separating source and binary files, and 

system.  

There is no proposal here that defsystem does version control.  

Available in updated-for-CL form on the web at 

@url{http://world.std.com/~pitman/Papers/Large-Systems.html}