HP OpenVMS Systems Documentation

HP Fortran for OpenVMS
Language Reference Manual

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:

• In general, any quantity of interest in a given situation; often used in place of the term "argument."
• A Fortran 95/90 named constant.

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:

• Fortran 95/90 pointer
  A data object that has the POINTER attribute. A Fortran 95/90 pointer does not contain data, but points to a scalar or array variable where data is stored. To be referenced or defined, it must be "pointer-associated" with a target (have storage space associated with it). If the pointer is an array, it must be pointer-associated to have a shape. See also pointer association.
• HP Fortran pointer
  A data object that contains the address of its paired variable.

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:

• Constant
• Constant subobject (parent is a constant)
• Variable (scalar, structure, array, or pointer; an array cannot be assumed size)
• Array constructor
• Structure constructor
• Function reference
• Expression in parentheses

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:

• A set of logically related data items (in a file) that is treated as a unit; such a record contains one or more fields. This definition applies to I/O records and items that are declared in a record structure.
• One or more data items that are grouped in a structure declaration and specified in a RECORD statement.

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:

• For a data object, the appearance of its name, designator, or associated pointer where the value of the object is required. When an object is referenced, it must be defined.
• For a procedure, the appearance of its name, operator symbol, or assignment symbol that causes the procedure to be executed. Procedure reference is also called "calling" or "invoking" a procedure.
• For a module, the appearance of its name in a USE statement.

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:

• A program unit or subprogram
• A derived-type definition
• A procedure interface body

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:

• Part of a data object (an array element or section, a substring, a derived type, or a structure component)
• The set of values for which a CASE block is executed

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:

• A scalar data object of derived (user-defined) type.
• An aggregate entity containing one or more fields or components.

structure component: Can be either of the following:

• One of the components of a structure.
• An array whose elements are components of the elements of an array of derived type.

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.