This glossary defines terms that are commonly used in this document.
It includes definitions developed by the American National Standards Institute
(ANSI) and entries from the IBM Dictionary of
Computing.
- A
- active processor
- See online processor.
- actual argument
- An expression, variable, procedure, or alternate return specifier that is
specified in a procedure reference.
- alias
- A single piece of storage that can be accessed through more than a single
name. Each name is an alias for that storage.
- alphabetic character
- A letter or other symbol, excluding digits, used in a language.
Usually the uppercase and lowercase letters A through Z plus other special
symbols (such as $ and _) allowed by a particular language.
- alphanumeric
- Pertaining to a character set that contains letters, digits, and usually
other characters, such as punctuation marks and mathematical symbols.
- American National Standard Code for Information Interchange
- See ASCII.
- argument
- An expression that is passed to a function or subroutine. See also
actual argument, dummy argument.
- argument association
- The relationship between an actual argument and a dummy argument during
the invoking of a procedure.
- arithmetic constant
- A constant of type integer, real, or complex.
- arithmetic expression
- One or more arithmetic operators and arithmetic primaries, the evaluation
of which produces a numeric value. An arithmetic expression can be an
unsigned arithmetic constant, the name of an arithmetic constant, or a
reference to an arithmetic variable, function reference, or a combination of
such primaries formed by using arithmetic operators and parentheses.
- arithmetic operator
- A symbol that directs the performance of an arithmetic operation.
The intrinsic arithmetic operators are:
+ addition
- subtraction
* multiplication
/ division
** exponentiation
- array
- An entity that contains an ordered group of scalar data. All
objects in an array have the same data type and type parameters.
- array declarator
- The part of a statement that describes an array used in a program
unit. It indicates the name of the array, the number of dimensions it
contains, and the size of each dimension.
- array element
- A single data item in an array, identified by the array name and one or
more subscripts. See also subscript.
- array name
- The name of an ordered set of data items.
- array section
- A subobject that is an array and is not a structure component.
- ASCII
- The standard code, using a coded character set consisting of 7-bit coded
characters (8-bits including parity check), that is used for information
interchange among data processing systems, data communication systems, and
associated equipment. The ASCII set consists of control characters and
graphic characters. See also Unicode.
- asynchronous
- Pertaining to events that are not synchronized in time or do not occur in
regular or predictable time intervals. For example, input events are
controlled by the user; the program can read them later.
- assignment statement
- An executable statement that defines or redefines a variable based on the
result of expression evaluation.
- associate name
- The name by which a selector of an ASSOCIATE construct is known
within the construct.
- attribute
- A property of a data object that may be specified in a type declaration
statement, attribute specification statement, or through a default
setting.
- automatic parallelization
- The process by which the compiler attempts to parallelize both explicitly
coded DO loops and DO loops generated by the compiler for
array language.
- B
- binary constant
- A constant that is made of one or more binary digits (0 and 1).
- bind
- To relate an identifier to another object in a program; for example,
to relate an identifier to a value, an address or another identifier, or to
associate formal parameters and actual parameters.
- blank common
- An unnamed common block.
- block data subprogram
- A subprogram headed by a BLOCK DATA statement and used to
initialize variables in named common blocks.
- bss storage
- Uninitialized static storage.
- busy-wait
- The state in which a thread keeps executing in a tight loop looking for
more work once it has completed all of its work and there is no new work to
do.
- byte constant
- A named constant that is of type byte.
- byte type
- A data type representing a one-byte storage area that can be used wherever
a LOGICAL(1), CHARACTER(1), or INTEGER(1) can be
used.
- C
- character constant
- A string of one or more alphabetic characters enclosed in apostrophes or
double quotation marks.
- character expression
- A character object, a character-valued function reference, or a sequence
of them separated by the concatenation operator, with optional
parentheses.
- character operator
- A symbol that represents an operation, such as concatenation (//), to be
performed on character data.
- character set
- All the valid characters for a programming language or for a computer
system.
- character string
- A sequence of consecutive characters.
- character substring
- A contiguous portion of a character string.
- character type
- A data type that consists of alphanumeric characters. See also
data type.
- chunk
- A subset of consecutive loop iterations.
- collating sequence
- The sequence in which the characters are ordered for the purpose of
sorting, merging, comparing, and processing indexed data
sequentially.
- comment
- A language construct for the inclusion of text in a program that has no
effect on the execution of the program.
- common block
- A storage area that may be referred to by a calling program and one or
more subprograms.
- compile
- To translate a source program into an executable program (an object
program).
- compiler directive
- Source code that controls what XL Fortran does rather than what the user
program does.
- complex constant
- An ordered pair of real or integer constants separated by a comma and
enclosed in parentheses. The first constant of the pair is the real
part of the complex number; the second is the imaginary part.
- complex number
- A number consisting of an ordered pair of real numbers, expressible in the
form a+bi, where a and b are real numbers and
i squared equals -1.
- complex type
- A data type that represents the values of complex numbers. The
value is expressed as an ordered pair of real data items separated by a comma
and enclosed in parentheses. The first item represents the real part of
the complex number; the second represents the imaginary part.
- conform
- To adhere to a prevailing standard. An executable program conforms
to the Fortran 95 Standard if it uses only those forms and relationships
described therein and if the executable program has an interpretation
according to the Fortran 95 Standard. A program unit conforms to the
Fortran 95 Standard if it can be included in an executable program in a manner
that allows the executable program to be standard-conforming. A
processor conforms to the standard if it executes standard-conforming programs
in a manner that fulfills the interpretations prescribed in the
standard.
- connected unit
- In XL Fortran, a unit that is connected to a file in one of three
ways: explicitly via the OPEN statement to a named file,
implicitly, or by preconnection.
- constant
- A data object with a value that does not change. The four classes
of constants specify numbers (arithmetic), truth values (logical), character
data (character), and typeless data (hexadecimal, octal, and binary).
See also variable.
- construct
- A sequence of statements starting with a SELECT CASE,
DO, IF, or WHERE statement and ending with the
corresponding terminal statement.
- continuation line
- A line that continues a statement beyond its initial line.
- control statement
- A statement that is used to alter the continuous sequential invocation of
statements; a control statement may be a conditional statement, such as
IF, or an imperative statement, such as STOP.
- D
- data object
- A variable, constant, or subobject of a constant.
- data striping
- Spreading data across multiple storage devices so that I/O operations can
be performed in parallel for better performance. Also known as
disk striping.
- data transfer statement
- A READ, WRITE, or PRINT statement.
- data type
- The properties and internal representation that characterize data and
functions. The intrinsic types are integer, real, complex, logical, and
character. See also intrinsic.
- debug line
- Allowed only for fixed source form, a line containing source code that is
to be used for debugging. Debug lines are defined by a D or
X in column 1. The handling of debug lines is controlled by
the -qdlines and -qxlines compiler options.
- default initialization
- The initialization of an object with a value specified as part of a
derived type definition.
- definable variable
- A variable whose value can be changed by the appearance of its name or
designator on the left of an assignment statement.
- delimiters
- A pair of parentheses or slashes (or both) used to enclose syntactic
lists.
- denormalized number
- An IEEE number with a very small absolute value and lowered
precision. A denormalized number is represented by a zero exponent and
a non-zero fraction.
- derived type
- A type whose data have components, each of which is either of intrinsic
type or of another derived type.
- digit
- A character that represents a nonnegative integer. For example, any
of the numerals from 0 through 9.
- directive
- A type of comment that provides instructions and information to the
compiler.
- disk striping
- See data striping.
- DO loop
- A range of statements invoked repetitively by a DO
statement.
- DO variable
- A variable, specified in a DO statement, that is initialized or
incremented prior to each occurrence of the statement or statements within a
DO range. It is used to control the number of times the
statements within the range are executed.
- DOUBLE PRECISION constant
- A constant of type real with twice the precision of the default real
precision.
- dummy argument
- An entity whose name appears in the parenthesized list following the
procedure name in a FUNCTION, SUBROUTINE, ENTRY, or
statement function statement.
- dynamic dimensioning
- The process of re-evaluating the bounds of an array each time the array is
referenced.
- dynamic extent
- For a directive, the lexical extent of the directive and all subprograms
called from within the lexical extent.
- E
- edit descriptor
- An abreviated keyword that controls the formatting of integer, real, or
complex data.
- elemental
- Pertaining to an intrinsic operation, procedure or assignment that is
applied independently to elements of an array or corresponding elements of a
set of conformable arrays and scalars.
- embedded blank
- A blank that is surrounded by any other characters.
- entity
- A general term for any of the following: a program unit, procedure,
operator, interface block, common block, external unit, statement function,
type, named variable, expression, component of a structure, named constant,
statement label, construct, or namelist group.
- environment variable
- A variable that describes the operating environment of the process.
- executable program
- A program that can be executed as a self-contained procedure. It
consists of a main program and, optionally, modules, subprograms and
non-Fortran external procedures.
- executable statement
- A statement that causes an action to be taken by the program; for
example, to perform a calculation, test conditions, or alter normal sequential
execution.
- explicit initialization
- The initialization of an object with a value stated in a data statement
initial value list, block data program unit, type declaration statement, or
array constructor.
- explicit interface
- For a procedure referenced in a scoping unit, the property of being an
internal procedure, module procedure, intrinsic procedure, external procedure
that has an interface block, recursive procedure reference in its own scoping
unit, or dummy procedure that has an interface block.
- expression
- A sequence of operands, operators, and parentheses. It may be a
variable, a constant, or a function reference, or it may represent a
computation.
- extended-precision constant
- A processor approximation to the value of a real number that occupies 16
consecutive bytes of storage.
- external file
- A sequence of records on an input/output device. See also
internal file.
- external name
- The name of a common block, subroutine, or other global procedure, which
the linker uses to resolve references from one compilation unit to
another.
- external procedure
- A procedure that is defined by an external subprogram or by a means other
than Fortran.
- F
- field
- An area in a record used to contain a particular category of
data.
- file
- A sequence of records. See also external file,
internal file.
- file index
- See i-node.
- floating-point number
- A real number represented by a pair of distinct numerals. The real
number is the product of the fractional part, one of the numerals, and a value
obtained by raising the implicit floating-point base to a power indicated by
the second numeral.
- format
- (1) A defined arrangement of such things as characters, fields, and lines,
usually used for displays, printouts, or files.
- (2) To arrange such things as characters, fields, and lines.
- formatted data
- Data that is transferred between main storage and an input/output device
according to a specified format. See also list-directed and
unformatted record.
- function
- A procedure that returns the value of a single variable or an object and
that usually has a single exit. See also intrinsic
procedure, subprogram.
- G
- generic identifier
- A lexical token that appears in an INTERFACE statement and is
associated with all the procedures in an interface block.
- H
- hard limit
- A system resource limit that can only be raised or lowered by using root
authority, or cannot be altered because it is inherent in the system or
operating environments's implementation. See also soft
limit.
- hexadecimal
- Pertaining to a system of numbers to the base sixteen; hexadecimal
digits range from 0 (zero) through 9 (nine) and A (ten) through F
(fifteen).
- hexadecimal constant
- A constant, usually starting with special characters, that contains only
hexadecimal digits.
- high order transformations
- A type of optimization that restructures loops.
- Hollerith constant
- A string of any characters capable of representation by XL Fortran and
preceded with nH, where n is the number of
characters in the string.
- host
- A main program or subprogram that contains an internal procedure is called
the host of the internal procedure. A module that contains a module
procedure is called the host of the module procedure.
- host association
- The process by which an internal subprogram, module subprogram, or
derived-type definition accesses the entities of its host.
- I
- IPA
- Interprocedural analysis, a type of optimization that allows optimizations
to be performed across procedure boundaries and across calls to procedures in
separate source files.
- implicit interface
- A procedure referenced in a scoping unit other than its own is said to
have an implicit interface if the procedure is an external procedure that does
not have an interface block, a dummy procedure that does not have an interface
block, or a statement function.
- implied DO
- An indexing specification (similar to a DO statement, but without
specifying the word DO) with a list of data elements, rather than a
set of statements, as its range.
- infinity
- An IEEE number (positive or negative) created by overflow or division by
zero. Infinity is represented by an exponent where all the bits are
1's, and a zero fraction.
- i-node
- The internal structure that describes the individual files in the
operating system. There is one i-node for each file. An i-node
contains the node, type, owner, and location of a file. A table of
i-nodes is stored near the beginning of a file system. Also known as
file index.
- input/output (I/O)
- Pertaining to either input or output, or both.
- input/output list
- A list of variables in an input or output statement specifying the data to
be read or written. An output list can also contain a constant, an
expression involving operators or function references, or an expression
enclosed in parentheses.
- integer constant
- An optionally signed digit string that contains no decimal point.
- interface block
- A sequence of statements from an INTERFACE statement to the
corresponding END INTERFACE statement.
- interface body
- A sequence of statements in an interface block from a FUNCTION or
SUBROUTINE statement to the corresponding END
statement.
- interference
- A situation in which two iterations within a DO loop have
dependencies upon one another.
- internal file
- A sequence of records in internal storage. See also external
file.
- interprocedural analysis
- See IPA.
- intrinsic
- Pertaining to types, operations, assignment statements, and procedures
that are defined by Fortran language standards and can be used in any scoping
unit without further definition or specification.
- intrinsic module
- A module that is provided by the compiler and is available to any
program.
- intrinsic procedure
- A procedure that is provided by the compiler and is available to any
program.
- K
- keyword
- (1) A statement keyword is a word that is part of the syntax of a statement
(or directive) and that may be used to identify the statement.
- (2) An argument keyword specifies a name for a dummy argument.
- kind type parameter
- A parameter whose values label the available kinds of an intrinsic
type.
- L
- lexical extent
- All of the code that appears directly within a directive
construct.
- lexical token
- A sequence of characters with an indivisible interpretation.
- link-edit
- To create a loadable computer program by means of a linker.
- linker
- A program that resolves cross-references between separately compiled or
assembled object modules and then assigns final addresses to create a single
relocatable load module. If a single object module is linked, the
linker simply makes it relocatable.
- list-directed
- A predefined input/output format that depends on the type, type
parameters, and values of the entities in the data list.
- literal
- A symbol or a quantity in a source program that is itself data, rather
than a reference to data.
- literal constant
- A lexical token that directly represents a scalar value of intrinsic
type.
- load balancing
- An optimization strategy that aims at evenly distributing the work load
among processors.
- logical constant
- A constant with a value of either true or false (or
T or F).
- logical operator
- A symbol that represents an operation on logical expressions:
.NOT. (logical negation)
.AND. (logical conjunction)
.OR. (logical union)
.EQV. (logical equivalence)
.NEQV. (logical nonequivalence)
.XOR. (logical exclusive disjunction)
- loop
- A statement block that executes repeatedly.
- M
- _main
- The default name given to a main program by the compiler if the main
program was not named by the programmer.
- main program
- The first program unit to receive control when a program is run.
See also subprogram.
- master thread
- The head process of a group of threads.
- module
- A program unit that contains or accesses definitions to be accessed by
other program units.
- mutex
- A primitive object that provides mutual exclusion between threads.
A mutex is used cooperatively between threads to ensure that only one of the
cooperating threads is allowed to access shared data or run certain
application code at a time.
- N
- NaN (not-a-number)
- A symbolic entity encoded in floating-point format that does not
correspond to a number. See also quiet NaN, signalling
NaN.
- name
- A lexical token consisting of a letter followed by up to 249 alphanumeric
characters (letters, digits, and underscores). Note that in FORTRAN 77,
this was called a symbolic name.
- named common
- A separate, named common block consisting of variables.
- namelist group name
- The first parameter in the NAMELIST statement that names a list of names
to be used in READ, WRITE, and PRINT statements.
- negative zero
- An IEEE representation where the exponent and fraction are both zero, but
the sign bit is 1. Negative zero is treated as equal to positive
zero.
- nest
- To incorporate a structure or structures of some kind into a structure of
the same kind. For example, to nest one loop (the nested loop) within
another loop (the nesting loop); to nest one subroutine (the nested
subroutine) within another subroutine (the nesting subroutine).
- nonexecutable statement
- A statement that describes the characteristics of a program unit, data,
editing information, or statement functions, but does not cause any action to
be taken by the program.
- nonexisting file
- A file that does not physically exist on any accessible storage
medium.
- normal
- A floating point number that is not denormal, infinity, or NaN.
- not-a-number
- See NaN.
- numeric constant
- A constant that expresses an integer, real, complex, or byte
number.
- O
- octal
- Pertaining to a system of numbers to the base eight; the octal digits
range from 0 (zero) through 7 (seven).
- octal constant
- A constant that is made of octal digits.
- one-trip DO-loop
- A DO loop that is executed at least once, if reached, even if the
iteration count is equal to 0. (This type of loop is from FORTRAN
66.)
- online processor
- In a multiprocessor machine, a processor that has been activated (brought
online). The number of online processors is less than or equal to the
number of physical processors actually installed in the machine. Also
known as active processor.
- operator
- A specification of a particular computation involving one or two
operands.
- P
- pad
- To fill unused positions in a field or character string with dummy data,
usually zeros or blanks.
- paging space
- Disk storage for information that is resident in virtual memory but is not
currently being accessed.
- PDF
- See profile-directed feedback.
- pointee array
- An explicit-shape or assumed-size array that is declared in an integer
POINTER statement or other specification statement.
- pointer
- A variable that has the POINTER attribute. A pointer must
not be referenced or defined unless it is pointer associated with a
target. If it is an array, it does not have a shape unless it is
pointer-associated.
- preconnected file
- A file that is connected to a unit at the beginning of execution of the
executable program. Standard error, standard input, and standard output
are preconnected files (units 0, 5 and 6, respectively).
- predefined convention
- The implied type and length specification of a data object, based on the
initial character of its name when no explicit specification is given.
The initial characters I through N imply type integer of length 4; the
initial characters A through H, O through Z, $, and _ imply type real of
length 4.
- present
- A dummy argument is present in an instance of a subprogram if it is
associated with an actual argument and the actual argument is a dummy argument
that is present in the invoking procedure or is not a dummy argument of the
invoking procedure.
- primary
- The simplest form of an expression: an object, array constructor,
structure constructor, function reference, or expression enclosed in
parentheses.
- procedure
- A computation that may be invoked during program execution. It may
be a function or a subroutine. It may be an intrinsic procedure, an
external procedure, a module procedure, an internal procedure, a dummy
procedure, or a statement function. A subprogram may define more than
one procedure if it contains ENTRY statements.
- profile-directed feedback (PDF)
- A type of optimization that uses information collected during application
execution to improve performance of conditional branches and in frequently
executed sections of code.
- program unit
- A main program or subprogram.
- pure
- An attribute of a procedure that indicates there are no side
effects.
- Q
- quiet NaN
- A NaN (not-a-number) value that does not signal an exception. The
intent of a quiet NaN is to propagate a NaN result through subsequent
computations. See also NaN, signalling
NaN.
- R
- random access
- An access method in which records can be read from, written to, or removed
from a file in any order. See also sequential access.
- rank
- The number of dimensions of an array.
- real constant
- A string of decimal digits that expresses a real number. A real
constant must contain a decimal point, a decimal exponent, or both.
- record
- A sequence of values that is treated as a whole within a file.
- relational expression
- An expression that consists of an arithmetic or character expression,
followed by a relational operator, followed by another arithmetic or character
expression.
- relational operator
- The words or symbols used to express a relational condition or a
relational expression:
.GT. greater than
.GE. greater than or equal to
.LT. less than
.LE. less than or equal to
.EQ. equal to
.NE. not equal to
- result variable
- The variable that returns the value of a function.
- return specifier
- An argument specified for a statement, such as CALL, that indicates to
which statement label control should return, depending on the action specified
by the subroutine in the RETURN statement.
- S
- scalar
- (1) A single datum that is not an array.
- (2) Not having the property of being an array.
- scale factor
- A number indicating the location of the decimal point in a real number
(and, on input, if there is no exponent, the magnitude of the number).
- scope
- That part of an executable program within which a lexical token has a
single interpretation.
- scope attribute
- That part of an executable program within which a lexical token has a
single interpretation of a particular named property or entity.
- scoping unit
- (1) A derived-type definition.
- (2) An interface body, excluding any derived-type definitions and interface
bodies contained within it.
- (3) A program unit or subprogram, excluding derived-type definitions,
interface bodies, and subprograms contained within it.
- selector
- The object that is associated with the associate name in an
ASSOCIATE construct.
- semantics
- The relationships of characters or groups of characters to their meanings,
independent of the manner of their interpretation and use. See also
syntax.
- sequential access
- An access method in which records are read from, written to, or removed
from a file based on the logical order of the records in the file. See
also random access.
- signalling NaN
- A NaN (not-a-number) value that signals an invalid operation exception
whenever it appears as an operand. The intent of the signaling NaN is
to catch program errors, such as using an uninitialized variable. See
also NaN, quiet NaN.
- sleep
- The state in which a thread completely suspends execution until another
thread signals it that there is work to do.
- SMP
- See symmetric multiprocessing.
- soft limit
- A system resource limit that is currently in effect for a process.
The value of a soft limit can be raised or lowered by a process, without
requiring root authority. The soft limit for a resource cannot be
raised above the setting of the hard limit. See also hard
limit.
- spill space
- The stack space reserved in each subprogram in case there are too many
variables to hold in registers and the program needs temporary storage for
register contents.
- specification statement
- A statement that provides information about the data used in the source
program. The statement could also supply information to allocate data
storage.
- stanza
- A group of lines in a file that together have a common function or define
a part of the system. Stanzas are usually separated by blank lines or
colons, and each stanza has a name.
- statement
- A language construct that represents a step in a sequence of actions or a
set of declarations. Statements fall into two broad classes:
executable and nonexecutable.
- statement function
- A name, followed by a list of dummy arguments, that is equated with an
intrinsic or derived-type expression, and that can be used as a substitute for
the expression throughout the program.
- statement label
- A number from one through five digits that is used to identify a
statement. Statement labels can be used to transfer control, to define
the range of a DO, or to refer to a FORMAT statement.
- storage association
- The relationship between two storage sequences if a storage unit of one is
the same as a storage unit of the other.
- structure
- A scalar data object of derived type.
- structure component
- The part of a data object of derived-type corresponding to a component of
its type.
- subobject
- A portion of a named data object that may be referenced or defined
independently of other portions. It can be an array element, array
section, structure component, or substring.
- subprogram
- A function subprogram or a subroutine subprogram. Note that in
FORTRAN 77, a block data program unit was called a subprogram. See also
main program.
- subroutine
- A procedure that is invoked by a CALL statement or defined
assignment statement.
- subscript
- A subscript quantity or set of subscript quantities enclosed in
parentheses and used with an array name to identify a particular array
element.
- substring
- A contiguous portion of a scalar character string. (Although an
array section can specify a substring selector, the result is not a
substring.)
- symmetric multiprocessing (SMP)
- A system in which functionally-identical multiple processors are used in
parallel, providing simple and efficient load-balancing.
- synchronous
- Pertaining to an operation that occurs regularly or predictably with
regard to the occurrence of a specified event in another process.
- syntax
- The rules for the construction of a statement. See also
semantics.
- T
- target
- A named data object specified to have the TARGET attribute, a
data object created by an ALLOCATE statement for a pointer, or a
subobject of such an object.
- thread
- A stream of computer instructions that is in control of a process.
A multithread process begins with one stream of instructions (one thread) and
may later create other instruction streams to perform tasks.
- thread visible variable
- A variable that can be accessed by more than one thread.
- time slice
- An interval of time on the processing unit allocated for use in performing
a task. After the interval has expired, processing unit time is
allocated to another task, so a task cannot monopolize processing unit time
beyond a fixed limit.
- token
- In a programming language, a character string, in a particular format,
that has some defined significance.
- trigger constant
- A sequences of characters that identifies comment lines as compiler
comment directives.
- type declaration statement
- A statement that specifies the type, length, and attributes of an object
or function. Objects can be assigned initial values.
- U
- unformatted record
- A record that is transmitted unchanged between internal and external
storage.
- Unicode
- A universal character encoding standard that supports the interchange,
processing, and display of text that is written in any of the languages of the
modern world. It also supports many classical and historical texts in a
number of languages. The Unicode standard has a 16-bit international
character set defined by ISO 10646. See also
ASCII.
- unit
- A means of referring to a file to use in input/output statements. A
unit can be connected or not connected to a file. If connected, it
refers to a file. The connection is symmetric: that is, if a unit
is connected to a file, the file is connected to the unit.
- unsafe option
- Any option that could result in grossly incorrect results if used in the
incorrect context. Other options may result in very small variations
from the default result, which is usually acceptable. Typically, using
an unsafe option is an assertion that your code is not subject to the
conditions that make the option unsafe.
- use association
- The association of names in different scoping units specified by a
USE statement.
- V
- variable
- A data object whose value can be defined and redefined during the
execution of an executable program. It may be a named data object,
array element, array section, structure component, or substring. Note
that in FORTRAN 77, a variable was always scalar and named.
- X
- XPG4
- X/Open Common Applications Environment (CAE) Portability Guide Issue
4; a document which defines the interfaces of the X/Open Common
Applications Environment that is a superset of POSIX.1-1990,
POSIX.2-1992, and POSIX.2a-1992 containing extensions to POSIX
standards from XPG3.
- Z
- zero-length character
- A character object that has a length of 0 and is always defined.
- zero-sized array
- An array that has a lower bound that is greater than its corresponding
upper bound. The array is always defined.
