Macro

Summary

defsystem is used to define systems for use with the LispWorks system tools. A system is a collection of files and other systems that, together with rules expressing the interdependencies of those files and subsystems, make a complete program. The LispWorks system tools support the development and maintenance of large programs.

Package

lispworks

Signature

defsystem system-name options &key members rules => system

Arguments

system-name

The name of the system to be made.

options are expressed as a list of keyword argument pairs. The following keywords are recognized:

:package

The default package that files are compiled and loaded in. If not specified, this defaults to the value of *package* at macroexpansion time.

:default-pathname

Used to compute a default pathname in which to find files. defsystem uses current-pathname to compute the pathname. defsystem checks that all the files given as members actually exist .

:default-host

The root pathname of a system is defined to be the :default-host if it is given. Otherwise, it is taken to be the directory containing the defsystem file.

Absolute pathnames are interpreted literally, and relative pathnames are taken relative to the root pathname.

:default-type

This is the default type of the members of the system. This may be :lisp-file , :c-file , or :system . The default is :lisp-file .

:documentation

This is a string.

members is a list defining the members of the system. Each element of the list may be a symbol or a string representing the name of the physical file referred to, or a list of format ( name { keyword value }*) where name is once again a symbol or a string referring to the physical file, and the possible keywords are:

:type

The type of this member. If not specified it defaults to the value of :default-type given as an option

:root-module

If nil then this member is not loaded unless its loading is specifically requested as a result of a dependency on another module

:source-only

Only the source file for this member is ever loaded

:load-only

The member is never compiled by defsystem , objects are loaded in preference to source files

:load-for-compile-only

The member is only loaded as necessary during compilation and is never loaded independently

:features

The member is only considered during planning if the feature expression is true

rules is a list of rules of the following format :

({:in-order-to} action
 {:all | ({ member-name
 }* )}

  (:caused-by {(action
 {:previous |{member-name
 }* }) }*)

  (:requires {(action
 {:previous |{ member-name
 }*}) }*))

The keyword :all refers to all the members of the system. It provides a shorthand for specifying that a rule should apply to all the system's members. The keyword :previous refers to all the members of the system that are before the member in the list of members. This makes it easy, for example, to specify that in order to compile a file in a system, all the members that come before it must be loaded.

Values

The name of the system is returned.

Examples

(defsystem defsys-macros

   (:default-pathname "/usr/users/james/scm/defsys/"

    :default-type :lisp-file

    :package defsystem)

   :members ("new-macros"

             "scm-timemacros"))

(defsystem clos-sys

   (:default-pathname "/usr/users/clc/defsys/"

    :default-type :lisp-file

    :package defsystem)

   :members

     (("defsys-macros" :type :system :root-module nil)

       "class"

       "time-methods"

      ("scm-pathname" :source-only t)

       "execute-plan"

       "file-types"

       "make-system"

       "conv-defsys")

   :rules

     ((:in-order-to :compile ("class" "time-methods")

           (:caused-by (:compile "defsys-macros"))

                       (:requires

                         (:load "defsys-macros")))

      (:in-order-to :compile

                       ("time-methods" "execute-plan")

                       (:requires (:load "class")))))

(defsystem dataworks-demo

   (:default-type :system)

   :members (

     "db-class"

     "planar"

     "dataworks-dep"

     "dataworks-interface-tk"

     "dataworks-interface-tools"

     "drugs-demo"

     ("gen-demo" :type :lisp-file)

     ("load-icon" :type :lisp-file :source-only t)

     )

   :rules ((:in-order-to :compile :all

 (:requires (:load :previous)))))

Notes

Systems that are members of another system must be declared in the system declaration file before the system of which they are a part.

The ordering of members is important and reflects the order in which operations are carried out on the members of the system.

See also

load-system
compile-system
concatenate-system
current-pathname