To load a file is to treat its contents as code and execute that code. The file may contain source code or compiled code.
A file containing source code is called a source file. Loading a source file is accomplished essentially by sequentially reading2 the forms in the file, evaluating each immediately after it is read.
A file containing compiled code is called a compiled file. Loading a compiled file is similar to loading a source file, except that the file does not contain text but rather an implementation-dependent representation of pre-digested expressions created by the compiler. Often, a compiled file can be loaded more quickly than a source file. See Section 3.2 (Compilation).
The way in which a source file is distinguished from a compiled file is implementation-dependent.
A feature is an aspect or attribute of Common Lisp, of the implementation, or of the environment. A feature is identified by a symbol.
A feature is said to be present in a Lisp image if and only if the symbol naming it is an element of the list held by the variable *features*, which is called the features list.
Boolean combinations of features, called feature expressions, are used by the #+
and #-
reader macros in order to direct conditional reading of expressions by the Lisp reader.
The rules for interpreting a feature expression are as follows:
If a symbol naming a feature is used as a feature expression, the feature expression succeeds if that feature is present; otherwise it fails.
(not feature-conditional)
A not feature expression succeeds if its argument feature-conditional fails; otherwise, it succeeds.
(and {feature-conditional}*)
An and feature expression succeeds if all of its argument feature-conditionals succeed; otherwise, it fails.
(or {feature-conditional}*)
An or feature expression succeeds if any of its argument feature-conditionals succeed; otherwise, it fails.
For example, suppose that in implementation A, the features spice
and perq
are present, but the feature lispm
is not present; in implementation B, the feature lispm
is present, but the features spice
and perq
are not present; and in implementation C, none of the features spice
, lispm, or perq
are present. Figure 24–1 shows some sample expressions, and how they would be read2 in these implementations.
(cons #+spice "Spice" #-spice "Lispm" x) | |
in implementation A . . . | (CONS "Spice" X) |
in implementation B . . . | (CONS "Lispm" X) |
in implementation C . . . | (CONS "Lispm" X) |
(cons #+spice "Spice" #+LispM "Lispm" x) | |
in implementation A . . . | (CONS "Spice" X) |
in implementation B . . . | (CONS "Lispm" X) |
in implementation C . . . | (CONS X) |
(setq a '(1 2 #+perq 43 #+(not perq) 27)) | |
in implementation A . . . | (SETQ A '(1 2 43)) |
in implementation B . . . | (SETQ A '(1 2 27)) |
in implementation C . . . | (SETQ A '(1 2 27)) |
(let ((a 3) #+(or spice lispm) (b 3)) (foo a)) | |
in implementation A . . . | (LET ((A 3) (B 3)) (FOO A)) |
in implementation B . . . | (LET ((A 3) (B 3)) (FOO A)) |
in implementation C . . . | (LET ((A 3)) (FOO A)) |
(cons #+Lispm "#+Spice" #+Spice "foo" #-(or Lispm Spice) 7 x) | |
in implementation A . . . | (CONS "foo" X) |
in implementation B . . . | (CONS "#+Spice" X) |
in implementation C . . . | (CONS 7 X) |