| Previous | Contents | Index |
label: An integer, from 1 to 5 digits long, that is
used to identify a statement. For example, labels can be used to refer
to a FORMAT statement or branch target statement.
language extension: A HP Fortran language element
or interpretation that is not part of the Fortran 95 standard.
lexical token:
A sequence of one or more characters that have an indivisible
interpretation. A lexical token is the smallest meaningful unit (a
basic language element) of a Fortran 95/90 statement; for example,
constants and statement keywords.
library function: See intrinsic
procedure.
linker: A system program that creates an executable
program from one or more object files (or modules) produced by a
language compiler or assembler. The linker resolves external
references, acquires referenced library routines, and performs other
processing required to create executable images.
list-directed I/O statement: An implicit, formatted
I/O statement that uses an asterisk (*) specifier rather than an
explicit format specification. See also formatted I/O
statement and namelist I/O statement.
listing: A printed copy of a program.
literal constant: A constant without a name.
little endian:
A method of data storage in which the least significant bit of a
numeric value spanning multiple bytes is in the lowest addressed byte.
This is the method used on HP systems. Contrast with
big endian.
local entity: An entity that can be used only within
the context of a subprogram (its scoping unit); for example, a
statement label. A local entity has local scope. See also
global entity.
local optimization: A level of optimization enabling
optimizations within the source program unit and recognition of common
expressions. See also optimization.
local symbol: A name defined in a program unit that is
not accessible outside of that program unit.
logical constant: A constant that specifies the value
.TRUE. or .FALSE..
logical expression: An integer or logical constant,
variable, function value, or another constant expression, joined by a
relational or logical operator. The logical expression is evaluated to
a value of either true or false. For example,
.NOT. 6.5 + (B .GT. D)
.
logical operator: A symbol that represents an
operation on logical expressions. The logical operators are .AND.,
.OR., .NEQV., .XOR., .EQV., and .NOT..
logical unit:
A channel in memory through which data transfer occurs between the
program and the device or file. See also unit
identifier.
longword:
Four contiguous bytes (32 bits) starting on any addressable byte
boundary. Bits are numbered 0 to 31. The address of the longword is the
address of the byte containing bit 0. When the longword is interpreted
as a signed integer, bit 31 is the sign bit. The value of signed
integers is in the range --2**31 to 2**31--1. The value of unsigned
integers is in the range 0 to 2**32--1.
loop: A group of statements that are executed
repeatedly until an ending condition is reached.
lower bound: See bounds.
main program: A program unit containing a PROGRAM
statement (or not containing a SUBROUTINE, FUNCTION, or BLOCK DATA
statement). The main program is the first program unit to receive
control when a program is run, and exercises control over subprograms.
Contrast with subprogram.
many-one array section: An array section with a vector
subscript having two or more elements with the same value.
message file: A file that contains the diagnostic
message text of errors that can occur during program execution (run
time).
misaligned data: Data not aligned on a natural
boundary. See also natural boundary.
module: A program unit that contains specifications
and definitions that other program units can access (unless the module
entities are declared PRIVATE). Modules are referenced in USE
statements.
module procedure: A subroutine or function defined
within a module subprogram (the module procedure's host). The module
procedure appears between a CONTAINS and END statement in its host
module, and inherits the host module's environment through host
association. A module procedure can be declared PRIVATE to the module;
it is public by default.
module subprogram: A subprogram that is contained in a
module. (It cannot be an internal subprogram.)
multinational character set: An 8-bit character
encoding scheme associating an integer from 128 through 255 with 128
characters. This character set contains international alphanumeric
characters, including characters with diacritical marks. See
also ASCII.
multitasking: The ability of an operating system to
execute several programs (tasks) at once.
multithreading: The ability of an operating system to execute different parts of a program, called threads, simultaneously.
If the system supports parallel processing, multiple processors may be
used to execute the threads.
name: Identifies an entity within a Fortran program
unit (such as a variable, function result, common block, named
constant, procedure, program unit, namelist group, or dummy argument).
In FORTRAN 77, this term was called a symbolic name.
name association: Pertains to argument, host, or use
association. See also argument association,
host association, and use association.
named common block: A common block (one or more
contiguous areas of storage) with a name. Common blocks are defined by
a COMMON statement.
named constant: A constant that has a name. In FORTRAN
77, this term was called a symbolic constant.
namelist I/O statement: An implicit, formatted I/O
statement that uses a namelist group specifier rather than an explicit
format specifier. See also formatted I/O
statement and list-directed I/O statement.
NaN: Not-a-Number. The condition that results from a
floating-point operation that has no mathematical meaning; for example,
zero divided by zero.
natural boundary: The virtual address of a data item
that is the multiple of the size of its data type. For example, a
REAL(8) (REAL*8) data item aligned on natural boundaries has an address
that is a multiple of eight.
naturally aligned record: A record that is aligned on
a hardware-specific natural boundary; each field is naturally aligned.
(For more information, see the HP Fortran for OpenVMS User Manual.) Contrast with
packed record.
nesting: The placing of one entity (such as a
construct, subprogram, format specification, or loop) inside another
entity of the same kind. For example, nesting a loop within another
loop (a nested loop), or nesting a subroutine within another subroutine
(a nested subroutine).
nonexecutable statement: A Fortran 95/90 statement
that describes program attributes, but does not cause any action to be
taken when the program is executed.
numeric expression: A numeric constant, variable, or
function value, or combination of these, joined by numeric operators
and parentheses, so that the entire expression can be evaluated to
produce a single numeric value. For example,
-L
or
X+(Y-4.5)*Z
.
numeric operator: A symbol designating an arithmetic
operation. In Fortran 95/90, the symbols +, -, *, /, and ** are used to
designate addition, subtraction, multiplication, division, and
exponentiation, respectively.
numeric storage unit: The unit of storage for holding
a non-pointer scalar value of type default real, default integer, or
default logical. One numeric storage unit corresponds to 4 bytes of
memory.
object: See data object.
object file: The binary output of a language processor
(such as the assembler or compiler), which can either be executed or
used as input to the linker.
octal constant: A constant that is a string of octal
(base 8) digits (range of 0 to 7) enclosed by apostrophes or quotation
marks and preceded by the letter O.
operand: The passive element in an expression on which
an operation is performed. Every expression must have at least one
operand. For example, in
I .NE. J
,
I and J are operands. Contrast with operator.
operation: A computation involving one or two operands.
operator: The active element in an expression that
performs an operation. An expression can have zero or more operators.
For example, in
I .NE. J
, .NE. is the operator. Contrast with operand.
optimization: The process of producing efficient
object or executing code that takes advantage of the hardware
architecture to produce more efficient execution.
optional argument: A dummy argument that has the
OPTIONAL attribute (or is included in an OPTIONAL statement in the
procedure definition). Such an argument does not have to be associated
with an actual argument.
order of subscript progression: A characteristic of a
multidimensional array in which the leftmost subscripts vary most
rapidly.
overflow: An error condition occurring when an
arithmetic operation yields a result that is larger than the maximum
value in the range of a data type.
packed record: A record that starts on an arbitrary
byte boundary; each field starts in the next unused byte. Contrast
with naturally aligned record.
pad: The filling of unused positions in a field or
character string with dummy data (such as zeros or blanks).
parallel processing: The simultaneous use of more than
one processor (CPU) to execute a program.
parameter: Can be either of the following:
parent process: A process that initiates and controls
another process (child). The parent process defines the environment for
the child process. Further, the parent process can suspend or terminate
without affecting the child process. See also child
process.
platform: A combination of operating system and
hardware that provides a distinct environment in which to use a
software product (for example, OpenVMS on Alpha processors).
pointer: Is one of the following:
pointer association: The association of storage space
to a Fortran 95/90 pointer by means of a target. A pointer is
associated with a target after pointer assignment or the valid
execution of an ALLOCATE statement.
precision: The number of significant digits in a real
number. See also double-precision constant,
kind type parameter, and single-precision
constant.
primary: The simplest form of an expression. A primary can be any of the following data objects:
primary key: The required key within the data records
of an indexed file. This key is used to determine the placement of
records within the file and to build the primary index.
procedure: A computation that can be invoked during
program execution. It can be a subroutine or function, an internal,
external, dummy or module procedure, or a statement function. A
subprogram can define more than one procedure if it contains an ENTRY
statement. See also subprogram.
procedure interface: The statements that specify the
name and characteristics of a procedure, the name and attributes of
each dummy argument, and the generic identifier (if any) by which the
procedure can be referenced. If these properties are all known to the
calling program, the procedure interface is explicit; otherwise it is
implicit.
program: A set of instructions that can be compiled
and executed by itself. Program blocks contain a declaration and an
executable section.
program section: A particular common block or local
data area for a particular routine containing equivalence groups.
program unit: The fundamental component of an
executable program. A sequence of statements and optional comments that
can be a main program, a procedure, an external program, or a block
data program unit.
quadword:
Four contiguous words (64 bits) starting on any addressable byte
boundary. Bits are numbered 0 to 63. (Bit 63 is used as the sign bit.)
A quadword is identified by the address of the word containing the
low-order bit (bit 0). The value of a signed quadword integer is in the
range --2**63 to 2**63--1.
random access: See direct
access.
rank: The number of dimensions in an array. A scalar
has a rank of zero.
rank-one object: A data structure comprising scalar
elements with the same data type and organized as a simple linear
sequence. See also scalar.
real constant: A constant that is a number written
with a decimal point, exponent, or both. It can have single precision
(REAL(4)) or double precision (REAL(8)). It can also have quad
precision (REAL(16)).
record: Can be either of the following:
record access: The method used to store and retrieve
records in a file.
record structure declaration: A block of statements
that define the fields in a record. The block begins with a STRUCTURE
statement and ends with END STRUCTURE. The name of the structure must
be specified in a RECORD statement.
record type: The property that determines whether
records in a file are all the same length, of varying length, or use
other conventions to define where one record ends and another begins.
recursion: Pertains to a subroutine or function that
directly or indirectly references itself.
reference: Can be any of the following:
relational expression: An expression containing one
relational operator and two operands of numeric or character type. The
result is a value that is true or false. For example,
A-C .GE. B+2
or
DAY .EQ. 'MONDAY'
.
relational operator: The symbols used to express a
relational condition or expression. The relational operators are ==,
/=, <, <=, >, and >= (.EQ., .NE., .LT., .LE., .GT., and
.GE.).
relative file organization: A file organization that
consists of a series of component positions, called cells, numbered
consecutively from 1 to n. HP Fortran uses these numbered,
fixed-length cells to calculate the component's physical position in
the file.
routine: A subprogram; a function or procedure.
See also function,
subroutine, and procedure.
run time: The time during which a computer executes
the statements of a program.
saved object: A variable that retains its association
status, allocation status, definition status, and value after execution
of a RETURN or END statement in the scoping unit containing the
declaration.
scalar: Pertaining to data items with a rank of zero.
A single data object of any intrinsic or derived data type.
Contrast with array. See also
rank-one object.
scalar memory reference: A reference to a scalar
variable, scalar record field, or array element that resolves into a
single data item (having a data type) and can be assigned a value with
an assignment statement. It is similar to a scalar reference, but it
excludes constants, character substrings, and expressions.
scalar reference: A reference to a scalar variable,
scalar record field, derived-type component, array element, constant,
character substring, or expression that resolves into a single data
item having a data type. Contrast with scalar memory
reference.
scalar variable: A variable name specifying one
storage location.
scale factor: A number indicating the location of the
decimal point in a real number and, if there is no exponent, the size
of the number on input.
scope: The portion of a program in which a declaration
or a particular name has meaning. Scope can be global (throughout an
executable program), scoping unit (local to the scoping unit), or
statement (within a statement, or part of a statement).
scoping unit: The part of the program in which a name has meaning. It is one of the following:
Scoping units cannot overlap, though one scoping unit can contain
another scoping unit. (The outer scoping unit is called the host
scoping unit.)
section subscript: A subscript list (enclosed in
parentheses and appended to the array name) indicating a portion
(section) of an array. At least one of the subscripts in the list must
be a subscript triplet or vector subscript. The number of section
subscripts is the rank of the array. See also array
section, subscript, subscript
triplet, and vector subscript.
seed: A value (which can be assigned to a variable)
that is required in order to properly determine the result of a
calculation; for example, the argument i in the random number generator
(RAN) function syntax:
y = RAN (i)
.
selector: A mechanism for designating the following:
sequence: A set ordered by a one-to-one correspondence
with the numbers 1 through n, where n is the total number of
elements in the sequence. A sequence can be empty (contain no elements).
sequential access: A method for retrieving or storing
data in which the data (record) is read from, written to, or removed
from a file based on the logical order (sequence) of the record in the
file. (The record cannot be accessed directly.) Contrast with
direct access.
sequential file organization: A file organization in
which records are stored one after the other, in the order in which
they were written to the file.
shape: The rank and extents of an array. Shape can be
represented by a rank-one array (vector) whose elements are the extents
in each dimension.
shape conformance: Pertains to the rule concerning
operands of binary intrinsic operations in expressions: to be in shape
conformance, the two operands must both be arrays of the same shape, or
one or both of the operands must be scalars.
short field termination: The use of a comma (,) to
terminate the field of a numeric data edit descriptor. This technique
overrides the field width (w) specification in the data edit descriptor
and therefore avoids padding of the input field. The comma can only
terminate fields less than w characters long. See also
data edit descriptor.
signal: The software mechanism used to indicate that
an exception condition (abnormal event) has been detected. For example,
a signal can be generated by a program or hardware error, or by request
of another program.
single-precision constant: A processor approximation
of the value of a real number that occupies 4 bytes of memory and can
assume a positive, negative, or zero value. The precision is less than
a constant of double-precision type. For the precise ranges of the
single-precision constants, see the HP Fortran for OpenVMS User Manual. See also
denormalized number.
size: The total number of elements in an array (the
product of the extents).
source file: A program or portion of a program
library, such as an object file, or image file.
specification expression: A restricted expression that
is of type integer and has a scalar value. This type of expression
appears only in the declaration of array bounds and character lengths.
specification statement: A nonexecutable statement
that provides information about the data used in the source program.
Such a statement can be used to allocate and initialize variables,
arrays, records, and structures, and define other characteristics of
names used in a program.
statement: An instruction in a programming language that represents a step in a sequence of actions or a set of declarations. In Fortran 95/90, an ampersand (&) can be used to continue a statement from one line to another, and a semicolon (;) can be used to separate several statements on one line.
There are two main classes of statements: executable and nonexecutable.
See also executable statement and
nonexecutable statement.
statement function: A computing procedure defined by a
single statement in the same program unit in which the procedure is
referenced.
statement function definition: A statement that defines a statement function. Its form is the statement function name (followed by its optional dummy arguments in parentheses), followed by an equal sign (=), followed by a numeric, logical, or character expression.
A statement function definition must precede all executable statements
and follow all specification statements. See also
statement function.
statement keyword: A word that begins the syntax of a
statement. All program statements (except assignment statements and
statement function definitions) begin with a statement keyword.
Examples are INTEGER, DO, IF, and WRITE.
statement label: See label.
static variable: A variable whose storage is allocated
for the entire execution of a program.
storage association: The relationship between two
storage sequences when the storage unit of one is the same as the
storage unit of the other. Storage association is provided by the
COMMON and EQUIVALENCE statements. For modules, pointers, allocatable
arrays, and automatic data objects, the SEQUENCE statement defines a
storage order for structures.
storage location: An addressable unit of main memory.
storage sequence: A sequence of any number of
consecutive storage units. The size of a storage sequence is the number
of storage units in the storage sequence. A sequence of storage
sequences forms a composite storage sequence. See also
storage association and storage unit.
storage unit: In a storage sequence, the number of
storage units needed to represent one real, integer, logical, or
character value. See also character storage
unit, numeric storage unit, and
storage sequence.
stride: The increment between subscript values that
can optionally be specified in a subscript triplet. If it is omitted,
it is assumed to be one.
string edit descriptor: A format descriptor that
transfers characters to an output record.
structure: Can be either of the following:
structure component: Can be either of the following:
structure constructor: A mechanism that is used to
specify a scalar value of a derived type. A structure constructor is
the name of the type followed by a parenthesized list of values for the
components of the type.
subobject: Part of a data object (parent object) that
can be referenced and defined separately from other parts of the data
object. A subobject can be an array element, an array section, a
substring, a derived type, or a structure component. Subobjects are
referenced by designators and can be considered to be data objects
themselves. See also designator.
subobject designator: See
designator.
subprogram: A user-written function or subroutine
subprogram that can be invoked from another program unit to perform a
specific task. Contrast with main program.
subroutine: A procedure that can return many values, a single value, or no value to the calling program unit (through arguments). A subroutine is invoked by a CALL statement in another program unit.
In Fortran 95/90, a subroutine can also be used to define a new form of
assignment (defined assignment), which is different from those
intrinsic to Fortran 95/90. Such assignments are invoked with
assignment syntax (using the = symbol) rather than the CALL statement.
See also function, statement
function, and subroutine subprogram.
| Previous | Next | Contents | Index |