Make your own free website on Tripod.com
10.0. 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.

Argument is an expression supplied to a function or subroutine,
and it provides data on which the call can work on.

Assignment is a clause in which second token is the equal sign.
[Note that the statements “a==b” and “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.]

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

Buffer

Caller routine

Character is a piece of information about a mapping from a storage
unit (normally a byte) and a 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.]

Character string is an finite, ordered, and possibly empty set of
characters.

Clause is a non-empty collection of tokens in a REXX script. The
tokens making up a clause are all the consecutive tokens delimited
by two consecutive clause delimiters. [Clauses are further divided
into null clauses, instructions, assignments, and commands.]

Clause delimiter is a non-empty sequence of elements of a subset
of tokens, normally the linefeed and the semicolon. Also the start
and end of a REXX script are considered clause delimiters. Also
colon is a clause separator, but it is only valid after a label.

Command

Compound variable is a variable which name has at least one “.”
character that isn’t positioned at the end of the name.

Current environment is a particular environment to which commands
is routed if no explicit environment is specified for their
routing.

Current procedure level is the procedure level in effect at a
certain point during execution.

Daemon

Decimal digit

Device driver

Digit is a single character having a numeric value associate with
its glyph.

Empty string

Environment is a interface to which REXX can route commands and
afterwards retrieve status information like return values.

Evaluation is the process applied to an expression in order to
derive a character string.

Exposing is the binding of a variable in the current procedure
level to the variable having the same name in the caller routine.
This binding will be in effect for as long as the current
procedure level is active.

Exponential form is a way of writing particularly large or small
numbers in a fashion that makes them more readable. The number is
divided into a mantissa and an exponent of base 10.

Expression is a non-empty sequence of 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
concatenation and operators.]

External data queue see “stack”.

External subroutine is a script of REXX code, which is executed as
a response to a subroutine or function call that is neither
internal nor built-in.

FIFO

Glyph is an atomic element of text, having a meaning and an
appearance; like a letter, a digit, a punctuation mark, etc.

Hex is used as a general abbreviation for term hexadecimal when
used in compound words like hex digit and hex string.

Hexadecimal digit is a digit in the number system having a base of
 16. The first ten digits are identical with the decimal digits (0-
9), while for the last six digits, the first six letters of the
Latin alphabet (A-F) are used.

Hexadecimal string is a character string that consists only of the
hexadecimal digits, and with optional whitespace to divide 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.

Instruction is a clause that is recognized by the fact that the
first token is a special keyword, and that the clause is not an
assignment or label. Instructions typically are well-defined REXX
language components, such as loops and function calls.

Interactive trace is a trace mode, where the interpreter halts
execution between each clause, and offer the user the possibility
to specify arbitrary REXX statements to be executed before the
execution continues.

Label

LIFO

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

Literal string is a token in a REXX script, that basically is
surrounded by quotation marks, in order to make a character string
containing the same characters as the literal string.

Keyword is a element from finite set of symbols.

Main level

Main program

Name space is a collection of named variables. In general, the
expression is used when referring to the set of variables
available to the program at some point during interpretation.

Nullstring is a character string having the length zero, i.e. an
empty character string. [Note the difference from the undefined
string.]

Operating system

Parameters

Parsing

Procedure level

Program is a collection of REXX code, which may be zero or more
scripts, or other repositories of REXX code. However, a program
must contain a all the code to be executed.

Queue see “external data queue” or “stack”.

Routine is a unit during run-time, which is a procedural level.
Certain settings are saved across routines. One routine (the
caller routine) can be temporarily suspended while another routine
is executed (the called routine). With such nesting, the called
routine must be terminated before execution of the caller routine
can be resumed. Normally, the CALL instruction or a function call
is used to do this. Note that the main level of a REXX script is
also a routine.

Script is a single file containing REXX code.

Space separated

Stack

Statement is a clause having in general some action, i.e. a clause
other than a null clause. [Assignments, commands and instructions
are statements.]

Stem collection

Stem variable

Strictly order

Subkeyword is a keyword, but the prefix “sub” stresses the fact
that a symbol is a keyword only in certain contexts [e.g. inside a
particular instruction].

Subroutine is a routine which has been invoked from another REXX
routine; i.e. it can not be the “main” program of a REXX script.

Symbol

Symbol table

Tail substitution

Term

Token

Token separator

Uninitialized

Variable name

Variable symbol

Whitespace One or several consecutive blank characters.



hex literal

norm. hex string

bin {digit,string,literal}

norm. bin string

packed char string

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.

                                 
                                 

PREV NEXT