defsystem Macro

Summary

Defines a system for use with the LispWorks system tools.

Package

lispworks

Signature

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

Arguments

Values

Description

The macro 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. Find a full description at 20 Common Defsystem and ASDF.

The name of the system to be made is a string specified by name. If name is a symbol, then its symbol name is used.

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

members is a list defining the members of the system. Elements of the list may be a string name representing the name of the physical file or system referred to. Elements of the list may also be a symbol, which is interpreted as its symbol name.

Elements of members list can also be a list of the form:

(member-name {keyword value}*)

where member-name is once again a string or a symbol naming a file or system.

The members of each system must have unique names, as compared by equalp. For example, if members contains "foo" then there cannot be another member (either a file or a system) named "foo", "FOO" or foo.

The possible keywords and their values are:

On Windows, the automation module adds the keyword :com for a member with type :midl-type-library-file. Then a member of the form:

("mso97.tlb" :type :midl-type-library-file :com nil)

can be specified when you use only Automation client code, reducing the memory used.

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.

The name of the system is returned.

There are more details about the rules in 20.2.4 DEFSYSTEM rules.

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 :lsp-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)))))

This example illustrates the use of :optimize.

(defsystem foo (:optimize ((speed 3) (space 3) 
                           (safety 0)))
  :members ("bar"
            "baz")
  :rules ((:compile :all 
           (:requires (:load :previous)))))

This last example illustrates the use of :embedded-module.

(defsystem my-foreign-code ()
  :members
  (("my-c-code.c" :type :c-file
                  :embedded-module my-module)))

Then initialize at run time with:

(fli:install-embedded-module 'my-module)

Notes

1. Subsystems must be defined before any system of which they are part.
2. The order of members is important and reflects the order in which operations are carried out on the members of the system, subject to rules.

See also

load-system
compile-system
concatenate-system
current-pathname
*defsystem-verbose*