;;; This file defines the base flavors for compiler objects and their protocols.

;;;

;;; The function of a compiler object is fairly simple: it must translate some

;;; program source into an appropriate object representation, and put that representation

;;; somewhere.

;;;

;;; A compiler object is made up of several components, which may be inter-related:

;;; - The Language Parser, which differentiates between various dialects of Lisp

;;; - The Target Architecture on which the object representation should run

;;; - The Compilation Environment

;;; - The Intermediate-Representation Optimizer

;;; - The Compilation Target, which actually disposes of the object representation

;;; (e.g. load it into virtual memory, or store it in a file)

;;;

;;; A Language Parser is responsible for all of the steps required to translate

;;; the source into an intermediate representation, including all source-to-source

;;; and source-to-pseudo-source transformations. [By pseudo-source we mean constructs

;;; which are similar in syntax to those of the source language, but which may not be

;;; understood correctly by an interpreter of the source language - "compiler-only forms",

;;; to put it another way.] The Language Parser may make use of the Target Architecture,

;;; and will certainly make use of the Compilation Environment.

;;;

;;; The task of the Target Architecture is to translate the program from its intermediate

;;; representation into an object representation that corresponds to the Instruction-Set

;;; Architecture of the machine on which the target is to be run. [Note that a "machine"

;;; can be a software emulation as well as a physical computer.] As previously stated, the

;;; Target Architecture may also be used by the Language Parser in the source-to-intermediate

;;; translation step. The Target Architecture may also interact with the

;;; Intermediate-Representation Optimizer, as described below.

;;;

;;; The Compilation Environment contains an evaluator and definitions that are needed at

;;; compile-time. Its main function is to support macroexpansion and compile-time

;;; error-checking.

;;;

;;; The Intermediate-Representation Optimizer does just what its name implies. It bases its

;;; decisions on advise from the user (e.g. the CL OPTIMIZE declaration). It may interact

;;; with the Target Architecture when the optimization is more easily implemented or disabled

;;; at this level, rather than during the intermediate-to-object translation.

;;;

;;; The Compilation Target's reponsibility is to put the object representation somewhere.

;;; This could either be the local Lisp virtual memory, a remote Lisp, either running on

;;; another piece of hardware or in a software emulation, or a file of some kind.

Skimming through the Genera source just now, I enjoyed this description of the compiler structure (from sys2/compiler_protocol.lisp), which precedes a very modern-feeling definition of the interface in terms of classes (or rather Flavors ) and generic functions. I wonder who wrote it.