Compiling and linking

Scheme 48 has a static linker that produces stand-alone heap images
from module descriptions. The programmer specifies a particular procedure in a
particular structure to be the image's startup procedure (entry
point), and the linker traces dependency links as given by open
and access clauses to determine the composition of the heap
image.

There is not currently any provision for separate compilation; the
only input to the static linker is source code. However, it will not
be difficult to implement separate compilation. The unit of
compilation is one module (not one file). Any opened or accessed
structures from which macros are obtained must be processed to the
extent of extracting its macro definitions. The compiler knows from
the interface of an opened or accessed structure which of its exports
are macros. Except for macros, a module may be compiled without any
knowledge of the implementation of its opened and accessed structures.
However, inter-module optimization may be available as an option.

The main difficulty with separate compilation is resolution of
auxiliary bindings introduced into macro expansions. The module
compiler must transmit to the loader or linker the search path by
which such bindings are to be resolved. In the case of the delay
macro's auxiliary make-promise (see example above), the loader
or linker needs to know that the desired binding of make-promise
is the one apparent in delay's defining package, not in the
package being loaded or linked.