%
%  The Regina Rexx Interpreter
%  Copyright (C) 1992-1994  Anders Christensen <anders@pvv.unit.no>
%


\chapter{Definitions}


In order to make the definitions more readable, but still have a rigid
definition of the terms, some extra comments have been added to some
of the definitions. These comments are enclosed in square brackets.

\begin{description}
\item[Argument]
   is an {\it expression} supplied to a {\it function} or {\it
   subroutine}, and it provides data on which the call can work on.

\item[Assignment]\index{assignment}
   is a {\it clause} in which second {\it token} is the equal sign.
   [Note that the statements ``{\tt a==b}'' and ``{\tt 3=4}'' are an
   (invalid) assignment, not an expression. The type of the first
   token is irrelevant; if the second token is the equal sign, then
   the clause is assumed to be an assignment.]

\item[Blanks]\index{blank}
   are characters which {\it glyphs} are empty space, either
   veritically or horisontally. A blank is not a {\it token} (but may
   sometimes be embedded in tokens), but acts as {\it token
   separators}. [Exactly which characters are considered blanks will
   differ between operating systems and implementations, but the {\sc
   space} character is always a blank.  The {\sc tab} character is
   also often considered a blank.  Other characters considered blank
   might be the end-of-line ({\sc eol}), vertical tab ({\sc vt}), and
   formfeed ({\sc ff}). See specific documentation for each
   interpreter for more information.]

\item[Buffer]

\item[Caller routine]

\item[Character]\index{character}
   is a piece of information about a mapping from a storage unit
   (normally a byte) and a {\it glyph}. Often used as ``the meaning of
   the glyph mapped to a particular storage unit''. [The glyph ``A''
   is the same in EBCDIC and ASCII, but the character ``A'' (i.e.\ the
   mapping from glyph to storage unit) differs.]

\item[Character string]\index{string}
   \index{character string!see{string}}
   is an finite, ordered, and possibly empty set of {\it characters}.

\item[Clause]\index{clause}
   is a non-empty collection of {\it tokens} in a {\rexx} script. The
   tokens making up a clause are all the consequitive tokens delimited
   by two consequitive {\it clause delimitors}. [Clauses are further
   divided into {\it null clauses}, {\it instructions}, {\it
   assignments}, and {\it commands}.]

\item[Clause delimitor]\index{clause!delimitor}
   is a non-empty sequence of elements of a subset of {\it tokens},
   normally the linefeed and the semicolon. Also the start and end of
   a {\rexx} {\it script} are considered clause delimitors. Also colon
   is a clause separator, but it is only valid after a label. 

\item[Command]

\item[Compound variable]
   is a {\it variable} which name has at least one ``{\tt .\@}'' character
   that isn't positioned at the end of the name. 

\item[Current environment]\index{environment!current}
   \index{current environment!see{environment, current}}
   is a particular {\it environment} to which {\it commands} is
   routed if no explicit environment is specified for their routing.

\item[Current procedure level]\index{current procedure level}
   is the {\it procedure level} in effect at a certain point during
   execution. 

\item[Daemon]

\item[Decimal digit]

\item[Device driver]

\item[Digit]\index{digit}
   is a single {\em character} having a numeric value associate with
   its glyph.

\item[Empty string]

\item[Environment]\index{environment}
   is a interface to which {\rexx} can route {\it commands} and afterwards
   retrieve status information like {\it return values}.

\item[Evaluation]\index{evaluation}
   is the process applied to an {\it expression} in order to derive a
   {\it character string}.

\item[Exposing]\index{exposing}
   is the binding of a {\it variable} in the {\it current procedure
   level} to the variable having the same name in the {\it caller
   routine}. This binding will be in effect for as long as the current
   procedure level is active.

\item[Exponential form]\index{exponential form}
   is a way of writing particularily large or small {\it numbers} in a
   fashion that makes them more readable. The number is divided into a
   matissa and an exponent of base 10.

\item[Expression]\index{expression}
   is a non-empty sequence of {\it tokens}, for which there exists
   syntactic restrictions on which tokens can be members, and the
   order in which the tokens can occur. [Typically, an expression may
   consist of literal strings or symbols, connected by concatentation
   and operators.]

\item[External data queue]
   see ``stack''.

\item[External subroutine]
   is a {\it script} of {\rexx} code, which is executed as a response
   to a {\it subroutine} or {\it function} call that is neither
   internal nor built-in.

\item[FIFO]

\item[Glyph]\index{glyph}
   is an atomic element of text, having a meaning and an appearance;
   like a letter, a digit, a punctuation mark, etc.

\item[Hex]\index{hex!see{digit, hexadecimal}}
   is used as a general abbreviation for term {\it hexadecimal} when
   used in compound words like hex digit and hex string.

\item[Hexadecimal digit]\index{digit!hexadecimal}
   is a {\it digit} in the number system having a base of 16. The
   first ten digits are identical with the {\it decimal digits} (0-9),
   while for the last six digits, the first six letters of the Latin
   alphabet (A-F) are used.

\item[Hexadecimal string]\index{string!hexadecimal}
   is a {\it character string} that consists only of the {\it
   hexadecimal digits}, and with optional {\it whitespace} to devide
   the hexadecimal digits into groups. Leading or trailing whitespace
   is illegal.  All groups except the first must consist of an even
   number of digits. If the first group have an odd number of digits,
   an extra leading zero is implied under some circumstances.

\item[Instruction]\index{instruction}
   is a {\it clause} that is recognized by the fact that the first
   {\it token} is a special {\it keyword}, and that the clause is not
   an {\it assignment} or label. Instructions typically are
   well-defined {\rexx} language components, such as loops and
   function calls.

\item[Interactive trace]\index{interactive trace}
   is a {\it trace} mode, where the {\it interpreter} halts execution
   between each {\it clause}, and offer the user the possibility to
   specify arbitrary {\rexx} {\it statements} to be executed before
   the execution continues.

\item[Label]

\item[LIFO]

\item[Literal name]
   is a name which will always be interpreted as a constant, i.e.~that
   no variable substitution will take place. 

\item[Literal string]
   is a {\it token} in a {\rexx} {\it script}, that basically is
   surrounded by quotation marks, in order to make a {\it character
   string} containing the same {\it characters} as the literal string.

\item[Keyword]\index{keyword}
   is a element from finite set of symbols.

\item[Main level]

\item[Main program]

\item[Name space]\index{name space}
   is a collection of named {\it variables}. In general, the
   expression is used when referring to the set of variables available
   to the {\it program} at some point during interpretation.

\item[Nullstring]\index{nullstring}
   is a {\it character string} having the length zero, i.e.~an empty
   character string. [Note the difference from the undefined string.] 

\item[Operating system]

\item[Parameters]

\item[Parsing]

\item[Procedure level]\index{procedure level}

\item[Program]\index{program}
   is a collection of {\rexx} code, which may be zero or more {\it
   scripts}, or other repositiories of {\rexx} code. However, a
   program must contain a all the code to be executed.

\item[Queue]
   see ``external data queue'' or ``stack''.

\item[Routine]\index{routine}
   is a unit during run-time, which is a procedureal level.  Certain
   settings are saved across {\it routines}. One {\it routine} (the
   caller {\it routine}) can be temporarily suspended while another
   {\it routine} is executed (the called {\it routine}). With such
   nesting, the called {\it routine} must be terminated before
   execution of the caller {\it routine} can be resumed. Normally, the
   {\tt CALL} instruction or a function call is used to do this. Note
   that the main level of a {\rexx} script is also a {\it routine}.
   
\item[Script]\index{script}
   is a single file containing {\rexx} code.

\item[Space separated]

\item[Stack]

\item[Statement]\index{statement}
   is a {\it clause} having in general some action, i.e.~a clause
   other than a {\it null clause}. [Assignments, commands and
   instructions are statements.]

\item[Stem collection]

\item[Stem variable]

\item[Strictly order]

\item[Subkeyword]\index{subkeyword}
   is a {\it keyword}, but the prefix ``sub'' stresses the fact that a
   {\it symbol} is a keyword only in certain contexts [e.g.~inside a
   particular instruction].

\item[Subroutine]\index{subroutine}
   is a {\it routine} which has been invoked from another {\rexx} {\it
   routine}; i.e.~it can not be the ``main'' program of a {\rexx}
   script. 

\item[Symbol]

\item[Symbol table]

\item[Tail substitution]

\item[Term]\index{term}

\item[Token]\index{token}

\item[Token separator]\index{token!separator}

\item[Uninitialized]

\item[Variable name]\index{variable!name}

\item[Variable symbol]

\item[Whitespace]
   One or several consequitive {\it blank} characters.


\item[hex literal]
\item[norm. hex string]
\item[bin {digit,string,literal}]
\item[norm. bin string]
\item[packed char string]


\end{description}

Character strings is the only type of data available in Rexx, but to
some extent there are 'subtypes' of character strings; character
strings which contents has certain format. These special formats is
discussed below.
