% -*- Mode: TeX -*-

% !!! Moon wonders if "denote" is the right verb for talking about what "designators"
%     refer to.
%
% !!! Moon thinks the bottom header gets too close to the running text in this chapter.
%     It even overstrikes on a few pages (e.g., p26-28 of draft 10.156)
%
% Barmar thinks we should define reference terms for expressions like "left & right".
%
% Moon sez: Most occurrences of "which" in the glossary should be "that" in correct English.
% I should review this later. -kmp
%
% Think about unifying terms: "type lattice", "type hierarchy", "type hierarchy lattice",
% "directed acyclic graph".
% RPG says "hierarchy" or "dag" are ok, but not "lattice".
% Allan Wechsler (ACW@Symbolics.COM) says: 
%  Regarding DAGs vs. lattices: I don't know the basis of Dick Gabriel's
%  objection to the latter term.  I think that it's quite clear
%  mathematically that "lattice" is correct and "directed acyclic graph" is
%  incorrect, but Gabriel's objection may not be mathematical.  Details on
%  request.  I'm using the definitions from the ``Encyclopedic Dictionary of
%  Mathematics.''
%
% Think about these terms, which are commonly used without definition:
%   "qualifier pattern" - something that gets matched against in method comb.
%   "type specifier list" - the list form of a type specifier
%   "default value"
%   "optional parameter", ...
%
% Think about these terms, which are common concepts in search of a name, to cut
% down on wasted verbiage at multiple places in the text.
%   "stringname" - a string or a symbol, which is taken the name of a string.
%                  if a symbol, then then it is treated as if its name had been supplied.
%
% Sometime search for braces immediately followed by an alpha char 
% ("{...}s", "{...}es", "{...}ing", "{...}ed", etc.) because these are often
% clues to needed glossary words.
%
% KMP: Maybe a term "user symbol" being defined as 
%      "a symbol that is not accessible in the common-lisp package".
%    (I find it cumbersome to write a param description that says
%     a symbol that is not in the common-lisp package.
%    This comes up in a number of places.)
% Barmar: That sounds like a reasonable term and definition.
% KMP: Issue--some places might need a restriction on keywords, too, but that should
%    probably not be piggy-backed on the "user symbol" term.

\def\gentry#1{\itemitem{}\b{#1}\idxterm{#1}}
\def\gexample#1{{``#1''}}
\def\indextab#1{\endlist\indextabnote{#1}\beginlist}
\def\firstindextab#1{\indextabnote{#1}\beginlist}
\def\indextabnote#1{\goodbreak\item{\b{#1}}\penalty20000}
 
\def\Noun{\i{n.}}
\def\Verb{\i{v.}}
\def\TransitiveVerb{\i{v.t.}}
\def\Adjective{\i{adj.}}
\def\Adverb{\i{adv.}}

\def\ANSI{\i{ANSI}}
\def\IEEE{\i{IEEE}}
\def\ISO{\i{ISO}}
\def\Traditional{\i{Trad.}}
\def\Mathematics{\i{Math.}}
\def\Idiomatic{\i{Idiom.}}
\def\Computers{\i{Comp.}}

%% Glossary
 
Each entry in this glossary has the following parts:
 
\beginlist
 
\item{\bull} the term being defined, set in boldface.
 
 \item{\bull} optional pronunciation, enclosed in square brackets and
set in boldface, as in the following example:
\pronounced{\Stress{a}\stress{list}}.  The pronunciation key follows
\WebstersDictionary\TypographyCaveats.
 
 \item{\bull} the part or parts of speech, set in italics.  If a term
can be used as several parts of speech, there is a separate definition
for each part of speech.
 
 \item{\bull} one or more definitions, organized as follows:
 
\beginlist
 
 \item{--} an optional number, present if there are several
definitions. Lowercase letters might also be used in cases where subdefinitions of
a numbered definition are necessary.
 
 \item{--} an optional part of speech, set in italics, present if the
term is one of several parts of speech.
 
 \item{--} an optional discipline, set in italics, present if the term
has a standard definition being repeated. For example, ``{\Mathematics}''
 
 \item{--} an optional context, present if this definition is
meaningful only in that context. For example, ``(of a \term{symbol})''.
 
 \item{--} the definition.
 
 \item{--} an optional example sentence. For example,
           \gexample{This is an example of an example.}
 
 \item{--} optional cross references.
%%There are a lot of options, and they are all pretty self-explanatory. -kmp 11-Sep-91
%A cross reference to another word uses the following form: \Seeterm{word}.
%A cross reference to a section uses the following form: \Seesection\Sample.
 
\endlist
\endlist
 
In addition, some terms have idiomatic usage in the Common Lisp
community which is not shared by other communities, or which is not
technically correct.  Definitions labeled ``{\Idiomatic}'' represent
such idiomatic usage; these definitions are sometimes followed by an
explanatory note.
 
Words in \term{this font} are words with entries in the glossary.
%Word in \typeref{this font} are names of data types.
Words in example sentences do not follow this convention.
 
When an ambiguity arises, the longest matching substring has precedence.
For example, ``\term{complex float}'' refers to a single glossary entry 
for ``\term{complex float}'' rather than the combined meaning of the 
glossary terms ``\term{complex}'' and ``\term{float}.''

Subscript notation, as in ``\term{something}\meaning{n}'' means that
the \i{n}th definition of ``\term{something}'' is intended.  This
notation is used only in situations where the context might be insufficient
to disambiguate.

The following are abbreviations used in the glossary:
 
\tabletwo{Abbreviation}{Meaning}{
\entry{\Adjective}{adjective}
\entry{\Adverb}{adverb}
\entry{\ANSI}{compatible with one or more ANSI standards}
\entry{\Computers}{computers}
\entry{\Idiomatic}{idiomatic}
\entry{\IEEE}{compatible with one or more IEEE standards}
\entry{\ISO}{compatible with one or more ISO standards}
\entry{\Mathematics}{mathematics}
\entry{\Traditional}{traditional}
\entry{\Noun}{noun}
\entry{\Verb}{verb}
\entry{\TransitiveVerb}{transitive verb}
}
 
\beginlist

\firstindextab{Non-alphabetic}

\gentry{()} \pronounced{\Stress{nil}}, \Noun\
  an alternative notation for writing the symbol~\nil, used to emphasize
  the use of \term{nil} as an \term{empty list}.

\indextab{A}

\gentry{absolute} \Adjective\
  1. (of a \term{time})
     representing a specific point in time.
  2. (of a \term{pathname})
     representing a specific position in a directory hierarchy.
  \Seeterm{relative}.

\gentry{access} \Noun, \TransitiveVerb\
%\term{variable} removed since generalized reference implies it.
  1. \TransitiveVerb\ (a \term{place}, or \term{array})
     to \term{read}\meaning{1} or \term{write}\meaning{1} the \term{value} of
         the \term{place}
      or an \term{element} of the \term{array}.
  2. \Noun\ (of a \term{place})
     an attempt to \term{access}\meaning{1} the \term{value} of the \term{place}.

% Moon: Useless entry. Adds nothing to normal English usage.
% KMP: Allows usage to be italicized; also, courtesy to non-native 
%      English speakers, who may not be as familiar with all our word forms.
\gentry{accessibility} \Noun\
  the state of being \term{accessible}.

%!!! Moon: accessible[1] and reference[2] don't seem to match up.
\gentry{accessible} \Adjective\ 
  1. (of an \term{object}) capable of being \term{referenced}.
  2. (of \term{shared slots} or \term{local slots} in an \term{instance} of 
     a \term{class}) having been defined by the \term{class} 
     of the \term{instance} or \term{inherited} from a
     \term{superclass} of that \term{class}.
%!!! JonL: this reader thing should be an effect, not the definition.
%          use "present" and "inherited".
  3. (of a \term{symbol} in a \term{package})
     capable of being \term{referenced} without a \term{package prefix} 
     when that \term{package} is current, regardless of whether the
     \term{symbol} is \term{present} in that \term{package} or is \term{inherited}.

\gentry{accessor} \Noun\
  an \term{operator} that performs an \term{access}.
  \Seeterm{reader} and \term{writer}.

\gentry{active} \Adjective\ 
  1. (of a \term{handler}, a \term{restart}, or a \term{catch tag})
     having been \term{established} but not yet \term{disestablished}.
  2. (of an \term{element} of an \term{array})
     having an index that is greater than or equal to zero,
     but less than the \term{fill pointer} (if any).
     For an \term{array} that has no \term{fill pointer},
     all \term{elements} are considered \term{active}.

\gentry{actual adjustability} \Noun\ (of an \term{array})
  a \term{generalized boolean} that is associated with the \term{array}, 
  representing whether the \term{array} is \term{actually adjustable}.
  \SeetermAlso{expressed adjustability} and \funref{adjustable-array-p}.

\gentry{actual argument} \Noun\ \Traditional\ 
  an \term{argument}.

\gentry{actual array element type} \Noun\ (of an \term{array})
  the \term{type} for which the \term{array} is actually specialized,
  which is the \term{upgraded array element type} of 
  the \term{expressed array element type} of the \term{array}.
  \Seefun{array-element-type}.

\gentry{actual complex part type} \Noun\ (of a \term{complex})
  the \term{type} in which the real and imaginary parts of the \term{complex}
  are actually represented, which is the \term{upgraded complex part type} of the
  \term{expressed complex part type} of the \term{complex}.

\gentry{actual parameter} \Noun\ \Traditional\ 
  an \term{argument}.

\gentry{actually adjustable} \Adjective\ (of an \term{array})
  such that \funref{adjust-array} can adjust its characteristics
  by direct modification.
  A \term{conforming program} may depend on
  an \term{array} being \term{actually adjustable}
  only if either that \term{array} is known to have been \term{expressly adjustable}
  or if that \term{array} has been explicitly tested by \funref{adjustable-array-p}.

\gentry{adjustability} \Noun\ (of an \term{array})
  1. \term{expressed adjustability}.
  2. \term{actual adjustability}.

\gentry{adjustable} \Adjective\ (of an \term{array})
  1. \term{expressly adjustable}.
  2. \term{actually adjustable}.

\gentry{after method} \Noun\
  a \term{method} having the \term{qualifier} \kwd{after}.

\gentry{alist} \pronounced{\Stress{\harda}\stress{list}}, \Noun\ 
  an \term{association list}.
 
\gentry{alphabetic} \Noun, \Adjective\
%% 13.2.0 12
  1. \Adjective\ (of a \term{character})
     being one of the \term{standard characters} \f{A} through \f{Z} 
         or \f{a} through \f{z},
      or being any \term{implementation-defined} character that has \term{case},
      or being some other \term{graphic} \term{character}
         defined by the \term{implementation} to be \term{alphabetic}\meaning{1}.
  2. a. \Noun\
        one of several possible \term{constituent traits} of a \term{character}.
        For details, \seesection\ConstituentChars\ and \secref\ReaderAlgorithm.
     b. \Adjective\ (of a \term{character})
        being a \term{character} 
              that has \term{syntax type} \term{constituent} in the \term{current readtable} 
	  and that has the \term{constituent trait} \term{alphabetic}\meaning{2a}.
	\Seefigure\ConstituentTraitsOfStdChars.

\gentry{alphanumeric} \Adjective\ (of a \term{character})
%% 13.2.0 12
  being either an \term{alphabetic}\meaning{1} \term{character}
            or a \term{numeric} {character}.

\gentry{ampersand} \Noun\
  the \term{standard character} that is called ``ampersand'' (\f{\&}).
  \Seefigure\StdCharsThree.

\gentry{anonymous} \Adjective\ 
  1. (of a \term{class} or \term{function}) having no \term{name}
  2. (of a \term{restart}) having a \term{name} of \nil.

\gentry{apparently uninterned} \Adjective\ 
  having a \term{home package} of \nil.  (An \term{apparently uninterned} \term{symbol} 
  might or might not be an \term{uninterned} \term{symbol}.  \term{Uninterned symbols}
  have a \term{home package} of \nil, but \term{symbols} which have been \term{uninterned}
  from their \term{home package} also have a \term{home package} of \nil,
  even though they might still be \term{interned} in some other \term{package}.)

%!!! Moon: Need to reconcile this entry with the following three.
\gentry{applicable} \Adjective\
  1. (of a \term{handler}) being an \term{applicable handler}.
  2. (of a \term{method}) being an \term{applicable method}.
  3. (of a \term{restart}) being an \term{applicable restart}.

\gentry{applicable handler} \Noun\ (for a \term{condition} being \term{signaled})
  an \term{active} \term{handler} for which the associated type contains the
  \term{condition}.

\gentry{applicable method} \Noun\ (of a \term{generic function}
				     called with \term{arguments})
  a \term{method} of the \term{generic function} for which the
  \term{arguments} satisfy the \term{parameter specializers} 
  of that \term{method}.
% and which has not been \term{shadowed}\meaning{2}.
%Moon says: ``applicableness does not take method combination into account
%             and shadowing is a property of method combination.''
  \Seesection\SelApplMeth.

\issue{CONDITION-RESTARTS:PERMIT-ASSOCIATION}
\gentry{applicable restart} \Noun\
  1. (for a \term{condition})
     an \term{active} \term{handler} for which the associated test returns 
     \term{true} when given the \term{condition} as an argument.
  2. (for no particular \term{condition})
     an \term{active} \term{handler} for which the associated test returns 
     \term{true} when given \nil\ as an argument.
\endissue{CONDITION-RESTARTS:PERMIT-ASSOCIATION}

\gentry{apply} \TransitiveVerb\ (a \term{function} to a \term{list})
  to \term{call} the \term{function} with arguments that are the \term{elements}
  of the \term{list}.
  \gexample{Applying the function \funref{+} to a list of integers returns
	    the sum of the elements of that list.} 

\gentry{argument} \Noun\
  1. (of a \term{function}) an \term{object} which is offered as data
     to the \term{function} when it is \term{called}.
%% I wonder if we should say this. -kmp
%    In other literature, but not here, this is sometimes called an ``actual argument.''
%
% 1. (of a \term{function}) an \term{object} which is paired 
%    with a corresponding \term{parameter} in order to provide data
%    flow into the function at the time it is called.
% Moon says:
%   ``Not all arguments have corresponding parameters, when the function accepts
%     keyword or rest arguments.  Consider \kwd{allow-other-keys}.  Thus this definition
%     cannot be exactly correct.  I don't think the definition of arguments should
%     have anything to do with what the function does internally to receive the
%     arguments.''
\issue{FORMAT-STRING-ARGUMENTS:SPECIFY}
  2. (of a \term{format control}) a \term{format argument}.
\endissue{FORMAT-STRING-ARGUMENTS:SPECIFY}

\gentry{argument evaluation order} \Noun\ 
  the order in which \term{arguments} are evaluated in a function call.
  \gexample{The argument evaluation order for Common Lisp is left to right.}
  \Seesection\Evaluation.

\gentry{argument precedence order} \Noun\
  the order in which the \term{arguments} to a \term{generic function} are
  considered when sorting the \term{applicable methods} into precedence order.

\gentry{around method} \Noun\
  a \term{method} having the \term{qualifier} \kwd{around}.

\gentry{array} \Noun\
  an \term{object} \oftype{array}, which serves as a container for other
  \term{objects} arranged in a Cartesian coordinate system.

\gentry{array element type} \Noun\ (of an \term{array})
  1. a \term{type} associated with the \term{array}, 
     and of which all \term{elements} of the \term{array} are 
     constrained to be members.
  2. the \term{actual array element type} of the \term{array}.
  3. the \term{expressed array element type} of the \term{array}.

\gentry{array total size} \Noun\ 
  the total number of \term{elements} in an \term{array}, computed by taking 
  the product of the \term{dimensions} of the \term{array}.
  (The size of a zero-dimensional \term{array} is therefore one.)

\gentry{assign} \TransitiveVerb\ (a \term{variable})
  to change the \term{value} of the \term{variable} in a \term{binding}
  that has already been \term{established}.
  \Seespec{setq}.

\gentry{association list} \Noun\ 
  a \term{list} of \term{conses} representing an association 
  of \term{keys} with \term{values}, where the \term{car} of each
  \term{cons} is the \term{key} and the \term{cdr} is the
  \term{value} associated with that \term{key}.
 
\gentry{asterisk} \Noun\
  the \term{standard character} that is variously called
      ``asterisk''
   or ``star'' (\f{*}).
  \Seefigure\StdCharsThree.

\gentry{at-sign} \Noun\
  the \term{standard character} that is variously called
     ``commercial at''
  or ``at sign'' (\f{@}).
  \Seefigure\StdCharsThree.

\gentry{atom} \Noun\
  any \term{object} that is not a \term{cons}.
  \gexample{A vector is an atom.}

\gentry{atomic} \Adjective\ 
  being an \term{atom}.
  \gexample{The number 3, the symbol \f{foo}, and \nil\ are atomic.}

\gentry{atomic type specifier} \Noun\
  a \term{type specifier} that is \term{atomic}.
  For every \term{atomic type specifier}, \i{x}, there is an equivalent
  \term{compound type specifier} with no arguments supplied, \f{(\i{x})}.

\gentry{attribute} \Noun\ (of a \term{character})
  a program-visible aspect of the \term{character}.
  The only \term{standardized} \term{attribute} of a \term{character}
  is its \term{code}\meaning{2}, but \term{implementations} are permitted to have
  additional \term{implementation-defined} \term{attributes}.
  \Seesection\CharacterAttributes.
  \gexample{An implementation that support fonts
            might make font information an attribute of a character,
            while others might represent font information separately from characters.}

\gentry{aux variable} \Noun\
  a \term{variable} that occurs in the part of a \term{lambda list}
  that was introduced by \keyref{aux}.  Unlike all other \term{variables}
  introduced by a \term{lambda-list}, \term{aux variables} are not 
  \term{parameters}.

\gentry{auxiliary method} \Noun\
  a member of one of two sets of \term{methods} 
  (the set of \term{primary methods} is the other)
  that form an exhaustive partition of the set of \term{methods}
  on the \term{method}'s \term{generic function}.
  How these sets are determined is dependent on the \term{method combination} type;
  \seesection\IntroToMethods.

\indextab{B}
 
\gentry{backquote} \Noun\
  the \term{standard character} that is variously called
       ``grave accent'' 
    or ``backquote'' (\f{`}).
  \Seefigure\StdCharsThree.

\gentry{backslash} \Noun\
  the \term{standard character} that is variously called
       ``reverse solidus'' 
    or ``backslash'' (\f{\\}).
  \Seefigure\StdCharsThree.

\gentry{base character} \Noun\
  a \term{character}
\issue{CHARACTER-VS-CHAR:LESS-INCONSISTENT-SHORT}
  \oftype{base-char}.
\endissue{CHARACTER-VS-CHAR:LESS-INCONSISTENT-SHORT}

\gentry{base string} \Noun\
  a \term{string} \oftype{base-string}.

\gentry{before method} \Noun\
  a \term{method} having the \term{qualifier} \kwd{before}.

\gentry{bidirectional} \Adjective\ (of a \term{stream})
  being both an \term{input} \term{stream} and an \term{output} \term{stream}.

\gentry{binary} \Adjective\ 
  1. (of a \term{stream})
     being a \term{stream} that has an \term{element type} that is a \subtypeof{integer}.
     The most fundamental operation on a \term{binary} \term{input} \term{stream} 
     is \funref{read-byte} and on a \term{binary} \term{output} \term{stream} 
     is \funref{write-byte}.
     \Seeterm{character}.
  2. (of a \term{file})
     having been created by opening a \term{binary} \term{stream}.
     (It is \term{implementation-dependent} whether this is an detectable aspect 
      of the \term{file}, or whether any given \term{character} \term{file} can be
      treated as a \term{binary} \term{file}.)

%!!! JonL: In the iteration chapter, you also use this to mean to 
%          reset the value of a variable.
% KMP: Those references need to be fixed.
\gentry{bind} \TransitiveVerb\ (a \term{variable})
  to establish a \term{binding} for the \term{variable}.

\gentry{binding} \Noun\ 
  an association between a \term{name} and that which the \term{name} 
  denotes.  
  \gexample{A lexical binding is a lexical association between a 
            name and its value.}
%% Added per Boyer/Kaufmann/Moore #5 (by X3J13 vote at May 4-5, 1994 meeting).
%% -kmp 9-May-94
  When the term \term{binding} is qualified by the name of a \term{namespace},
  such as ``variable'' or ``function,'' 
  it restricts the binding to the indicated namespace, as in:
  \gexample{\specref{let} establishes variable bindings.}
  or 
  \gexample{\specref{let} establishes bindings of variables.}
 
\gentry{bit} \Noun\ 
  an \term{object} \oftype{bit}; 
  that is, the \term{integer} \f{0} or the \term{integer} \f{1}.

\gentry{bit array} \Noun\
  a specialized \term{array} that is of \term{type} \f{(array bit)},
  and whose elements are \oftype{bit}.

\gentry{bit vector} \Noun\ 
  a specialized \term{vector} that is \oftype{bit-vector},
  and whose elements are \oftype{bit}.

\gentry{bit-wise logical operation specifier} \Noun\ 
  an \term{object} which names one of the sixteen possible bit-wise logical
  operations that can be performed by the \funref{boole} function,
  and which is the \term{value} of exactly one of the
  \term{constant variables} 
  \conref{boole-clr},     \conref{boole-set},
  \conref{boole-1},       \conref{boole-2},
  \conref{boole-c1},      \conref{boole-c2},
  \conref{boole-and},     \conref{boole-ior},
  \conref{boole-xor},     \conref{boole-eqv},
  \conref{boole-nand},    \conref{boole-nor},
  \conref{boole-andc1},   \conref{boole-andc2},
  \conref{boole-orc1}, or \conref{boole-orc2}.

\gentry{block} \Noun\
  a named lexical \term{exit point}, 
  \term{established} explicitly by \specref{block}
  		  or implicitly by \term{operators} 
		       such as \macref{loop}, \macref{do} and \macref{prog},
  to which control and values may be transfered by 
  using a \specref{return-from} \term{form} with the name of the \term{block}.

\gentry{block tag} \Noun\ 
  the \term{symbol} that, within the \term{lexical scope} 
  of a \specref{block} \term{form}, names the \term{block}
  \term{established} by that \specref{block} \term{form}.
  See \macref{return} or \specref{return-from}.

\gentry{boa lambda list} \Noun\
  a \term{lambda list} that is syntactically like an \term{ordinary lambda list},
  but that is processed in ``\b{b}y \b{o}rder of \b{a}rgument'' style.
  \Seesection\BoaLambdaLists.

\gentry{body parameter} \Noun\
  a \term{parameter} available in certain \term{lambda lists}
  which from the point of view of \term{conforming programs}
  is like a \term{rest parameter} in every way except that it is introduced
  by \keyref{body} instead of \keyref{rest}.  (\term{Implementations} are 
  permitted to provide extensions which distinguish \term{body parameters}
  and \term{rest parameters}---\eg the \term{forms} for \term{operators}
  which were defined using a \term{body parameter} might be pretty printed
  slightly differently than \term{forms} for \term{operators} which were 
  defined using \term{rest parameters}.)

\gentry{boolean} \Noun\ 
  an \term{object} \oftype{boolean};
  that is, one of the following \term{objects}: 
       the symbol~\t\   (representing \term{true}),
    or the symbol~\nil\ (representing \term{false}).
  \Seeterm{generalized boolean}.

\gentry{boolean equivalent} \Noun\ (of an \term{object} $O\sub 1$)
  any \term{object} $O\sub 2$ that has the same truth value as $O\sub 1$
  when both $O\sub 1$ and $O\sub 2$ are viewed as \term{generalized booleans}.
 
\gentry{bound} \Adjective, \TransitiveVerb\ 
  1. \Adjective\ having an associated denotation in a \term{binding}.
     \gexample{The variables named by a \specref{let} are bound within
               its body.}
     \Seeterm{unbound}.
  2. \Adjective\ having a local \term{binding} which 
     \term{shadows}\meaning{2} another. 
     \gexample{The variable \varref{*print-escape*} is bound while in
               the \funref{princ} function.}
  3. \TransitiveVerb\ the past tense of \term{bind}.

\gentry{bound declaration} \Noun\ 
  a \term{declaration} that refers to or is associated with a \term{variable}
  or \term{function} and that appears within the \term{special form} 
  that \term{establishes} the \term{variable} or \term{function},
  but before the body of that \term{special form}
% This next parenthetical remark was added because Moon thinks (and I agree)
% that rather than just "within" we need to say "at the head of the body" 
% in order to make it clear that 
%    (let ((a (let ((b 1))
%               (declare (fixnum a))
%               (expt b 100))))
%      (print a))
%    is not accidentally covered.
  (specifically, at the head of that \term{form}'s body).
%!!! Barmar: The following should be replaced by a cross-reference to a
%   	     concept section.
  (If a \term{bound declaration} refers to a \term{function} \term{binding} or
   a \term{lexical variable} \term{binding}, the \term{scope} of
   the \term{declaration} is exactly the \term{scope} of that
   \term{binding}.  If the \term{declaration} refers to a
   \term{dynamic variable} \term{binding}, the \term{scope} of
   the \term{declaration} is what the \term{scope} of the 
   \term{binding} would have been if it were lexical rather than dynamic.)
 
\gentry{bounded} \Adjective\ (of a \term{sequence} $S$,
			      by an ordered pair
			          of \term{bounding indices} $i\sub{start}$ and $i\sub{end}$)
  restricted to a subrange of the \term{elements} of $S$ that includes each \term{element}
  beginning with (and including) the one indexed by $i\sub{start}$ and
  continuing up to (but not including) the one indexed by $i\sub{end}$.

\gentry{bounding index} \Noun\ (of a \term{sequence} with \term{length} $n$)
  either of a conceptual pair of \term{integers}, $i\sub{start}$ and $i\sub{end}$,
  respectively called the ``lower bounding index'' and ``upper bounding index'',
  such that $0 \leq i\sub{start} \leq i\sub{end} \leq n$, and which therefore delimit
  a subrange of the \term{sequence} \term{bounded} by $i\sub{start}$ and $i\sub{end}$.

\gentry{bounding index designator} (for a \term{sequence})
  one of two \term{objects} that, taken together as an ordered pair, 
  behave as a \term{designator} for \term{bounding indices} of the \term{sequence}; 
  that is, they denote \term{bounding indices} of the \term{sequence},
  and are either:
      an \term{integer} (denoting itself) and \nil\ 
       (denoting the \term{length} of the \term{sequence}),
   or two \term{integers} (each denoting themselves).

\gentry{break loop} \Noun\
  A variant of the normal \term{Lisp read-eval-print loop} that is recursively
  entered, usually because the ongoing \term{evaluation} of some other \term{form}
  has been suspended for the purpose of debugging.  Often, a \term{break loop}
  provides the ability to exit in such a way as to continue the suspended computation.
  \Seefun{break}.

\gentry{broadcast stream} \Noun\
  an \term{output} \term{stream} \oftype{broadcast-stream}.

\gentry{built-in class} \Noun\
%"instance" => "generalized instance" per Quinquevirate. -kmp 14-Feb-92
  a \term{class} that is a \term{generalized instance} \ofclass{built-in-class}.

%!!! KMP: This term is confusing and should probably be called something else.
\gentry{built-in type} \Noun\
   one of the \term{types} in \figref\StandardizedAtomicTypeSpecs.

% \gentry{built-in type} \Noun\
%   one of the \term{types} in \thenextfigure.
% 
% Moon: Aren't there a bunch missing, like base-char and simple-vector.
% \displaythree{Built-in types}{
% array&integer&restart\cr
% bit-vector&long-float&sequence\cr
% character&null&short-float\cr
% complex&number&single-float\cr
% condition&package&stream\cr
% cons&pathname&string\cr
% double-float&random-state&symbol\cr
% float&ratio&vector\cr
% function&rational&\cr
% hash-table&readtable&\cr
% }

\gentry{byte} \Noun\
  1. adjacent bits within an \term{integer}.
     (The specific number of bits can vary from point to point in the program;
      \seefun{byte}.)
  2. an integer in a specified range.
% Moon: Below 0 and a power of 2?
% KMP: I'm not so sure.  In the context of OPEN, it seems to mean any integer.
     (The specific range can vary from point to point in the program;
      \seefuns{open} and \funref{write-byte}.)

\gentry{byte specifier} \Noun\
  An \term{object} of \term{implementation-dependent} nature 
  that is returned by \thefunction{byte} and
  that specifies the range of bits in an \term{integer} to be used
  as a \term{byte} by \term{functions} such as \funref{ldb}.

\indextab{C}

\gentry{cadr} \pronounced{\Stress{ka}\stress{d\schwa r}}, \Noun\ (of an \term{object})
  the \term{car} of the \term{cdr} of that \term{object}.

\gentry{call} \TransitiveVerb, \Noun\ 
  1. \TransitiveVerb\ (a \term{function} with \term{arguments})
     to cause the \term{code} represented by that \term{function} to be 
     \term{executed} in an \term{environment} where \term{bindings} for
     the \term{values} of its \term{parameters} have been \term{established}
     based on the \term{arguments}.
     \gexample{Calling the function \funref{+} with the arguments 
               \f{5} and \f{1} yields a value of \f{6}.}
  2. \Noun\ a \term{situation} in which a \term{function} is called.

\gentry{captured initialization form} \Noun\
  an \term{initialization form} along with the \term{lexical environment}
  in which the \term{form} that defined the \term{initialization form}
  was \term{evaluated}.
  \gexample{Each newly added shared slot is set to the result of evaluating
            the captured initialization form for the slot that was specified
            in the \macref{defclass} form for the new class.}

\gentry{car} \Noun\
  1. a. (of a \term{cons}) 
        the component of a \term{cons} corresponding to the first
        \term{argument} to \funref{cons}; the other component is the
        \term{cdr}.
	\gexample{The function \funref{rplaca} modifies the car of a cons.}
     b. (of a \term{list})
        the first \term{element} of the \term{list}, or \nil\ if the
        \term{list} is the \term{empty list}.
  2. the \term{object} that is held in the \term{car}\meaning{1}.
     \gexample{The function \funref{car} returns the car of a cons.}
 
\gentry{case} \Noun\ (of a \term{character})
  the property of being either \term{uppercase} or \term{lowercase}.
  Not all \term{characters} have \term{case}.
  \gexample{The characters \f{\#\\A} and \f{\#\\a} have case,
	    but the character \f{\#\\\$} has no case.}
  \Seesection\CharactersWithCase\ and \thefunction{both-case-p}.

\gentry{case sensitivity mode} \Noun\
  one of the \term{symbols}
  \kwd{upcase}, \kwd{downcase}, \kwd{preserve}, or \kwd{invert}.

\gentry{catch} \Noun\
  an \term{exit point} which is \term{established} by a \specref{catch}
  \term{form} within the \term{dynamic scope} of its body,
  which is named by a \term{catch tag},
  and to which control and \term{values} may be \term{thrown}.

\gentry{catch tag} \Noun\
  an \term{object} which names an \term{active} \term{catch}.
  (If more than one \term{catch} is active with the same \term{catch tag},
   it is only possible to \term{throw} to the innermost such \term{catch}
   because the outer one is \term{shadowed}\meaning{2}.)

\gentry{cddr} \pronounced{\Stress{k\.ud}\schwa \stress{d\schwa r}} or
	      \pronounced{\Stress{k\schwa}\stress{d\.ud\schwa r}}, \Noun\ 
	      (of an \term{object})
  the \term{cdr} of the \term{cdr} of that \term{object}.

\gentry{cdr} \pronounced{\Stress{k\.u}\stress{d\schwa r}}, \Noun\ 
  1. a. (of a \term{cons}) 
        the component of a \term{cons} corresponding to the second \term{argument}
        to \funref{cons}; the other component is the \term{car}.
	\gexample{The function \funref{rplacd} modifies the cdr of a cons.}
     b. (of a \term{list} $L\sub 1$)
        either the \term{list} $L\sub 2$ that contains 
	       the \term{elements} of $L\sub 1$ that follow after the first, 
	or else \nil\ if $L\sub 1$ is the \term{empty list}.
  2. the \term{object} that is held in the \term{cdr}\meaning{1}.
     \gexample{The function \funref{cdr} returns the cdr of a cons.}

\gentry{cell} \Noun\ \Traditional\ (of an \term{object})
  a conceptual \term{slot} of that \term{object}.
  The \term{dynamic variable} and global \term{function} \term{bindings}
  of a \term{symbol} are sometimes referred to as its \term{value cell}
  and \term{function cell}, respectively.

\gentry{character} \Noun, \Adjective\
  1. \Noun\ an \term{object} \oftype{character}; that is,
     an \term{object} that represents a unitary token in an aggregate quantity of text;
     \seesection\CharacterConcepts.
  2. \Adjective\ 
     a. (of a \term{stream})
        having an \term{element type} that is a \subtypeof{character}.
        The most fundamental operation on a \term{character} \term{input} \term{stream} 
        is \funref{read-char} and on a \term{character} \term{output} \term{stream} 
        is \funref{write-char}. \Seeterm{binary}.
     b. (of a \term{file})
        having been created by opening a \term{character} \term{stream}.
        (It is \term{implementation-dependent} whether this is an inspectable aspect 
         of the \term{file}, or whether any given \term{binary} \term{file} can be
         treated as a \term{character} \term{file}.)

%!!! Moon: This never says what it is!
\gentry{character code} \Noun\
  1. one of possibly several \term{attributes} of a \term{character}.
  2. a non-negative \term{integer} less than \thevalueof{char-code-limit}
     that is suitable for use as a \term{character code}\meaning{1}.

\gentry{character designator} \Noun\
  a \term{designator} for a \term{character}; that is,
  an \term{object} that denotes a \term{character} 
  and that is one of:
       a \term{designator} for a \term{string} of \term{length} one
         (denoting the \term{character} that is its only \term{element}),
\issue{CHARACTER-PROPOSAL:2-1-1}
% Integers used to be permitted (a la INT-CHAR), but are now removed.
\endissue{CHARACTER-PROPOSAL:2-1-1}
    or a \term{character} (denoting itself).

\gentry{circular} \Adjective\
  1. (of a \term{list}) a \term{circular list}.
  2. (of an arbitrary \term{object})
     having a \term{component}, \term{element}, \term{constituent}\meaning{2}, 
     or \term{subexpression} (as appropriate to the context) 
     that is the \term{object} itself.

\gentry{circular list} \Noun\ 
  a chain of \term{conses} that has no termination because some
 \term{cons} in the chain is the \term{cdr} of a later \term{cons}.

\gentry{class} \Noun\
  1. an \term{object} that uniquely determines the structure and behavior of 
     a set of other \term{objects} called its \term{direct instances}, 
     that contributes structure and behavior to a set of
     other \term{objects} called its \term{indirect instances},
     and that acts as a \term{type specifier} for a set of objects
     called its \term{generalized instances}.
     \gexample{The class \typeref{integer} is a subclass of the class \typeref{number}.}
     (Note that the phrase ``the \term{class} \f{foo}'' is often substituted for
      the more precise phrase ``the \term{class} named \f{foo}''---in both
      cases, a \term{class} \term{object} (not a \term{symbol}) is denoted.)
  2. (of an \term{object})
     the uniquely determined \term{class} of which the \term{object} is
     a \term{direct instance}.
     \Seefun{class-of}.
     \gexample{The class of the object returned by \funref{gensym} 
 	       is \typeref{symbol}.}
     (Note that with this usage a phrase such as ``its \term{class} is \f{foo}'' 
      is often substituted for the more precise phrase
      ``its \term{class} is the \term{class} named \f{foo}''---in both
      cases, a \term{class} \term{object} (not a \term{symbol}) is denoted.)

\gentry{class designator} \Noun\
  a \term{designator} for a \term{class}; that is,
  an \term{object} that denotes a \term{class} 
  and that is one of:
       a \term{symbol} (denoting the \term{class} named by that \term{symbol};
		        \seefun{find-class})
    or a \term{class} (denoting itself).

\gentry{class precedence list} \Noun\
  a unique total ordering on a \term{class}
  and its \term{superclasses} that is consistent with the
  \term{local precedence orders} for the \term{class} and its
  \term{superclasses}.
  For detailed information, \seesection\DeterminingtheCPL.

\gentry{close} \TransitiveVerb\ (a \term{stream})
  to terminate usage of the \term{stream} as a source or sink of data,
  permitting the \term{implementation} to reclaim its internal data structures,
  and to free any external resources which might have been locked by the
 \term{stream} when it was opened.

\gentry{closed} \Adjective\ (of a \term{stream})
  having been \term{closed} (\seeterm\term{close}).
  Some (but not all) operations that are valid on \term{open} \term{streams} 
  are not valid on \term{closed} \term{streams}.
  \Seesection\OpenAndClosedStreams.

\gentry{closure} \Noun\
  a \term{lexical closure}.
 
%"constant objects" => "literal objects" per Moon #4(first public review) --kmp 5-May-93
\gentry{coalesce} \TransitiveVerb\ (\term{literal objects} that are \term{similar})
  to consolidate the identity of those \term{objects},
  such that they become the \term{same} %was "identical". -kmp 27-Jul-93
  \term{object}.
  \Seesection\CompilationTerms.

\gentry{code} \Noun\
  1. \Traditional\ 
     any representation of actions to be performed, whether conceptual
     or as an actual \term{object}, such as
         \term{forms},
         \term{lambda expressions},
         \term{objects} of \term{type} \term{function}, 
         text in a \term{source file},
      or instruction sequences in a \term{compiled file}.
      This is a generic term;
      the specific nature of the representation depends on its context.
  2. (of a \term{character})
     a \term{character code}.

\gentry{coerce} \TransitiveVerb\ (an \term{object} to a \term{type})
  to produce an \term{object} from the given \term{object},
  without modifying that \term{object},
  by following some set of coercion rules that must be specifically 
  stated for any context in which this term is used.
  The resulting \term{object} is necessarily of the indicated \term{type}, 
  except when that type is a \subtypeof{complex}; in that case,
  if a \term{complex rational} with an imaginary part of zero would result,
  the result is a \term{rational} 
  rather than a \term{complex}---\seesection\RuleOfCanonRepForComplexRationals.

\gentry{colon} \Noun\
  the \term{standard character} that is called ``colon'' (\f{:}).
  \Seefigure\StdCharsThree.

\gentry{comma} \Noun\
  the \term{standard character} that is called ``comma'' (\f{,}).
  \Seefigure\StdCharsThree.

\gentry{compilation} \Noun\
  the process of \term{compiling} \term{code} by the \term{compiler}.

%!!! Needs to acknowledge the interpreter in case of lazy semantic processing.
\gentry{compilation environment} \Noun\ 
  1. An \term{environment} that represents information known by the
     \term{compiler} about a \term{form} that is being \term{compiled}.
     \Seesection\CompilationTerms.
  2. An \term{object} that represents the
     \term{compilation environment}\meaning{1} 
     and that is used as a second argument to a \term{macro function}
     (which supplies a \term{value} for any \keyref{environment} \term{parameter}
      in the \term{macro function}'s definition).

\gentry{compilation unit} \Noun\
  an interval during which a single unit of compilation is occurring.
  \Seemac{with-compilation-unit}.

\gentry{compile} \TransitiveVerb\ 
  1. (\term{code})
     to perform semantic preprocessing of the \term{code}, usually optimizing
     one or more qualities of the code, such as run-time speed of \term{execution}
     or run-time storage usage.  The minimum semantic requirements of compilation are
     that it must remove all macro calls and arrange for all \term{load time values}
     to be resolved prior to run time.
  2. (a \term{function})
     to produce a new \term{object} \oftype{compiled-function}
     which represents the result of \term{compiling} the \term{code} 
     represented by the \term{function}.  \Seefun{compile}.
  3. (a \term{source file})
     to produce a \term{compiled file} from a \term{source file}.
     \Seefun{compile-file}.

\gentry{compile time} \Noun\ 
  the duration of time that the \term{compiler} is processing \term{source code}.

\gentry{compile-time definition} \Noun\
  a definition in the \term{compilation environment}.

\gentry{compiled code} \Noun\
  1. \term{compiled functions}.
  2. \term{code} that represents \term{compiled functions},
     such as the contents of a \term{compiled file}.

\gentry{compiled file} \Noun\
  a \term{file} which represents the results of \term{compiling} the 
  \term{forms} which appeared in a corresponding \term{source file},
  and which can be \term{loaded}.  \Seefun{compile-file}.

\issue{COMPILED-FUNCTION-REQUIREMENTS:TIGHTEN}
\gentry{compiled function} \Noun\
  an \term{object} \oftype{compiled-function}, which is a \term{function}
  that has been \term{compiled}, which contains no references to \term{macros} that
  must be expanded at run time, and which contains no unresolved references 
  to \term{load time values}.
\endissue{COMPILED-FUNCTION-REQUIREMENTS:TIGHTEN}

\gentry{compiler} \Noun\
  a facility that is part of Lisp and that translates \term{code}
  into an \term{implementation-dependent} form
  that might be represented or \term{executed} efficiently.
  The functions \funref{compile} and \funref{compile-file}
  permit programs to invoke the \term{compiler}.

\issue{DEFINE-COMPILER-MACRO:X3J13-NOV89}
\gentry{compiler macro} \Noun\
  an auxiliary macro definition for a globally defined \term{function}
  or \term{macro} which might or might not be called by any given
  \term{conforming implementation} and which must preserve the semantics
  of the globally defined \term{function} or \term{macro} but which might
  perform some additional optimizations.  (Unlike a \term{macro}, 
  a \term{compiler macro} does not extend the syntax of \clisp; rather, it
  provides an alternate implementation strategy for some existing syntax
  or functionality.)

\gentry{compiler macro expansion} \Noun\
  1. the process of translating a \term{form} into another \term{form}
     by a \term{compiler macro}.
  2. the \term{form} resulting from this process.

\gentry{compiler macro form} \Noun\
  a \term{function form} or \term{macro form} whose \term{operator}
  has a definition as a \term{compiler macro}, 
  or a \funref{funcall} \term{form} whose first \term{argument} is a
  \specref{function} \term{form} whose \term{argument} is the \term{name}
  of a \term{function} that has a definition as a \term{compiler macro}.

\gentry{compiler macro function} \Noun\ 
  a \term{function} of two arguments, a \term{form} and an 
  \term{environment}, that implements \term{compiler macro expansion} by
  producing either a \term{form} to be used in place of the original
  argument \term{form} or else \nil, indicating that the original \term{form}
  should not be replaced.  \Seesection\CompilerMacros.
\endissue{DEFINE-COMPILER-MACRO:X3J13-NOV89}

\gentry{complex} \Noun\
  an \term{object} \oftype{complex}.

\gentry{complex float} \Noun\
  an \term{object} \oftype{complex} which has a \term{complex part type}
  that is a \term{subtype} of \typeref{float}.
  A \term{complex float} is a \term{complex},
  but it is not a \term{float}.

\gentry{complex part type} \Noun\ (of a \term{complex})
  1. the \term{type} which is used to represent both the real part 
     and the imaginary part of the \term{complex}.
  2. the \term{actual complex part type} of the \term{complex}.
  3. the \term{expressed complex part type} of the \term{complex}.

\gentry{complex rational} \Noun\
  an \term{object} \oftype{complex} which has a \term{complex part type}
  that is a \term{subtype} of \typeref{rational}.
  A \term{complex rational} is a \term{complex}, but it is not a \term{rational}.  
  No \term{complex rational} has an imaginary part of zero because such a
  number is always represented by \clisp\ as an \term{object} \oftype{rational};
  \seesection\RuleOfCanonRepForComplexRationals.

\gentry{complex single float} \Noun\
  an \term{object} \oftype{complex} which has a \term{complex part type}
  that is a \term{subtype} of \typeref{single-float}.
  A \term{complex single float} is a \term{complex},
  but it is not a \term{single float}.

\gentry{composite stream} \Noun\
  a \term{stream} that is composed of one or more other \term{streams}.
  \gexample{\funref{make-synonym-stream} creates a composite stream.}
 
\gentry{compound form} \Noun\
  a \term{non-empty} \term{list} which is a \term{form}:
  a \term{special form},
  a \term{lambda form},
  a \term{macro form}, 
  or a \term{function form}.

\gentry{compound type specifier} \Noun\
  a \term{type specifier} that is a \term{cons};
  \ie a \term{type specifier} that is not an \term{atomic type specifier}.
  \gexample{\f{(vector single-float)} is a compound type specifier.}

\gentry{concatenated stream} \Noun\
  an \term{input} \term{stream} \oftype{concatenated-stream}.

\gentry{condition} \Noun\
  1. an \term{object} which represents a \term{situation}---usually,
     but not necessarily, during \term{signaling}.
  2. an \term{object} \oftype{condition}.

\gentry{condition designator} \Noun\
  one or more \term{objects} that, taken together, 
  denote either an existing \term{condition} \term{object} 
	     or a \term{condition} \term{object} to be implicitly created.
  For details, \seesection\ConditionDesignators.

\gentry{condition handler} \Noun\
  a \term{function} that might be invoked by the act of \term{signaling},
  that receives the \term{condition} being signaled as its only argument,
  and that is permitted to \term{handle} the \term{condition} 
  or to \term{decline}.  \Seesection\Signaling.

\gentry{condition reporter} \Noun\
  a \term{function} that describes how a \term{condition} is to be printed
  when the \term{Lisp printer} is invoked while \varref{*print-escape*} 
  is \term{false}.  \Seesection\PrintingConditions.

\gentry{conditional newline} \Noun\
  a point in output where a \term{newline} might be inserted at the
  discretion of the \term{pretty printer}.
  There are four kinds of \term{conditional newlines},
  called ``linear-style,''
	 ``fill-style,''
	 ``miser-style,''
     and ``mandatory-style.''
  \Seefun{pprint-newline} and \secref\DynamicControlofOutput.

\gentry{conformance} \Noun\
  a state achieved by proper and complete adherence to the requirements
  of this specification.  \Seesection\Conformance.

\gentry{conforming code} \Noun\
  \term{code} that is all of part of a \term{conforming program}.

\gentry{conforming implementation} \Noun\
  an \term{implementation}, used to emphasize complete and correct
  adherance to all conformance criteria.
  A \term{conforming implementation} is capable of 
      accepting a \term{conforming program} as input,
      preparing that \term{program} for \term{execution},
  and executing the prepared \term{program} in accordance with this specification.
  An \term{implementation} which
  has been extended may still be a \term{conforming implementation} 
  provided that no extension interferes with the correct function of any
  \term{conforming program}.

\gentry{conforming processor} \Noun\ \ANSI\ 
  a \term{conforming implementation}.

\gentry{conforming program} \Noun\
  a \term{program}, used to emphasize the fact that the \term{program}
  depends for its correctness only upon documented aspects of \clisp, and
  can therefore be expected to run correctly in any \term{conforming implementation}.

\gentry{congruent} \Noun\ 
  conforming to the rules of \term{lambda list} congruency, as detailed in 
  \secref\GFMethodLambdaListCongruency.

\gentry{cons} \Noun\Verb\ 
  1. \Noun\ a compound data \term{object} having two components called the
     \term{car} and the \term{cdr}.
  2. \Verb\ to create such an \term{object}.
  3. \Verb\ \Idiomatic\ to create any \term{object}, or to allocate storage.

\gentry{constant} \Noun\
  1. a \term{constant form}.
  2. a \term{constant variable}.
  3. a \term{constant object}.
  4. a \term{self-evaluating object}.

\gentry{constant form} \Noun\
  any \term{form}
   for which \term{evaluation} always \term{yields} the same \term{value},
   that neither affects nor is affected by the \term{environment}
     in which it is \term{evaluated} (except that it is permitted to
     refer to the names of \term{constant variables} 
     defined in the \term{environment}),
   and
   that neither affects nor is affected by the state of any \term{object}
     except those \term{objects} that are \term{otherwise inaccessible parts}
     of \term{objects} created by the \term{form} itself.
  \gexample{A \funref{car} form in which the argument is a
            \specref{quote} form is a constant form.}

\gentry{constant object} \Noun\
  an \term{object} that is constrained (\eg by its context in a \term{program}
  or by the source from which it was obtained) to be \term{immutable}.
  \gexample{A literal object that has been processed by \funref{compile-file}
	    is a constant object.}

\gentry{constant variable} \Noun\
  a \term{variable}, the \term{value} of which can never change;
  that is, a \term{keyword}\meaning{1} or a \term{named constant}.
  \gexample{The symbols \t, \nil, \kwd{direction}, and
            \conref{most-positive-fixnum}\ are constant variables.}

\gentry{constituent} \Noun, \Adjective\
  1. a. \Noun\ the \term{syntax type} of a \term{character} that is part of a \term{token}.
         For details, \seesection\ConstituentChars.
     b. \Adjective\ (of a \term{character})
        having the \term{constituent}\meaning{1a} \term{syntax type}\meaning{2}.
     c. \Noun\ a \term{constituent}\meaning{1b} \term{character}.
  2. \Noun\ (of a \term{composite stream})
     one of possibly several \term{objects} that collectively comprise
     the source or sink of that \term{stream}.

\gentry{constituent trait} \Noun\ (of a \term{character})
  one of several classifications of a \term{constituent} \term{character}
  in a \term{readtable}.  \Seesection\ConstituentChars.

\gentry{constructed stream} \Noun\ 
  a \term{stream} whose source or sink is a Lisp \term{object}.
  Note that since a \term{stream} is another Lisp \term{object},
  \term{composite streams} are considered \term{constructed streams}.
  \gexample{A string stream is a constructed stream.}

\gentry{contagion} \Noun\
  a process whereby operations on \term{objects} of differing \term{types}
  (\eg arithmetic on mixed \term{types} of \term{numbers}) produce a result
  whose \term{type} is controlled by the dominance of one \term{argument}'s
  \term{type} over the \term{types} of the other \term{arguments}.
  \Seesection\NumericContagionRules.

\gentry{continuable} \Noun\ (of an \term{error})
  an \term{error} that is \term{correctable} by the \f{continue} restart.

\gentry{control form} \Noun\
  1. a \term{form} that establishes one or more places to which control
     can be transferred.
  2. a \term{form} that transfers control.
% Moon says he can't think of any form which doesn't match this:
% 3. a \term{form} from which control can be transferred.

\gentry{copy} \Noun\
  1. (of a \term{cons} $C$)
     a \term{fresh} \term{cons} with the \term{same} \term{car} and \term{cdr} as $C$.
  2. (of a \term{list} $L$)
     a \term{fresh} \term{list} with the \term{same} \term{elements} as $L$.  
     (Only the \term{list structure} is \term{fresh};
      the \term{elements} are the \term{same}.)
     \Seefun{copy-list}.
  3. (of an \term{association list} $A$ with \term{elements} $A\sub{i}$)
     a \term{fresh} \term{list} $B$ with \term{elements} $B\sub{i}$, each of which is
     \nil\ if $A\sub i$ is \nil, or else a \term{copy} of the \term{cons} $A\sub i$.
     \Seefun{copy-alist}.
  4. (of a \term{tree} $T$)
     a \term{fresh} \term{tree} with the \term{same} \term{leaves} as $T$.
     \Seefun{copy-tree}.
  5. (of a \term{random state} $R$)
     a \term{fresh} \term{random state} that, if used as an argument to
     to \thefunction{random} would produce the same series of ``random''
     values as $R$ would produce.
\issue{DEFSTRUCT-COPIER:ARGUMENT-TYPE}
  6. (of a \term{structure} $S$)
     a \term{fresh} \term{structure} that has the same \term{type} as $S$,
     and that has slot values, each of which is the \term{same} as the 
     corresponding slot value of $S$.
\endissue{DEFSTRUCT-COPIER:ARGUMENT-TYPE}
%% Proposed:
%   7. (of an \term{array} $A\sub 1$)
%      a \term{fresh} \term{array} $A\sub 2$
%      with the same \term{array element type} as $A\sub 1$
%      and the \term{same} \term{active} \term{elements} as $A\sub 1$.
%   8. (of a \term{readtable} $R\sub 1$)
%      a \term{fresh} \term{readtable} $R\sub 2$
%      that has the same \term{readtable case} as $R\sub 1$
%      and whose associations between \term{macro characters} 
%        			        and their \term{reader macro functions}
%      are distinct from those of $R\sub 1$.
% 
  (Note that since the difference between a \term{cons}, a \term{list}, 
   and a \term{tree} is a matter of ``view'' or ``intention,''  there can
   be no general-purpose \term{function} which, based solely on the \term{type}
   of an \term{object}, can determine which of these distinct meanings is 
   intended.  The distinction rests solely on the basis of the text description
   within this document.  For example, phrases like ``a \term{copy} of the
   given \term{list}'' or ``copy of the \term{list} \param{x}'' imply the
   second definition.)

\gentry{correctable} \Adjective\ (of an \term{error})
  1. (by a \term{restart} other than \misc{abort} 
      that has been associated with the \term{error})
     capable of being corrected by invoking that \term{restart}.
     \gexample{The function \funref{cerror} signals an error 
	       that is correctable by the \misc{continue} \term{restart}.}
\issue{CONDITION-RESTARTS:PERMIT-ASSOCIATION}
     (Note that correctability is not a property of an
      \term{error} \term{object}, but rather a property of the 
      \term{dynamic environment} that is in effect when the
      \term{error} is \term{signaled}.
      Specifically, the \term{restart} is ``associated with'' 
      the \term{error} \term{condition} \term{object}.
      \Seesection\AssocRestartWithCond.)
\endissue{CONDITION-RESTARTS:PERMIT-ASSOCIATION}
  2. (when no specific \term{restart} is mentioned)
     \term{correctable}\meaning{1} by at least one \term{restart}.
     \gexample{\funref{import} signals a correctable error \oftype{package-error}
	       if any of the imported symbols has the same name as
	        some distinct symbol already accessible in the package.}

\gentry{current input base} \Noun\ (in a \term{dynamic environment})
  the \term{radix} that is \thevalueof{*read-base*} in that \term{environment}, 
  and that is the default \term{radix} employed by the \term{Lisp reader}
  and its related \term{functions}.

\gentry{current logical block} \Noun\
  the context of the innermost lexically enclosing use of \macref{pprint-logical-block}.

\gentry{current output base} \Noun\ (in a \term{dynamic environment})
  the \term{radix} that is \thevalueof{*print-base*} in that \term{environment}, 
  and that is the default \term{radix} employed by the \term{Lisp printer}
  and its related \term{functions}.

\gentry{current package} \Noun\ (in a \term{dynamic environment})
  the \term{package} that is \thevalueof{*package*} in that \term{environment}, 
  and that is the default \term{package} employed by the \term{Lisp reader} 
  and \term{Lisp printer}, and their related \term{functions}.

% Added for consistency with other "current xxx" terms. -kmp 27-Aug-93
\gentry{current pprint dispatch table} \Noun\ (in a \term{dynamic environment})
  the \term{pprint dispatch table} that is \thevalueof{*print-pprint-dispatch*}
  in that \term{environment}, and that is the default \term{pprint dispatch table}
  employed by the \term{pretty printer}.

\gentry{current random state} \Noun\ (in a \term{dynamic environment})
  the \term{random state} that is \thevalueof{*random-state*} in that \term{environment}, 
  and that is the default \term{random state} employed by \funref{random}.

\gentry{current readtable} \Noun\ (in a \term{dynamic environment})
  the \term{readtable} that is \thevalueof{*readtable*} in that \term{environment}, 
  and that affects the way in which \term{expressions}\meaning{2} are parsed 
  into \term{objects} by the \term{Lisp reader}.

\indextab{D}

\gentry{data type} \Noun\ \Traditional\ 
  a \term{type}.

\gentry{debug I/O} \Noun\ 
  the \term{bidirectional} \term{stream} 
  that is the \term{value} of \thevariable{*debug-io*}.

\gentry{debugger} \Noun\
  a facility that allows the \term{user} to handle a \term{condition} interactively.
  For example, the \term{debugger} might permit interactive
  selection of a \term{restart} from among the \term{active} \term{restarts},
  and it might perform additional \term{implementation-defined} services
  for the purposes of debugging.

\gentry{declaration} \Noun\
  a \term{global declaration} or \term{local declaration}.

\gentry{declaration identifier} \Noun\
  one of the \term{symbols}
     \declref{declaration},
     \declref{dynamic-extent},
     \declref{ftype},
     \declref{function},
     \declref{ignore}, 
     \declref{inline},  
     \declref{notinline},
     \declref{optimize}, 
     \declref{special}, 
  or \declref{type};
  or a \term{symbol} which is the \term{name} of a \term{type};
  or a \term{symbol} which has been \term{declared}
     to be a \term{declaration identifier} by using a \declref{declaration}
     \term{declaration}.
\issue{SYNTACTIC-ENVIRONMENT-ACCESS:RETRACTED-MAR91}
% or by using \funref{define-declaration}.
\endissue{SYNTACTIC-ENVIRONMENT-ACCESS:RETRACTED-MAR91}

\gentry{declaration specifier} \Noun\
  an \term{expression} that can appear at top level of a \misc{declare} 
  expression or a \macref{declaim} form, or as the argument to \funref{proclaim},
  and which has a \term{car} which is a \term{declaration identifier},
  and which has a \term{cdr} that is data interpreted according to rules
  specific to the \term{declaration identifier}.

\gentry{declare} \Verb\ 
  to \term{establish} a \term{declaration}.
  \Seemisc{declare}, \macref{declaim}, or \funref{proclaim}.

\gentry{decline} \Verb\ (of a \term{handler})
  to return normally without having \term{handled} the \term{condition}
  being \term{signaled}, permitting the signaling process to continue
  as if the \term{handler} had not been present.

\gentry{decoded time} \Noun\
  \term{absolute} \term{time}, represented as an ordered series of
  nine \term{objects} which, taken together, form a description of
  a point in calendar time, accurate to the nearest second (except
  that \term{leap seconds} are ignored).
  \Seesection\DecodedTime.

\gentry{default method} \Noun\
  a \term{method} having no \term{parameter specializers} other than
  \theclass{t}.  Such a \term{method} is always an \term{applicable method}
  but might be \term{shadowed}\meaning{2} by a more specific \term{method}.

\gentry{defaulted initialization argument list} \Noun\
  a \term{list} of alternating initialization argument \term{names} and
  \term{values} in which unsupplied initialization arguments are
  defaulted, used in the protocol for initializing and reinitializing 
  \term{instances} of \term{classes}.

% This is new per Barrett #3 (first public review). -kmp 12-May-93
\gentry{define-method-combination arguments lambda list} \Noun\
  a \term{lambda list} used by the \kwd{arguments} option 
  to \macref{define-method-combination}.
  \Seesection\DefMethCombArgsLambdaLists.

% This is new.  --sjl 5 Mar 92
\gentry{define-modify-macro lambda list} \Noun\
  a \term{lambda list} used by \macref{define-modify-macro}.
  \Seesection\DefineModifyMacroLambdaLists.

\gentry{defined name} \Noun\
  a \term{symbol} the meaning of which is defined by \clisp.

\gentry{defining form} \Noun\
  a \term{form} that has the side-effect of \term{establishing} a definition.
  \gexample{\macref{defun} and \macref{defparameter} are defining forms.}

\gentry{defsetf lambda list} \Noun\
  a \term{lambda list} that is like an \term{ordinary lambda list} 
  except that it does not permit \keyref{aux}
     and that it permits use of \keyref{environment}.
  \Seesection\DefsetfLambdaLists.

\issue{DEFTYPE-KEY:ALLOW}
\issue{DEFTYPE-DESTRUCTURING:YES}
\gentry{deftype lambda list} \Noun\
  a \term{lambda list} that is like a \term{macro lambda list}
  except that the default \term{value} for unsupplied \term{optional parameters}
  and \term{keyword parameters} is the \term{symbol} \misc{*} (rather than \nil).
  \Seesection\DeftypeLambdaLists.
\endissue{DEFTYPE-DESTRUCTURING:YES}
\endissue{DEFTYPE-KEY:ALLOW}

\gentry{denormalized} \Adjective, \ANSI, \IEEE\ (of a \term{float})
  conforming to the description of ``denormalized'' as described by 
  {\IEEEFloatingPoint}.
  For example, in an \term{implementation} where the minimum possible exponent 
  was \f{-7} but where \f{0.001} was a valid mantissa, the number \f{1.0e-10}
  might be representable as \f{0.001e-7} internally even if the \term{normalized}
  representation would call for it to be represented instead as \f{1.0e-10} 
  or \f{0.1e-9}.  By their nature, \term{denormalized} \term{floats} generally
  have less precision than \term{normalized} \term{floats}.

\gentry{derived type} \Noun\
  a \term{type specifier} which is defined in terms of an expansion into another
  \term{type specifier}.  \macref{deftype} defines \term{derived types}, 
  and there may be other \term{implementation-defined} \term{operators}
  which do so as well.

\gentry{derived type specifier} \Noun\
  a \term{type specifier} for a \term{derived type}.

\gentry{designator} \Noun\ 
  an \term{object} that denotes another \term{object}.
  In the dictionary entry for an \term{operator}
  if a \term{parameter} is described as a \term{designator} for a \term{type},
  the description of the \term{operator} is written in a way
  that assumes that appropriate coercion to that \term{type} has already occurred;
  that is, that the \term{parameter} is already of the denoted \term{type}.
  For more detailed information, \seesection\Designators.

\gentry{destructive} \Adjective\ (of an \term{operator})
  capable of modifying some program-visible aspect of one or more
  \term{objects} that are either explicit \term{arguments} to the
  \term{operator} or that can be obtained directly or indirectly 
  from the \term{global environment} by the \term{operator}.

% This is new.  --sjl 5 Mar 92
\gentry{destructuring lambda list} \Noun\
  an \term{extended lambda list} used in \macref{destructuring-bind} and
  nested within \term{macro lambda lists}.  
  \Seesection\DestructuringLambdaLists.

\gentry{different} \Adjective\ 
  not the \term{same}
  \gexample{The strings \f{"FOO"} and \f{"foo"} are different under
	    \funref{equal} but not under \funref{equalp}.}

\gentry{digit} \Noun\ (in a \term{radix})
  a \term{character} that is among the possible digits (\f{0} to \f{9},
  \f{A} to \f{Z}, and \f{a} to \f{z}) and that is defined to have an 
  associated numeric weight as a digit in that \term{radix}.
  \Seesection\Digits.

\gentry{dimension} \Noun\
  1. a non-negative \term{integer} indicating the number of
     \term{objects} an \term{array} can hold along one axis.
     If the \term{array} is a \term{vector} with a \term{fill pointer},
     the \term{fill pointer} is ignored.
     \gexample{The second dimension of that array is 7.}
  2. an axis of an array.
     \gexample{This array has six dimensions.}
 
\gentry{direct instance} \Noun\ (of a \term{class} $C$)
  an \term{object} whose \term{class} is $C$ itself,
  rather than some \term{subclass} of $C$.
  \gexample{The function \funref{make-instance} always returns a 
  	    direct instance of the class which is (or is named by)
	    its first argument.}

\gentry{direct subclass} \Noun\ (of a \term{class} $C\sub{1}$)
  a \term{class} $C\sub{2}$,
  such that $C\sub{1}$ is a \term{direct superclass} of $C\sub{2}$.

\gentry{direct superclass} \Noun\ (of a \term{class} $C\sub{1}$)
  a \term{class} $C\sub{2}$ which was explicitly designated as 
  a \term{superclass} of $C\sub{1}$ in the definition of $C\sub{1}$.

\gentry{disestablish} \TransitiveVerb\ 
  to withdraw the \term{establishment} of 
      an \term{object},
      a  \term{binding},
      an \term{exit point}, 
      a  \term{tag},
      a  \term{handler},
      a  \term{restart}, 
   or an \term{environment}.
 
\gentry{disjoint} \Noun\ (of \term{types})
  having no \term{elements} in common.

\gentry{dispatching macro character} \Noun\ 
  a \term{macro character} that has an associated table that specifies 
  the \term{function} to be called for each \term{character} that is
  seen following the \term{dispatching macro character}.
  \Seefun{make-dispatch-macro-character}.

\gentry{displaced array} \Noun\
%Alternatively (from an old definition of make-array):
% ...an indirect or shared \term{array} that shares its contents...
  an \term{array} which has no storage of its own, but which is instead
  indirected to the storage of another \term{array}, called its
  \term{target}, at a specified offset, in such a way that any attempt
  to \term{access} the \term{displaced array} implicitly references the 
  \term{target} \term{array}.

\gentry{distinct} \Adjective\
  not \term{identical}.

\gentry{documentation string} \Noun\ (in a defining \term{form}) 
  A \term{literal} \term{string} which because of the context in which
  it appears (rather than because of some intrinsically observable 
  aspect of the \term{string}) is taken as documentation.
  In some cases, the \term{documentation string} is saved in such a
  way that it can later be obtained by supplying either an \term{object}, 
  or by supplying a \term{name} and a ``kind'' to \thefunction{documentation}.
  \gexample{The body of code in a \macref{defmacro} form can be preceded 
	    by a documentation string of kind \misc{function}.}

\gentry{dot} \Noun\
  the \term{standard character} that is variously called
     ``full stop,''
     ``period,''
  or ``dot'' (\f{.}).
  \Seefigure\StdCharsThree.

%Maybe separate into adjective so we can say "(possibly dotted) list" etc. -kmp 7-May-91
\gentry{dotted list} \Noun\
  a \term{list} which has a terminating \term{atom} that is not \nil.
  (An \term{atom} by itself is not a \term{dotted list}, however.)

\gentry{dotted pair} \Noun\
  1. a \term{cons} whose \term{cdr} is a \term{non-list}.
  2. any \term{cons}, used to emphasize the use of the \term{cons}
     as a symmetric data pair.
 
\gentry{double float} \Noun\
  an \term{object} \oftype{double-float}.

\gentry{double-quote} \Noun\
  the \term{standard character} that is variously called
      ``quotation mark''
   or ``double quote'' (\f{"}).
  \Seefigure\StdCharsThree.

\gentry{dynamic binding} \Noun\ 
  a \term{binding} in a \term{dynamic environment}.

\gentry{dynamic environment} \Noun\
  that part of an \term{environment} that contains \term{bindings} 
  with \term{dynamic extent}.  A \term{dynamic environment} contains,
%!!! Moon: This phrase ["among other things"] always scares me. Is it necessary?
  among other things:
    \term{exit points} established by \specref{unwind-protect},
  and 
    \term{bindings} of
      \term{dynamic variables},
      \term{exit points} established by \specref{catch},
      \term{condition handlers},
    and
      \term{restarts}.  
 
%%!!! The CLIM folks want to be able to say:
%%      ``the parameter x has dynamic extent''
%%    and have it imply that:
%%      (a) ``the implementation of the indicated function 
%%            may declare the argument to be dynamic extent''
%%    and
%%      (b) ``it is permissible to pass an object which was 
%%            the value of a variable which had been declared dynamic extent''
%%    -kmp 30-Jan-92
\gentry{dynamic extent} \Noun\
  an \term{extent} whose duration is bounded by points of 
  \term{establishment} and \term{disestablishment} within the execution
  of a particular \term{form}.  \Seeterm{indefinite extent}.
  \gexample{Dynamic variable bindings have dynamic extent.}
 
\gentry{dynamic scope} \Noun\
  \term{indefinite scope} along with \term{dynamic extent}.
 
\gentry{dynamic variable} \Noun\
  a \term{variable} the \term{binding} for which is in the \term{dynamic environment}.
  \Seemisc{special}.

\indextab{E}

\gentry{echo stream} \Noun\
  a \term{stream} \oftype{echo-stream}.

\gentry{effective method} \Noun\
  the combination of \term{applicable methods} that are executed
  when a \term{generic function} is invoked with a particular sequence
  of \term{arguments}.
 
\gentry{element} \Noun\
  1. (of a \term{list}) 
     an \term{object} that is the \term{car} of one of the \term{conses}
     that comprise the \term{list}.
  2. (of an \term{array})
     an \term{object} that is stored in the \term{array}.
  3. (of a \term{sequence})
     an \term{object} that is an \term{element} of the \term{list} or \term{array}
     that is the \term{sequence}.
  4. (of a \term{type})
     an \term{object} that is a member of the set of \term{objects}
     designated by the \term{type}.
  5. (of an \term{input} \term{stream})
     a \term{character} or \term{number} (as appropriate to the
     \term{element type} of the \term{stream})
     that is among the ordered series of \term{objects} that can be 
     read from the \term{stream} (using \funref{read-char} or \funref{read-byte},
     as appropriate to the \term{stream}).
  6. (of an \term{output} \term{stream})
     a \term{character} or \term{number} (as appropriate to the
     \term{element type} of the \term{stream})
     that is among the ordered series of \term{objects} that has been
     or will be written to the \term{stream} (using \funref{write-char} 
     or \funref{write-byte}, as appropriate to the \term{stream}).
  7. (of a \term{class}) a \term{generalized instance} of the \term{class}.

\gentry{element type} \Noun\ 
  1. (of an \term{array}) the \term{array element type} of the \term{array}.
  2. (of a \term{stream}) the \term{stream element type} of the \term{stream}.

\gentry{em} \Noun\ \Traditional\ 
  a context-dependent unit of measure commonly used in typesetting,
  equal to the displayed width of of a letter ``M'' in the current font.
  (The letter ``M'' is traditionally chosen because it is typically 
   represented by the widest \term{glyph} in the font, and other characters' 
   widths are typically fractions of an \term{em}.  In implementations providing 
   non-Roman characters with wider characters than ``M,'' it is permissible 
   for another character to be the \term{implementation-defined} reference character
   for this measure, and for ``M'' to be only a fraction of an \term{em}
   wide.)  
  In a fixed width font, a line with \i{n} characters is \i{n} 
  \term{ems} wide; in a variable width font, \i{n} \term{ems} is the
  expected upper bound on the width of such a line.

\gentry{empty list} \Noun\
  the \term{list} containing no \term{elements}. \Seeterm{()}.
 
\gentry{empty type} \Noun\
  the \term{type} that contains no \term{elements}, and that is
  a \term{subtype} of all \term{types} (including itself).
  \Seeterm{nil}.

\gentry{end of file} \Noun\
  1. the point in an \term{input} \term{stream} beyond which there is
     no further data.
     Whether or not there is such a point on an \term{interactive stream} 
     is \term{implementation-defined}.
  2. a \term{situation} that occurs upon an attempt to obtain data from an
     \term{input stream} that is at the \term{end of file}\meaning{1}.

%% This might be handy sometime...
%
% \gentry{end of line} \Noun\
%   the termination of a line of text,
%   whether by a \term{newline} or an \term{end of file}.

\gentry{environment} \Noun\
  1. a set of \term{bindings}. \Seesection\IntroToEnvs.
  2. an \term{environment object}.
     \gexample{\funref{macroexpand} takes an optional environment argument.}

\gentry{environment object} \Noun\
  an \term{object} representing a set of \term{lexical bindings},
     used in the processing of a \term{form} to provide meanings for
     \term{names} within that \term{form}.
     \gexample{\funref{macroexpand} takes an optional environment argument.}
     (The \term{object} \nil\ when used as an \term{environment object}
      denotes the \term{null lexical environment};
      the \term{values} of \term{environment parameters} 
      to \term{macro functions} are \term{objects}
      of \term{implementation-dependent} nature which represent the 
      \term{environment}\meaning{1} in which the corresponding \term{macro form}
      is to be expanded.)
     \Seesection\EnvObjs.

\gentry{environment parameter} \Noun\
  A \term{parameter} in a \term{defining form} $f$ for which there is no corresponding
  \term{argument}; instead, this \term{parameter} receives as its value an
  \term{environment} \term{object} which corresponds to the
  \term{lexical environment} in which the \term{defining form} $f$ appeared.

%!!! Moon: I disagree with 1 and 2, "undefined consequences" /= "defined to signal an error"
\gentry{error} \Noun\
  1. (only in the phrase ``is an error'')
     a \term{situation} in which the semantics of a program are not specified, 
     and in which the consequences are undefined.
  2. a \term{condition} which represents an \term{error} \term{situation}.
     \Seesection\ErrorTerms.
  3. an \term{object} \oftype{error}.

\gentry{error output} \Noun\ 
  the \term{output} \term{stream} which is the \term{value} of the \term{dynamic variable}
  \varref{*error-output*}.

\gentry{escape} \Noun, \Adjective\
  1. \Noun\ a \term{single escape} or a \term{multiple escape}.
  2. \Adjective\ \term{single escape} or \term{multiple escape}.

%!!!! RPG doesn't think this definition is really adequate, 
%     especially for declarations.
\gentry{establish} \TransitiveVerb\ 
  to build or bring into being 
      a  \term{binding},
      a  \term{declaration},
      an \term{exit point},
      a  \term{tag},
      a  \term{handler}, 
      a \term{restart},
   or an \term{environment}. 
  \gexample{\specref{let} establishes lexical bindings.}

%% Experimental definition not installed. -kmp 26-Jan-92
% \gentry{establish} \TransitiveVerb\ 
%   1. (an \term{environment}) to build or bring into being.
%   2. (a  \term{binding},
%       a  \term{declaration},
%       an \term{exit point},
%       a  \term{tag},
%       a  \term{handler}, 
%       a \term{restart})
%      to \term{establish}\meaning{1} an augmented \term{environment}
%      in which that entity is \term{active}, applicable, present, or visible.
%   \gexample{\specref{let} establishes lexical bindings.}

\gentry{evaluate} \TransitiveVerb\ (a \term{form} or an \term{implicit progn})
  to \term{execute} the \term{code} represented by the \term{form}
  (or the series of \term{forms} making up the \term{implicit progn})
  by applying the rules of \term{evaluation},
  returning zero or more values.

\gentry{evaluation} \Noun\
  a model whereby \term{forms} are \term{executed}, returning zero or more values.
  Such execution might be implemented directly in one step by an interpreter
  or in two steps by first \term{compiling} the \term{form} and then
  \term{executing} the \term{compiled} \term{code}; this choice is 
  dependent both on context and the nature of the \term{implementation}, 
  but in any case is not in general detectable by any program.  The evaluation
  model is designed in such a way that a \term{conforming implementation} 
  might legitimately have only a compiler and no interpreter, or vice versa.
  \Seesection\EvaluationModel.
 
\gentry{evaluation environment} \Noun\
  a \term{run-time environment} in which macro expanders 
  and code specified by \specref{eval-when} to be evaluated
  are evaluated.  All evaluations initiated by the \term{compiler} 
  take place in the \term{evaluation environment}.

\gentry{execute} \TransitiveVerb\ \Traditional\ (\term{code})
  to perform the imperative actions represented by the \term{code}.

\gentry{execution time} \Noun\
  the duration of time that \term{compiled code} is being \term{executed}.

\gentry{exhaustive partition} \Noun\ (of a \term{type})
  a set of \term{pairwise} \term{disjoint} \term{types} that form an 
  \term{exhaustive union}.

\gentry{exhaustive union} \Noun\ (of a \term{type})
  a set of \term{subtypes} of the \term{type},
  whose union contains all \term{elements} of that \term{type}.
 
\gentry{exit point} \Noun\
  a point in a \term{control form}
% Moon would remove this first phrase, but I think the phrases refer 
% respectively to BLOCK, UNWIND-PROTECT, and TAGBODY. -kmp 14-Nov-91
       from which (\eg \specref{block}),
       through which (\eg \specref{unwind-protect}),
    or to which (\eg \specref{tagbody})
  control and possibly \term{values} can be transferred both actively by using 
  another \term{control form} and passively through the normal control and
  data flow of \term{evaluation}.
  \gexample{\specref{catch} and \specref{block} establish bindings for
            exit points to which \specref{throw} and \specref{return-from},
	    respectively, can transfer control and values;
	    \specref{tagbody} establishes a binding for an exit point
	    with lexical extent to which \specref{go} can transfer control;
	    and \specref{unwind-protect} establishes an exit point 
	    through which control might be transferred by 
	    operators such as \specref{throw}, \specref{return-from},
            and \specref{go}.}

\gentry{explicit return} \Noun\ 
  the act of transferring control (and possibly \term{values}) 
  to a \term{block} by using \specref{return-from} (or \macref{return}).

\gentry{explicit use} \Noun\ (of a \term{variable} $V$ in a \term{form} $F$)
  a reference to $V$ that is directly apparent in the normal semantics of $F$;
  \ie that does not expose any undocumented details of the
      \term{macro expansion} of the \term{form} itself.
  References to $V$ exposed by expanding \term{subforms} of $F$ are, however,
  considered to be \term{explicit uses} of $V$.

%Barmar prefers "printed representation of" to "textual notation for"
\gentry{exponent marker} \Noun\
  a character that is used in the textual notation for a \term{float}
  to separate the mantissa from the exponent.
  The characters defined as \term{exponent markers} in the \term{standard readtable}
  are shown in \thenextfigure.
  For more information, \seesection\CharacterSyntax.
  \gexample{The exponent marker `d' in `3.0d7' indicates
	    that this number is to be represented as a double float.}

\tablefigtwo{Exponent Markers}{Marker}{Meaning}{
 \f{D} or \f{d} & \typeref{double-float}                                     \cr
 \f{E} or \f{e} & \typeref{float} (see \varref{*read-default-float-format*}) \cr
 \f{F} or \f{f} & \typeref{single-float}                                     \cr
 \f{L} or \f{l} & \typeref{long-float}                                       \cr
 \f{S} or \f{s} & \typeref{short-float}                                      \cr
}

\gentry{export} \TransitiveVerb\ (a \term{symbol} in a \term{package})
  to add the \term{symbol} to the list of \term{external symbols} of the
  \term{package}.

\gentry{exported} \Adjective\ (of a \term{symbol} in a \term{package})
  being an \term{external symbol} of the \term{package}.

\gentry{expressed adjustability} \Noun\ (of an \term{array})
  a \term{generalized boolean} that is conceptually (but not necessarily actually)
  associated with the \term{array}, representing whether the \term{array}
  is \term{expressly adjustable}.
  \SeetermAlso{actual adjustability}.

\gentry{expressed array element type} \Noun\ (of an \term{array})
  the \term{type} which is the \term{array element type}
  implied by a \term{type declaration} for the \term{array}, 
  or which is the requested \term{array element type} at its time 
  of creation, prior to any selection of an \term{upgraded array element type}.
  (\clisp\ does not provide a way of detecting this \term{type}
   directly at run time, but an \term{implementation} is permitted 
   to make assumptions about the \term{array}'s contents and
   the operations which may be performed on the \term{array} when
   this \term{type} is noted during code analysis, even if those 
   assumptions would not be valid in general for the
   \term{upgraded array element type} of the
   \term{expressed array element type}.)
% KMP->Barmar:
%  You remarked that you think you can rely on array-element-type and 
%  upgraded-xxx-type. This is intended to permit a compiler optimizer like:
%      (frob (make-array n :element-type '(unsigned-byte 13)))
%  to turn into
%      (si:frob-internal-signed-byte-13 
%        (make-array n :element-type '(unsigned-byte 13)))
%  even though the implementation knows that (unsigned-byte 16) will really get
%  allocated, let's say.  Moreover, the compiler should be permitted to warn about:
%      (defun foo (n) 
%        (let ((x (make-array n :element-type '(unsigned-byte 2))))
% 	 (setf (aref x 0) 17.) ...))
%  It generally will not warn about:
%      (defun foo (n)
%        (bar (make-array n :element-type '(unsigned-byte 2))))
%      (defun bar (a)
%        (setf (aref x 0) 17.) ...)
%  I agree that it should never warn about:
%      (defun foo (n) 
%        (let ((x (make-array n :element-type '(unsigned-byte 2))))
% 	 (when (type-equivalent-p (array-element-type x) 'fixnum)
% 	    (setf (aref x 0) 17.) ...)))
%  because this is portably guarded even if it behaves differently on the
%  different implementations to which it is ported.
% 
%  This makes it tough to do the optimization I'm referring to, but I don't
%  think that implementations which really properly check that the path is
%  clear between the allocation and the reference should be forbidden from
%  flagging an unconditional non-portability.
%
% Barmar: 
%  You apparently understand the point I was making.  If you can come up
%  with a concise way to phrase it in the definition of "declared XXX
%  type", that's all I was hoping for.  If not, I don't think this is a
%  critical issue.

\gentry{expressed complex part type} \Noun\ (of a \term{complex})
  the \term{type} which is implied as the \term{complex part type}
  by a \term{type declaration} for the \term{complex}, 
  or which is the requested \term{complex part type} at its time of
  creation, prior to any selection of an \term{upgraded complex part type}.
  (\clisp\ does not provide a way of detecting this \term{type}
   directly at run time, but an \term{implementation} is permitted 
   to make assumptions about the operations which may be performed on
   the \term{complex} when this \term{type} is noted during code
   analysis, even if those assumptions would not be valid in general for 
   the \term{upgraded complex part type} of the
   \term{expressed complex part type}.)

\gentry{expression} \Noun\
  1. an \term{object}, often used to emphasize the use 
     of the \term{object} to encode or represent information in a specialized
     format, such as program text.
     \gexample{The second expression in a \specref{let} form is a list
   	       of bindings.}
  2. the textual notation used to notate an \term{object} in a source file.
     \gexample{The expression \f{'sample} is equivalent to \f{(quote sample)}.}

\gentry{expressly adjustable} \Adjective\ (of an \term{array})
  being \term{actually adjustable} by virtue of an explicit request for this
  characteristic having been made at the time of its creation.
  All \term{arrays} that are \term{expressly adjustable} 
  are \term{actually adjustable},
  but not necessarily vice versa.

\gentry{extended character} \Noun\
  a \term{character} 
\issue{CHARACTER-VS-CHAR:LESS-INCONSISTENT-SHORT}
  \oftype{extended-char}:
\endissue{CHARACTER-VS-CHAR:LESS-INCONSISTENT-SHORT}
  a \term{character} that is not a \term{base character}.

\gentry{extended function designator} \Noun\
  a \term{designator} for a \term{function}; that is,
  an \term{object} that denotes a \term{function}
  and that is one of:
      a \term{function name} (denoting the \term{function} it names
                              in the \term{global environment}),
   or a \term{function} (denoting itself).
  The consequences are undefined if 
  a \term{function name} is used as an 
  \term{extended function designator} but
  it does not have a global definition as a \term{function},
  or if it is a \term{symbol} 
     that has a global definition as a \term{macro} or a \term{special form}.
  \SeetermAlso{function designator}.

\gentry{extended lambda list} \Noun\
  a list resembling an \term{ordinary lambda list} in form and purpose, but 
  offering additional syntax or functionality not available in an
  \term{ordinary lambda list}.
  \gexample{\macref{defmacro} uses extended lambda lists.}
 
\gentry{extension} \Noun\
  a facility in an \term{implementation} of \clisp\ 
  that is not specified by this standard.

\gentry{extent} \Noun\
  the interval of time during which a \term{reference} to 
      an \term{object},
      a  \term{binding},
      an \term{exit point},
      a  \term{tag},
      a  \term{handler},
      a  \term{restart},
   or an \term{environment} is defined.
 
\gentry{external file format} \Noun\
  an \term{object} of \term{implementation-dependent} nature which determines
  one of possibly several \term{implementation-dependent} ways in which
  \term{characters} are encoded externally in a \term{character} \term{file}.

\gentry{external file format designator} \Noun\
  a \term{designator} for an \term{external file format}; that is,
  an \term{object} that denotes an \term{external file format}
  and that is one of:
      the \term{symbol} \kwd{default} 
         (denoting an \term{implementation-dependent} default 
          \term{external file format} that can accomodate at least
          the \term{base characters}),
      some other \term{object} defined by the \term{implementation} to be
      an \term{external file format designator}
         (denoting an \term{implementation-defined} \term{external file format}),
   or some other \term{object} defined by the \term{implementation} to be
      an \term{external file format} 
         (denoting itself).

\gentry{external symbol} \Noun\ (of a \term{package})
  a \term{symbol} that is part of the `external interface' to the \term{package}
  and that are \term{inherited}\meaning{3} by any other \term{package}
   that \term{uses} the \term{package}.
  When using the \term{Lisp reader}, 
  if a \term{package prefix} is used,
  the \term{name} of an \term{external symbol} is separated
    from the \term{package} \term{name} by a single \term{package marker}
  while
  the \term{name} of an \term{internal symbol} is separated
    from the \term{package} \term{name} by a double \term{package marker};
  \seesection\SymbolTokens.

\gentry{externalizable object} \Noun\
  an \term{object} that can be used as a \term{literal} \term{object} 
  in \term{code} to be processed by the \term{file compiler}.  

\indextab{F}
 
\gentry{false} \Noun\
  the \term{symbol} \nil,
  used to represent the failure of a \term{predicate} test.

\gentry{fbound} \pronounced{\Stress{ef}\stress{ba\.und}} \Adjective\ 
							 (of a \term{function name})
  \term{bound} in the \term{function} \term{namespace}.
  (The \term{names} of \term{macros} and \term{special operators} are \term{fbound},
   but the nature and \term{type} of the \term{object} which is their \term{value}
   is \term{implementation-dependent}.
\issue{SETF-FUNCTIONS-AGAIN:MINIMAL-CHANGES}
   Further, defining a \term{setf expander} \param{F} does not cause the \term{setf function}
   \f{(setf \param{F})} to become defined; as such, if there is a such a definition
   of a \term{setf expander} \param{F}, the \term{function} \f{(setf \param{F})}
   can be \term{fbound} if and only if, by design or coincidence, a
   function binding for \f{(setf \param{F})} has been independently established.)
\endissue{SETF-FUNCTIONS-AGAIN:MINIMAL-CHANGES}
  \Seefuns{fboundp} and \funref{symbol-function}.

\gentry{feature} \Noun\
  1. an aspect or attribute 
        of \clisp, 
        of the \term{implementation},
     or of the \term{environment}.
  2. a \term{symbol} that names a \term{feature}\meaning{1}.
  \Seesection\Features.
  \gexample{The \kwd{ansi-cl} feature is present in all conforming implementations.}

\gentry{feature expression} \Noun\
  A boolean combination of \term{features} used by the \f{\#+} and \f{\#-} 
  \term{reader macros} in order to direct conditional \term{reading} of
  \term{expressions} by the \term{Lisp reader}.
  \Seesection\FeatureExpressions.

\gentry{features list} \Noun\
  the \term{list} that is \thevalueof{*features*}.

\gentry{file} \Noun\
  a named entry in a \term{file system},
  having an \term{implementation-defined} nature.

\gentry{file compiler} \Noun\
  any \term{compiler} which \term{compiles} \term{source code} contained in a \term{file},
  producing a \term{compiled file} as output.  The \funref{compile-file} 
  function is the only interface to such a \term{compiler} provided by \clisp,
  but there might be other, \term{implementation-defined} mechanisms for 
  invoking the \term{file compiler}.

\gentry{file position} \Noun\ (in a \term{stream})
  a non-negative \term{integer} that represents a position in the \term{stream}.
  Not all \term{streams} are able to represent the notion of \term{file position};
  in the description of any \term{operator} which manipulates \term{file positions}, 
  the behavior for \term{streams} that don't have this notion must be explicitly stated.
  For \term{binary} \term{streams}, the \term{file position} represents the number 
  of preceding \term{bytes} in the \term{stream}.
  For \term{character} \term{streams}, the constraint is more relaxed: 
  \term{file positions} must increase monotonically, the amount of the increase
  between \term{file positions} corresponding to any two successive characters
  in the \term{stream} is \term{implementation-dependent}.

\gentry{file position designator} \Noun\ (in a \term{stream})
  a \term{designator} for a \term{file position} in that \term{stream}; that is,
      the symbol \kwd{start}  
        (denoting \f{0}, the first \term{file position} in that \term{stream}),
      the symbol \kwd{end}
	(denoting the last \term{file position} in that \term{stream};
	 \ie the position following the last \term{element} of the \term{stream}),
   or a \term{file position} (denoting itself).

\gentry{file stream} \Noun\
  an \term{object} \oftype{file-stream}.

\gentry{file system} \Noun\
  a facility which permits aggregations of data to be stored in named
  \term{files} on some medium that is external to the \term{Lisp image}
  and that therefore persists from \term{session} to \term{session}.

\issue{PATHNAME-HOST-PARSING:RECOGNIZE-LOGICAL-HOST-NAMES}
\gentry{filename} \Noun\
%% This term applies some places to logical pathnames and doesn't work very well
%% for them, so I tried to make it more abstract. -kmp 28-Aug-93
%   an \term{implementation-dependent} handle, not necessarily ever directly
%   represented as an \term{object}, that can be used to refer to a \term{file}
%   in a \term{file system}.  \term{Physical pathnames} and 
%   \term{physical pathname} \term{namestrings} are two kinds of \term{objects} 
%   that substitute for \term{filenames} in \clisp.  The specific relationship 
%   between \term{filenames} and \term{physical pathnames}, and between
%   \term{filenames} and \term{namestrings}, is \term{implementation-defined}.
  a handle, not necessarily ever directly represented as an \term{object},
  that can be used to refer to a \term{file} in a \term{file system}.
  \term{Pathnames} and \term{namestrings} are two kinds of \term{objects} 
  that substitute for \term{filenames} in \clisp.  
\endissue{PATHNAME-HOST-PARSING:RECOGNIZE-LOGICAL-HOST-NAMES}

\gentry{fill pointer} \Noun\ (of a \term{vector})
  an \term{integer} associated with a \term{vector} that represents the
  index above which no \term{elements} are \term{active}.
  (A \term{fill pointer} is a non-negative \term{integer} no
   larger than the total number of \term{elements} in the \term{vector}.
   Not all \term{vectors} have \term{fill pointers}.)
 
\gentry{finite} \Adjective\ (of a \term{type})
  having a finite number of \term{elements}.
  \gexample{The type specifier \f{(integer 0 5)} denotes a finite type,
	    but the type specifiers \typeref{integer} and \f{(integer 0)} do not.}

\gentry{fixnum} \Noun\ 
  an \term{integer} \oftype{fixnum}.

\gentry{float} \Noun\
  an \term{object} \oftype{float}.

\issue{IGNORE-USE-TERMINOLOGY:VALUE-ONLY}
\gentry{for-value} \Adjective\ (of a \term{reference} to a \term{binding})
  being a \term{reference} that \term{reads}\meaning{1}
  the \term{value} of the \term{binding}.
\endissue{IGNORE-USE-TERMINOLOGY:VALUE-ONLY}

\gentry{form} \Noun\
  1. any \term{object} meant to be \term{evaluated}.
  2.    a \term{symbol},
        a \term{compound form},
     or a \term{self-evaluating object}.
  3. (for an \term{operator}, as in ``\metavar{operator} \term{form}'')
     a \term{compound form} having that \term{operator} as its first element.
     \gexample{A \specref{quote} form is a constant form.}
 
\gentry{formal argument} \Noun\ \Traditional\ 
  a \term{parameter}.

\gentry{formal parameter} \Noun\ \Traditional\ 
  a \term{parameter}.

\issue{FORMAT-STRING-ARGUMENTS:SPECIFY}
\gentry{format} \TransitiveVerb\ (a \term{format control} and \term{format arguments})
  to perform output as if by \funref{format},
  using the \term{format string} and \term{format arguments}.
\endissue{FORMAT-STRING-ARGUMENTS:SPECIFY}

\issue{FORMAT-STRING-ARGUMENTS:SPECIFY}
\gentry{format argument} \Noun\
  an \term{object} which is used as data by functions such as \funref{format}
  which interpret \term{format controls}.
\endissue{FORMAT-STRING-ARGUMENTS:SPECIFY}

\gentry{format control} \Noun\
     a \term{format string},
  or a \term{function} that obeys the \term{argument} conventions
     for a \term{function} returned by \themacro{formatter}.
  \Seesection\CompilingFormatStrings.

\gentry{format directive} \Noun\
  1. a sequence of \term{characters} in a \term{format string}
     which is introduced by a \term{tilde}, and which is specially 
     interpreted by \term{code} which processes \term{format strings}
     to mean that some special operation should be performed, possibly
     involving data supplied by the \term{format arguments} that 
     accompanied the \term{format string}.  \Seefun{format}.
     \gexample{In \f{"~D base 10 = ~8R"}, the character
     	       sequences `\f{~D}' and `\f{~8R}' are format directives.}
  2. the conceptual category of all \term{format directives}\meaning{1}
     which use the same dispatch character.
     \gexample{Both \f{"~3d"} and \f{"~3,'0D"} are valid uses of the
	       `\f{~D}' format directive.}

\gentry{format string} \Noun\
  a \term{string} which can contain both ordinary text and \term{format directives},
  and which is used in conjunction with \term{format arguments} to describe how 
  text output should be formatted by certain functions, such as \funref{format}.

\gentry{free declaration} \Noun\
  a declaration that is not a \term{bound declaration}.
  \Seemisc{declare}.
 
\gentry{fresh} \Adjective\ 
  1. (of an \term{object} \term{yielded} by a \term{function})
     having been newly-allocated by that \term{function}.
     (The caller of a \term{function} that returns a \term{fresh} \term{object}
      may freely modify the \term{object} without fear that such modification will
      compromise the future correct behavior of that \term{function}.)
  2. (of a \term{binding} for a \term{name})
     newly-allocated; not shared with other \term{bindings} for that \term{name}.

\gentry{freshline} \Noun\
  a conceptual operation on a \term{stream}, implemented by \thefunction{fresh-line}
  and by the \term{format directive} \f{~\&}, which advances the display position
  to the beginning of the next line (as if a \term{newline} had been typed, or 
  \thefunction{terpri} had been called)
  unless the \term{stream} is already known to be positioned at the beginning of a line.
  Unlike \term{newline}, \term{freshline} is not a \term{character}.

\gentry{funbound} \pronounced{\Stress{ef}unba\.und} \Noun\ (of a \term{function name})
  not \term{fbound}.

\gentry{function} \Noun\
  %% 6.2.2 26
  1. an \term{object} representing code,
     which can be \term{called} with zero or more \term{arguments},
     and which produces zero or more \term{values}.
  2. an \term{object} \oftype{function}.

\gentry{function block name} \Noun\ (of a \term{function name})
  The \term{symbol} that would be used as the name of an \term{implicit block}
  which surrounds the body of a \term{function} having that \term{function name}.
  If the \term{function name} is a \term{symbol}, its \term{function block name} is
  the \term{function name} itself.
  If the \term{function name} is a \term{list} whose \term{car} is \misc{setf}
  and whose \term{cadr} is a \term{symbol}, its \term{function block name} is 
  the \term{symbol} that is the \term{cadr} of the \term{function name}.
  An \term{implementation} which supports additional kinds of \term{function names}
  must specify for each how the corresponding \term{function block name} is computed.

\gentry{function cell} \Noun\ \Traditional\ (of a \term{symbol})
  The \term{place} which holds the \term{definition} of the
  global \term{function} \term{binding}, if any, named by that \term{symbol},
  and which is \term{accessed} by \funref{symbol-function}.
  \Seeterm{cell}.

\gentry{function designator} \Noun\
  a \term{designator} for a \term{function}; that is,
  an \term{object} that denotes a \term{function}
  and that is one of:
      a \term{symbol} (denoting the \term{function} named by that \term{symbol}
                       in the \term{global environment}),
   or a \term{function} (denoting itself).
  The consequences are undefined if 
  a \term{symbol} is used as a \term{function designator} but
  it does not have a global definition as a \term{function},
  or it has a global definition as a \term{macro} or a \term{special form}.
  \SeetermAlso{extended function designator}.

\gentry{function form} \Noun\
  a \term{form} that is a \term{list} and that has a first element 
  which is the \term{name} of a \term{function} to be called on
  \term{arguments} which are the result of \term{evaluating} subsequent
  elements of the \term{function form}.
 
\gentry{function name} \Noun\ 
  1. (in an \term{environment})
     A \term{symbol} or a \term{list} \f{(setf \i{symbol})} 
     that is the \term{name} of a \term{function} in that \term{environment}.
%   \editornote{KMP: I think that in many (but obviously not all) cases where
% 	           `function name' is used, `operator name' might be intended.
% 		   I'll be looking for such cases later, but if readers happen
% 		   to notice any of these, they should feel free to mark them.}%!!!
% !!! Moon: Not always with respect to an environment, see e.g., function block name.
%           Also, can sometimes name a macro or special operator or be fbound.
%% Added per Boyer/Kaufmann/Moore #8,#9 (by X3J13 vote at May 4-5, 1994 meeting)
%% -kmp 9-May-94
  2. A \term{symbol} or a \term{list} \f{(setf \i{symbol})}.

\gentry{functional evaluation} \Noun\ 
  the process of extracting a \term{functional value} from a \term{function name}
%Added for Moon:
  or a \term{lambda expression}.
  The evaluator performs \term{functional evaluation} 
       implicitly when it encounters a \term{function name} 
%Added for Moon:
 	or a \term{lambda expression}
        in the \term{car} of a \term{compound form}, 
    or explicitly when it encounters a \specref{function} \term{special form}.
  Neither a use of a \term{symbol} as a \term{function designator} nor a
  use of \thefunction{symbol-function} to extract the \term{functional value}
  of a \term{symbol} is considered a \term{functional evaluation}.

\gentry{functional value} \Noun\ 
  1. (of a \term{function name} $N$ in an \term{environment} $E$)
     The \term{value} of the \term{binding} named $N$
     in the \term{function} \term{namespace} for \term{environment} $E$;
%!!! Moon: Wrong.  Function cell only holds global binding.
     that is, the contents of the \term{function cell} named $N$ in 
     \term{environment} $E$.
  2. (of an \term{fbound} \term{symbol} $S$)
     the contents of the \term{symbol}'s \term{function cell}; that is,
     the \term{value} of the \term{binding} named $S$
     in the \term{function} \term{namespace} of the \term{global environment}.
     (A \term{name} that is a \term{macro name} in the \term{global environment}
      or is a \term{special operator} might or might not be \term{fbound}.
%!!! Moon: Isn't this ["might or might not be fbound"] contrary to CLtL?
%          I don't have the book here, so I didn't check.
      But if $S$ is such a \term{name} and is \term{fbound}, the specific
      nature of its \term{functional value} is \term{implementation-dependent};
      in particular, it might or might not be a \term{function}.)

\gentry{further compilation} \Noun\ 
  \term{implementation-dependent} compilation beyond \term{minimal compilation}.
  Further compilation is permitted to take place at \term{run time}.
  \gexample{Block compilation and generation of machine-specific instructions
            are examples of further compilation.}  

\indextab{G}

\gentry{general} \Adjective\ (of an \term{array})
  having \term{element type} \typeref{t},
   and consequently able to have any \term{object} as an \term{element}.

\gentry{generalized boolean} \Noun\ 
  an \term{object} used as a truth value, where the symbol~\nil\ 
  represents \term{false} and all other \term{objects} represent \term{true}.
  \Seeterm{boolean}.

\gentry{generalized instance} \Noun\ (of a \term{class})
  an \term{object} the \term{class} of which is either that \term{class} itself,
  or some subclass of that \term{class}.  (Because of the correspondence between
  types and classes, the term ``generalized instance of $X$''
  implies ``object of type $X$'' and in cases where $X$ is a \term{class} 
  (or \term{class name}) the reverse is also true.
  The former terminology emphasizes the view of $X$ as a \term{class}
  while the latter emphasizes the view of $X$ as a \term{type specifier}.)

\gentry{generalized reference} \Noun\
  a reference to a location storing an \term{object} as if to a \term{variable}.
  (Such a reference can be either to \term{read} or \term{write} the location.)
  \Seesection\GeneralizedReference.  See also \term{place}.

\gentry{generalized synonym stream} \Noun\ (with a \term{synonym stream symbol})
  1. (to a \term{stream}) 
     a \term{synonym stream} to the \term{stream},
     or a \term{composite stream} which has as a target 
     a \term{generalized synonym stream} to the \term{stream}.
  2. (to a \term{symbol})
     a \term{synonym stream} to the \term{symbol},
     or a \term{composite stream} which has as a target 
     a \term{generalized synonym stream} to the \term{symbol}.

\gentry{generic function} \Noun\
  a \term{function} whose behavior depends on the \term{classes} or
  identities of the arguments supplied to it and whose parts include, among
  other things, a set of \term{methods}, a \term{lambda list}, and a
  \term{method combination} type.

\gentry{generic function lambda list} \Noun\
  A \term{lambda list} that is used to describe data flow into a \term{generic function}.
  \Seesection\GFLambdaLists.

\gentry{gensym} \Noun\ \Traditional\ 
  an \term{uninterned} \term{symbol}.
  \Seefun{gensym}.

%!!! Needs work. -kmp 25-Oct-90
\gentry{global declaration} \Noun\ 
  a \term{form} that makes certain kinds of information about 
  code globally available; that is, a \funref{proclaim} \term{form} 
  or a \macref{declaim} \term{form}.

\gentry{global environment} \Noun\ 
  that part of an \term{environment} that contains \term{bindings}
  with \term{indefinite scope} and \term{indefinite extent}.
 
\gentry{global variable} \Noun\
  a \term{dynamic variable} or a \term{constant variable}.%Is this really right?

\gentry{glyph} \Noun\ 
  a visual representation.
  \gexample{Graphic characters have associated glyphs.}

\gentry{go} \Verb\ 
  to transfer control to a \term{go point}.
  \Seespec{go}.

\gentry{go point}
  one of possibly several \term{exit points} that are \term{established} 
  by \specref{tagbody} (or other abstractions, such as \macref{prog}, 
  which are built from \specref{tagbody}).

\gentry{go tag} \Noun\ 
  the \term{symbol} or \term{integer} that, within the \term{lexical scope} 
  of a \specref{tagbody} \term{form}, names an \term{exit point}
  \term{established} by that \specref{tagbody} \term{form}.

\gentry{graphic} \Adjective\ (of a \term{character})
  being a ``printing'' or ``displayable'' \term{character} 
  that has a standard visual representation
  as a single \term{glyph}, such as \f{A} or \f{*} or \f{=}.
  \term{Space} is defined to be \term{graphic}.
  Of the \term{standard characters}, all but \term{newline} are \term{graphic}.
  \Seeterm{non-graphic}.

\indextab{H}

\gentry{handle} \Verb\ (of a \term{condition} being \term{signaled})
  to perform a non-local transfer of control, terminating the ongoing
  \term{signaling} of the \term{condition}.

\gentry{handler} \Noun\ 
  %I'm expecting that we might have a need for other kinds of handlers. -kmp 31-Dec-90
  a \term{condition handler}.

\gentry{hash table} \Noun\ 
  an \term{object} \oftype{hash-table}, 
  which provides a mapping from \term{keys} to \term{values}.

\gentry{home package} \Noun\ (of a \term{symbol})
  the \term{package}, if any, which is contents of the \term{package cell} 
  of the \term{symbol}, and which dictates how the \term{Lisp printer} 
  prints the \term{symbol} when it is not \term{accessible} in the
  \term{current package}. (\term{Symbols} which have \nil\ in their
  \term{package cell} are said to have no \term{home package}, and also
  to be \term{apparently uninterned}.)

\indextab{I}                           

\gentry{I/O customization variable} \Noun\
  one of the \term{stream variables} in \thenextfigure, 
  or some other (\term{implementation-defined}) \term{stream variable}
      that is defined by the \term{implementation} 
      to be an \term{I/O customization variable}.

\showthree{Standardized I/O Customization Variables}{
*debug-io*&*error-io*&query-io*\cr
*standard-input*&*standard-output*&*trace-output*\cr
}

\gentry{identical} \Adjective\ 
  the \term{same} under \funref{eq}.

\gentry{identifier} \Noun\        
  1. a \term{symbol} used to identify or to distinguish \term{names}. 
  2. a \term{string} used the same way.            
 
\gentry{immutable} \Adjective\
  not subject to change, either because no \term{operator} is provided which is
  capable of effecting such change or because some constraint exists which 
  prohibits the use of an \term{operator} that might otherwise be capable of
  effecting such a change.  Except as explicitly indicated otherwise,
  \term{implementations} are not required to detect attempts to modify
  \term{immutable} \term{objects} or \term{cells}; the consequences of attempting
  to make such modification are undefined.
  \gexample{Numbers are immutable.}

\gentry{implementation} \Noun\ 
  a system, mechanism, or body of \term{code} that implements the semantics of \clisp.

\gentry{implementation limit} \Noun\ 
  a restriction imposed by an \term{implementation}.
 
\gentry{implementation-defined} \Adjective\ 
  \term{implementation-dependent}, but required by this specification to be
  defined by each \term{conforming implementation} and to be documented by 
  the corresponding implementor.
%When this was moved to this position from far away, it became redundant. -kmp 14-Nov-91
% %I added this after asking Quinquevirate if they thought I should.
% %No one objected, and RPG thought it was a good idea. -kmp 17-Oct-90
%   A \term{conforming implementation} is required to document its treatment of each 
%   item in this specification which is marked \term{implementation-defined}.
 
\gentry{implementation-dependent} \Adjective\ 
  describing a behavior or aspect of \clisp\ which has been deliberately left
  unspecified, that might be defined in some \term{conforming implementations} 
  but not in others, and whose details may differ between \term{implementations}.
%I added this after asking Quinquevirate if they thought I should.
%No one objected, and RPG thought it was a good idea. -kmp 17-Oct-90
  A \term{conforming implementation} is encouraged (but not required) to 
  document its treatment of each item in this specification which is
  marked \term{implementation-dependent}, although in some cases
  such documentation might simply identify the item as ``undefined.''
  
\gentry{implementation-independent} \Adjective\ 
  used to identify or emphasize a behavior or aspect of \clisp\ which does 
  not vary between \term{conforming implementations}.

\gentry{implicit block} \Noun\ 
 a \term{block} introduced by a \term{macro form} 
 rather than by an explicit \specref{block} \term{form}.

\gentry{implicit compilation} \Noun\ 
 \term{compilation} performed during \term{evaluation}.

\gentry{implicit progn} \Noun\ 
  an ordered set of adjacent \term{forms} appearing in another
  \term{form}, and defined by their context in that \term{form}
  to be executed as if within a \specref{progn}.

\gentry{implicit tagbody} \Noun\ 
  an ordered set of adjacent \term{forms} and/or \term{tags} 
  appearing in another \term{form}, and defined by their context 
  in that \term{form} to be executed as if within a \specref{tagbody}.

\gentry{import} \TransitiveVerb\ (a \term{symbol} into a \term{package})
  to make the \term{symbol} be \term{present} in the \term{package}.

\gentry{improper list} \Noun\ 
  a \term{list} which is not a \term{proper list}:  
  a \term{circular list} or a \term{dotted list}.
 
\gentry{inaccessible} \Adjective\ 
  not \term{accessible}.
 
\gentry{indefinite extent} \Noun\ 
  an \term{extent} whose duration is unlimited.
  \gexample{Most Common Lisp objects have indefinite extent.}
 
\gentry{indefinite scope} \Noun\ 
  \term{scope} that is unlimited.
 
\gentry{indicator} \Noun\ 
  a \term{property indicator}.

\gentry{indirect instance} \Noun\ (of a \term{class} $C\sub 1$)
  an \term{object} of \term{class} $C\sub 2$, 
  where $C\sub 2$ is a \term{subclass} of $C\sub 1$.
  \gexample{An integer is an indirect instance of the class \typeref{number}.}

\gentry{inherit} \TransitiveVerb\ 
  1. to receive or acquire a quality, trait, or characteristic; 
     to gain access to a feature defined elsewhere.
  2. (a \term{class}) to acquire the structure and behavior defined
     by a \term{superclass}.
  3. (a \term{package}) to make \term{symbols} \term{exported} by another
     \term{package} \term{accessible} by using \funref{use-package}.
 
\issue{KMP-COMMENTS-ON-SANDRA-COMMENTS:X3J13-MAR-92}
\gentry{initial pprint dispatch table} \Noun\
  \thevalueof{*print-pprint-dispatch*} at the time the \term{Lisp image} is started.
\endissue{KMP-COMMENTS-ON-SANDRA-COMMENTS:X3J13-MAR-92}

\issue{WITH-STANDARD-IO-SYNTAX-READTABLE:X3J13-MAR-91}
\gentry{initial readtable} \Noun\
  \thevalueof{*readtable*} at the time the \term{Lisp image} is started.
\endissue{WITH-STANDARD-IO-SYNTAX-READTABLE:X3J13-MAR-91}

\issue{PLIST-DUPLICATES:ALLOW}
\gentry{initialization argument list} \Noun\ 
% a \term{proper list} of \term{keyword/value pairs} 
% (of initialization argument \term{names} and \term{values})
  a \term{property list} of initialization argument \term{names} and \term{values}
  used in the protocol for initializing and reinitializing \term{instances} of \term{classes}.
  \Seesection\ObjectCreationAndInit.
\endissue{PLIST-DUPLICATES:ALLOW}
 
\gentry{initialization form} \Noun\ 
  a \term{form} used to supply the initial \term{value} for a \term{slot}
  or \term{variable}.
  \gexample{The initialization form for a slot in a \macref{defclass} form
            is introduced by the keyword \kwd{initform}.}

\gentry{input} \Adjective\ (of a \term{stream})
  supporting input operations (\ie being a ``data source'').
  An \term{input} \term{stream} might also be an \term{output} \term{stream},
  in which case it is sometimes called a \term{bidirectional} \term{stream}.
  \Seefun{input-stream-p}.

\gentry{instance} \Noun\ 
  1. a \term{direct instance}.
  2. a \term{generalized instance}.
  3. an \term{indirect instance}.

\gentry{integer} \Noun\ 
  an \term{object} \oftype{integer}, which represents a mathematical integer.

\gentry{interactive stream} \Noun\ 
  a \term{stream} on which it makes sense to perform interactive querying.
  \Seesection\InteractiveStreams.

%!!! The usage "interning a symbol" is used but not described here.
%     e.g., see the type entry for KEYWORD.
\gentry{intern} \TransitiveVerb\ 
  1. (a \term{string} in a \term{package})
     to look up the \term{string} in the \term{package}, 
     returning either a \term{symbol} with that \term{name}
     which was already \term{accessible} in the \term{package}
     or a newly created \term{internal symbol} of the \term{package} 
     with that \term{name}.
  2. \Idiomatic\ generally, to observe a protocol whereby objects which 
     are equivalent or have equivalent names under some predicate defined
     by the protocol are mapped to a single canonical object.

\gentry{internal symbol} \Noun\ (of a \term{package})
  a symbol which is \term{accessible} in the \term{package},
  but which is not an \term{external symbol} of the \term{package}.

\gentry{internal time} \Noun\
  \term{time}, represented as an \term{integer} number of \term{internal time units}.
  \term{Absolute} \term{internal time} is measured as an offset 
  from an arbitrarily chosen, \term{implementation-dependent} base.
  \Seesection\InternalTime.

%% 25.4.1 21
\gentry{internal time unit} \Noun\ 
  a unit of time equal to $1/n$ of a second, 
  for some \term{implementation-defined} \term{integer} value of $n$.
  \Seevar{internal-time-units-per-second}.

\gentry{interned} \Adjective\ \Traditional\ 
  1. (of a \term{symbol}) \term{accessible}\meaning{3} in
     any \term{package}.
  2. (of a \term{symbol} in a specific \term{package}) 
     \term{present} in that \term{package}.

\gentry{interpreted function} \Noun\ 
  a \term{function} that is not a \term{compiled function}.
  (It is possible for there to be a \term{conforming implementation} which
   has no \term{interpreted functions}, but a \term{conforming program}
   must not assume that all \term{functions} are \term{compiled functions}.)

\gentry{interpreted implementation} \Noun\
  an \term{implementation} that uses an execution strategy for 
  \term{interpreted functions} that does not involve a one-time semantic
  analysis pre-pass, and instead uses ``lazy'' (and sometimes repetitious)
  semantic analysis of \term{forms} as they are encountered during execution.

\gentry{interval designator} \Noun\ (of \term{type} $T$)
  an ordered pair of \term{objects} that describe a \term{subtype} of $T$
  by delimiting an interval on the real number line.
  \Seesection\IntervalDesignators.

\gentry{invalid} \Noun, \Adjective\
  1. \Noun\
     a possible \term{constituent trait} of a \term{character}
     which if present signifies that the \term{character} 
     cannot ever appear in a \term{token} 
     except under the control of a \term{single escape} \term{character}.
     For details, \seesection\ConstituentChars.
  2. \Adjective\ (of a \term{character})
     being a \term{character} that has \term{syntax type} \term{constituent}
     in the \term{current readtable} and that has the 
     \term{constituent trait} \term{invalid}\meaning{1}.
     \Seefigure\ConstituentTraitsOfStdChars.

\issue{DOTIMES-IGNORE:X3J13-MAR91}
\gentry{iteration form} \Noun\
  a \term{compound form} whose \term{operator} is named in \thenextfigure,
  or a \term{compound form} that has an \term{implementation-defined} \term{operator}
     and that is defined by the \term{implementation} to be an \term{iteration form}.

\displaythree{Standardized Iteration Forms}{
do&do-external-symbols&dotimes\cr
do*&do-symbols&loop\cr
do-all-symbols&dolist&\cr
}

% Moon: Is this correct? I think WITH variables in LOOP are not iteration variables.
% KMP: Looks right to me. See issue DOTIMES-IGNORE.
\gentry{iteration variable} \Noun\
  a \term{variable} $V$, the \term{binding} for which was created by an
  \term{explicit use} of $V$ in an \term{iteration form}.
\endissue{DOTIMES-IGNORE:X3J13-MAR91}

\indextab{K}

\gentry{key} \Noun\ 
  an \term{object} used for selection during retrieval. 
  \Seeterm{association list}, \term{property list}, and \term{hash table}.
  Also, \seesection\SequenceConcepts.
 
\gentry{keyword} \Noun\ 
  1. a \term{symbol} the \term{home package} of which is \thepackage{keyword}.
  2. any \term{symbol}, usually but not necessarily in \thepackage{keyword},
     that is used as an identifying marker in keyword-style argument passing.
     \Seemisc{lambda}.
  3. \Idiomatic\ a \term{lambda list keyword}.

\gentry{keyword parameter} \Noun\
  A \term{parameter} for which a corresponding keyword \term{argument}
  is optional.  (There is no such thing as a required keyword \term{argument}.)
  If the \term{argument} is not supplied, a default value is used.
  \SeetermAlso{supplied-p parameter}.

\issue{PLIST-DUPLICATES:ALLOW}
\gentry{keyword/value pair} \Noun\ 
  two successive \term{elements} (a \term{keyword} and a \term{value}, 
  respectively) of a \term{property list}.
\endissue{PLIST-DUPLICATES:ALLOW}
 
\indextab{L}
 
\gentry{lambda combination} \Noun\ \Traditional\ 
  a \term{lambda form}.

\gentry{lambda expression} \Noun\ 
  a \term{list} which can be used in place of a \term{function name} in 
  certain contexts to denote a \term{function} by directly describing its
  behavior rather than indirectly by referring to the name of an
  \term{established} \term{function}; its name derives from the fact that its
  first element is the \term{symbol} \f{lambda}.
  \Seemisc{lambda}.
 
\gentry{lambda form} \Noun\ 
  a \term{form} that is a \term{list} and that has a first element
  which is a \term{lambda expression} representing a \term{function}
  to be called on \term{arguments} which are the result of \term{evaluating}
  subsequent elements of the \term{lambda form}.

\gentry{lambda list} \Noun\ 
  a \term{list} that specifies a set of \term{parameters} 
  (sometimes called \term{lambda variables})
  and a protocol for receiving \term{values} for those \term{parameters};
  that is,
  an \term{ordinary lambda list},
  an \term{extended lambda list},
  or a \term{modified lambda list}.

\gentry{lambda list keyword} \Noun\ 
  a \term{symbol} whose \term{name} begins with \term{ampersand}
  and that is specially recognized in a \term{lambda list}.
  Note that no \term{standardized} \term{lambda list keyword} 
  is in \thepackage{keyword}.
 
\gentry{lambda variable} \Noun\ 
  a \term{formal parameter}, used to emphasize the \term{variable}'s
  relation to the \term{lambda list} that \term{established} it.
 
\gentry{leaf} \Noun\ 
  1. an \term{atom} in a \term{tree}\meaning{1}.
  2. a terminal node of a \term{tree}\meaning{2}.
 
\gentry{leap seconds} \Noun\
  additional one-second intervals of time that are occasionally inserted 
  into the true calendar by official timekeepers as a correction similar 
  to ``leap years.''  All \clisp\ \term{time} representations ignore 
  \term{leap seconds}; every day is assumed to be exactly 86400 seconds 
  long.

\gentry{left-parenthesis} \Noun\
  the \term{standard character} ``\f{(}'',
  that is variously called
      ``left parenthesis''
   or ``open parenthesis''
  \Seefigure\StdCharsThree.

\gentry{length} \Noun\ (of a \term{sequence})
  the number of \term{elements} in the \term{sequence}.
  (Note that if the \term{sequence} is a \term{vector} with a 
   \term{fill pointer}, its \term{length} is the same as the 
   \term{fill pointer} even though the total allocated size of
   the \term{vector} might be larger.)

\gentry{lexical binding} \Noun\ 
  a \term{binding} in a \term{lexical environment}.

\gentry{lexical closure} \Noun\ 
  a \term{function} that, when invoked on \term{arguments}, executes
  the body of a \term{lambda expression} in the \term{lexical environment} 
  that was captured at the time of the creation of the \term{lexical closure},
  augmented by \term{bindings} of the \term{function}'s \term{parameters}
  to the corresponding \term{arguments}.
 
\gentry{lexical environment} \Noun\ 
  that part of the \term{environment} that contains \term{bindings}
  whose names have \term{lexical scope}. A \term{lexical environment} 
  contains, among other things:
%!!! Moon: [re "among other things"] scary!
     ordinary \term{bindings} of \term{variable} \term{names} to \term{values},
     lexically \term{established} \term{bindings} of \term{function names}
        to \term{functions},
     \term{macros},
     \term{symbol macros},
     \term{blocks},
     \term{tags},
  and
     \term{local declarations} (\seemisc{declare}).

\gentry{lexical scope} \Noun\ 
  \term{scope} that is limited to a spatial or textual region within the
  establishing \term{form}.
%!!! Moon: [re "names" in this example] "bindings"?
  \gexample{The names of parameters to a function normally are lexically scoped.}

\gentry{lexical variable} \Noun\ 
  a \term{variable} the \term{binding} for which is in the
  \term{lexical environment}.

%!!! KMP wonders if the "Lisp xxx" terms shouldn't be renamed to not require 
%    the use of the prefix "Lisp".

%!!! Moon: Too long?
%    KMP: Maybe I'll separate out into a concept section.
\gentry{Lisp image} \Noun\
  a running instantiation of a \clisp\ \term{implementation}.
  A \term{Lisp image} is characterized by a single address space in which any
  \term{object} can directly refer to any another in conformance with this specification,
  and by a single, common, \term{global environment}.
  (External operating systems sometimes call this a 
       ``core image,''
       ``fork,''
       ``incarnation,'' 
       ``job,''
    or ``process.''  Note however, that the issue of a ``process'' in such 
    an operating system is technically orthogonal to the issue of a \term{Lisp image}
    being defined here.  Depending on the operating system, a single ``process'' 
    might have multiple \term{Lisp images}, and multiple ``processes'' might reside
    in a single \term{Lisp image}.  Hence, it is the idea of a fully shared address
    space for direct reference among all \term{objects} which is the defining
    characteristic.  Note, too, that two ``processes'' which have a communication 
    area that permits the sharing of some but not all \term{objects} are considered
    to be distinct \term{Lisp images}.)

\gentry{Lisp printer} \Noun\ \Traditional\ 
  the procedure that prints the character representation of an
  \term{object} onto a \term{stream}. (This procedure is implemented
  by \thefunction{write}.)
 
\gentry{Lisp read-eval-print loop} \Noun\ \Traditional\ 
  an endless loop that \term{reads}\meaning{2} a \term{form},
  \term{evaluates} it,
  and prints (\ie \term{writes}\meaning{2}) the results.
  In many \term{implementations},
  the default mode of interaction with \clisp\ during program development
  is through such a loop.

\gentry{Lisp reader} \Noun\ \Traditional\ 
  the procedure that parses character representations of \term{objects}
  from a \term{stream}, producing \term{objects}.
  (This procedure is implemented by \thefunction{read}.)
  %!!! KMP wants more words about the readtable here.
 
\gentry{list} \Noun\ 
  1. a chain of \term{conses} in which the \term{car} of each
     \term{cons} is an \term{element} of the \term{list}, 
     and the \term{cdr} of each \term{cons} is either the next
     link in the chain or a terminating \term{atom}.  
     \SeetermAlso{proper list},
	    \term{dotted list}, 
         or \term{circular list}.
  2. the \term{type} that is the union of \typeref{null} and \typeref{cons}.

\gentry{list designator} \Noun\
  a \term{designator} for a \term{list} of \term{objects}; that is,
  an \term{object} that denotes a \term{list} 
  and that is one of:
       a \term{non-nil} \term{atom} 
         (denoting a \term{singleton} \term{list} 
          whose \term{element} is that \term{non-nil} \term{atom})
       or a \term{proper list} (denoting itself).

\gentry{list structure} \Noun\ (of a \term{list})
  the set of \term{conses} that make up the \term{list}.
  Note that while the \term{car}\meaning{1b} component of each such \term{cons}
  is part of the \term{list structure}, 
  the \term{objects} that are \term{elements} of the \term{list}
  (\ie the \term{objects} that are the \term{cars}\meaning{2} of each \term{cons}
   in the \term{list})
  are not themselves part of its \term{list structure}, 
  even if they are \term{conses},
  except in the (\term{circular}\meaning{2})
  case where the \term{list} 
  actually contains one of its \term{tails} as an \term{element}.
  (The \term{list structure} of a \term{list} is sometimes redundantly 
   referred to as its ``top-level list structure'' in order to emphasize
   that any \term{conses} that are \term{elements} of the \term{list} 
   are not involved.)

\gentry{literal} \Adjective\ (of an \term{object})
  referenced directly in a program rather than being computed by the program;
  that is,
  appearing as data in a \specref{quote} \term{form}, 
  or, if the \term{object} is a \term{self-evaluating object},
  appearing as unquoted data.
  \gexample{In the form \f{(cons "one" '("two"))}, 
            the expressions \f{"one"}, \f{("two")}, and \f{"two"}
            are literal objects.}

\gentry{load} \TransitiveVerb\ (a \term{file})
  to cause the \term{code} contained in the \term{file} to be \term{executed}.
  \Seefun{load}.

\gentry{load time} \Noun\
  the duration of time that the loader is \term{loading} \term{compiled code}.

\gentry{load time value} \Noun\ 
  an \term{object} referred to in \term{code} by a \specref{load-time-value} 
  \term{form}.  The \term{value} of such a \term{form} is some specific
  \term{object} which can only be computed in the run-time \term{environment}.
  In the case of \term{file} \term{compilation}, the \term{value} is
  computed once as part of the process of \term{loading} the \term{compiled file},
  and not again.  \Seespec{load-time-value}.

\gentry{loader} \Noun\
  a facility that is part of Lisp and that \term{loads} a \term{file}.
  \Seefun{load}.

\gentry{local declaration} \Noun\ 
  an \term{expression} which may appear only in specially designated
  positions of certain \term{forms}, and which provides information about
  the code contained within the containing \term{form}; 
  that is, a \misc{declare} \term{expression}.

\gentry{local precedence order} \Noun\ (of a \term{class})
  a \term{list} consisting of the \term{class} followed by its
  \term{direct superclasses} in the order mentioned in the defining
  \term{form} for the \term{class}.
 
\gentry{local slot} \Noun\ (of a \term{class})
  a \term{slot} \term{accessible} in only one \term{instance}, 
  namely the \term{instance} in which the \term{slot} is allocated.

% Or maybe... {Request for comment sent to Moon. -kmp 28-Feb-91}
%
% \gentry{local slot} \Noun\ 
%   1. (of an \term{instance}) a \term{slot} which is allocated in and \term{accessible}
%      to just that \term{instance}.
%   2. (of a \term{class}) a \term{slot} which is allocated anew for each 
%      \term{generalized instance} of the \term{class}.

\gentry{logical block} \Noun\
  a conceptual grouping of related output used by the \term{pretty printer}.
  \Seemac{pprint-logical-block} and \secref\DynamicControlofOutput.

\gentry{logical host} \Noun\
  an \term{object} of \term{implementation-dependent} nature 
  that is used as the representation of a ``host'' in a \term{logical pathname},
  and that has an associated set of translation rules for converting
  \term{logical pathnames} belonging to that host into \term{physical pathnames}.
  \Seesection\LogicalPathnames.

\gentry{logical host designator} \Noun\
  a \term{designator} for a \term{logical host}; that is,
  an \term{object} that denotes a \term{logical host} 
  and that is one of:
       a \term{string} (denoting the \term{logical host} that it names),
    or a \term{logical host} (denoting itself).
  (Note that because the representation of a \term{logical host} 
   is \term{implementation-dependent},
   it is possible that an \term{implementation} might represent 
   a \term{logical host} as the \term{string} that names it.)

\gentry{logical pathname} \Noun\ 
  an \term{object} \oftype{logical-pathname}.

\gentry{long float} \Noun\ 
  an \term{object} \oftype{long-float}.

\gentry{loop keyword} \Noun\ \Traditional\
  a symbol that is a specially recognized part of the syntax of 
  an extended \macref{loop} \term{form}.  Such symbols are recognized by their
  \term{name} (using \funref{string=}), not by their identity; as such, they
  may be in any package.  A \term{loop keyword} is not a \term{keyword}.

\gentry{lowercase} \Adjective\ (of a \term{character})
     being among \term{standard characters} corresponding to
     the small letters \f{a} through \f{z},
  or being some other \term{implementation-defined} \term{character}
      that is defined by the \term{implementation} to be \term{lowercase}.
  \Seesection\CharactersWithCase.

\indextab{M}
 
\gentry{macro} \Noun\ 
  1. a \term{macro f