Glossary
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 invocation 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.
- assignment statement
- An executable statement
that defines or redefines a variable based on the result of expression evaluation.
- 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 comment directive
- A line in source code
that is not a Fortran statement but is recognized and acted on by the compiler.
- 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,
for example, 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 loop. 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 abbreviated 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 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 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 and array language.
- 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 at least
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 its corresponding END INTERFACE statement.
- interface body
- A sequence of statements in an interface
block from a FUNCTION or SUBROUTINE statement to its 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 may be used to identify the
statement.
- (2) An argument keyword specifies the name of 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.
- numeric storage unit
- The space occupied by a nonpointer
scalar object of type default integer, default real, or default logical.
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.
- procedure pointer
- A procedure entity
that has the EXTERNAL and POINTER attributes. It can be
pointer associated with an external procedure, a module procedure, a dummy
procedure or another procedure pointer.
- 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.
- signaling 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 sequence 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 undesirable
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.