Glossary

A value, variable, or procedure that is passed by a call to a procedure (function or subroutine). The actual argument appears in the source of the calling procedure.

A named array with the ALLOCATABLE attribute whose rank is specified at compile time, but whose bounds are determined at run time. Storage for the array must be explicitly allocated before the array may be referenced.

(1) A variable, declared in the argument list of a procedure or ENTRY statement, that receives a value when the procedure is called (a dummy argument).

(2) The variable, expression, or procedure that is passed by a call to a procedure (an actual argument).

The correspondence between an actual argument and a dummy argument during execution of a procedure reference.

A dummy argument name. Argument keywords can be used to pass actual arguments to a procedure in any order if the procedure has an explicit interface.

A rectangular pattern of elements of the same data type. The properties of an array include its rank, shape, extent, and data type.

A rank-one array represented as a sequence of scalar or array values that may be constant or variable.

An individual, scalar component of an array that is specified by the array name and, in parenthesis, one or more subscripts that identify the element's position in the array.

A subset of an array specified by a subscript triplet or vector subscript in one or more dimensions. For an array a(4,4), a(2:4:2,2:4:2) is an array section containing only the evenly indexed elements a(2,2), a(4,2), a(2,4), and a(4,4).

Having the property of being an array.

An array that is a dummy argument to a procedure and whose shape is assumed (taken) from that of the associated actual argument. An assumed-shape array's upper bound in each dimension is represented by a colon (:).

An older FORTRAN 77 feature. An array that is a dummy argument to a procedure and whose size (but not necessarily its shape) is assumed (taken) from that of the associated actual argument. The upper bound of an assumed-size array's last dimension is specified by an asterisk (*).

A property of a constant or variable that may be specified in a type declaration statement. Most attributes may alternately be specified in a separate statement. For instance, the ALLOCATABLE statement has the same meaning as the ALLOCATABLE attribute, which appears in a type declaration statement.

An explicit-shape array that is local to a procedure and is not a dummy argument. One or more of an automatic array's bounds is determined upon entry to the procedure, allowing automatic arrays to have a different size and shape each time the procedure is invoked.

A data object declared in a subprogram whose storage space is dynamically allocated when the subprogram is invoked; its storage is released on return from the subprogram.

A binary digit, either 1 or 0.

A common block that is not associated with a name.

A series of consecutive statements that are treated as a complete unit and are within a SELECT CASE, DO, IF, or WHERE construct.

A procedure that establishes initial values for variables in named common blocks and contains no executable statements. A block data subprogram begins with a BLOCK DATA statement.

The minimum and maximum values permitted as a subscript of an array for each dimension.

A group of contiguous bits starting on an addressable boundary. In HP machines, a byte is 8 bits in length.

A digit, letter, or other symbol in the character set. For information about the HP character set, see Appendix B.

A sequence of zero or more consecutive characters.

The default storage method for arrays in Fortran 90.

Memory representation of an array is such that the columns are stored contiguously. For example, in the array a(3,4) element a(1,2) follows a(3,1), which follows a(2,1) in memory.

A block of memory for storing variables. A common block is a global entity that may be referenced by one or more program units.

A flag that can be specified with the f90 command line to override the default actions of the HP Fortran 90 compiler.

A specially-formatted comment within a source program that affects how the program is compiled. Compiler directives are not part of the Fortran 90 Standard. In HP Fortran 90, compiler directives provide control over source listing, optimization, and other features.

An executable program that is created using only archive libraries and thus contains its own copy of the library routines referenced in the program.

A constituent that is part of a derived type. A derived type may consist of one or more components. For example, time%hour refers to the hour component of time (and time is a variable whose data type is a derived type defined in the program).

Two arrays are conformable if both arrays have the same rank (number of dimensions) and the same extent (number of elements for each dimension). A scalar is conformable with any array.

(1) A unit is connected if it refers to an external file.

(2) An external file is connected if a unit refers to it.

In both cases, connection is established either by the OPEN statement or by preconnection. See also preconnected.

A data object that retains the same value during a program's execution. A constant's value is established when a program is compiled. A constant is either a literal constant or a named constant.

An expression whose value does not vary during the program's execution. A constant expression's operands are all constants.

A series of statements that begins with a SELECT CASE, DO, IF, or WHERE statement and ends with a corresponding END SELECT, END DO, END IF, or ENDWHERE statement.

A named category of data that has a set of values, a way to denote its values, and a set of operations for interpreting and manipulating the values. Fortran 90 intrinsic data types include character, complex, double precision, integer, logical, and real. HP Fortran 90 also provides the byte and double complex data types as extensions.

An allocatable array or a pointer array (an array with the ALLOCATABLE or POINTER attribute).

A variable is definable if its value may be changed by its name or designator appearing in an assignment context (for example, in a READ statement or on the left-hand side of an assignment statement).

A non-intrinsic assignment statement that is defined by an ASSIGNMENT(=) interface block and a subroutine.

An operator that is present in an INTERFACE statement and has its operation implemented by one or more user-defined functions.

A process is demand-loadable if its pages are brought into physical memory only when they are accessed.

A user-defined (non-intrinsic) data type that consists of one or more components. Each component of a derived type is either an intrinsic data type or another derived type.

A name that references a part of a data object that can be defined and referenced separately from other parts of the data object. A designator may be a derived type component, array section, array element, substring, or actual argument with INTENT(INOUT) or INTENT(OUT).

Each subscript of an array corresponds to a dimension of the array; arrays may have from one to seven dimensions. The number of dimensions is an array's rank. See also extent.

A pointer that is disassociated points to no target. A pointer becomes disassociated following a DEALLOCATE or NULLIFY statement involving the pointer or by the pointer being associated with (pointing to) a disassociated pointer.

An entity whose name appears in the argument list of a procedure or ENTRY statement. It is associated with an actual argument when the procedure is called. The dummy argument appears in the source of the called procedure.

An older, pre-FORTRAN 77 program. Presumably called a "dusty deck" program because it was stored on punched cards and has not been changed since. Such programs generally rely on nonstructured programming techniques such as the GOTO statement.

To be elemental, an intrinsic operation, procedure, or assignment must apply independently to every element of an array or apply independently to the corresponding elements of a set of conformable arrays and scalars.

The process of sharing storage units among two or more data objects by means of the EQUIVALENCE statement.

A set of program units, including one main program, that can be run as a self-contained program.

An instruction that causes the program to perform one or more computational or branching actions.

A procedure interface whose properties (including the name and attributes of the procedure and the order and attributes of its arguments) are known by the calling program unit. A procedure may have an explicit interface in a scoping unit if it:

An array with explicitly-declared bounds for each dimension.

A series of operands and (optionally) operators and parentheses that forms either a data reference or a computation.

The number of elements in one dimension of an array.

A file that is stored on a medium external to the executing program.

A procedure that is not contained in a main program, module, or another subprogram.

A sequence of records (characters or values processed as a unit).

A procedure that returns a value (the function result) and that can be referenced in an expression.

The data object returned from a call to a function.

A procedure in which at least one actual argument may have more than one data type. Generic procedures may be intrinsic or user-defined.

1073741824 bytes (2³⁰ bytes). See also byte.

A program unit, common block, or external procedure whose scope is the entire executable program.

An extension to the Fortran 90 Standard that provides user-directed data distribution and alignment. HPF is not a standard, but rather a set of features desirable for parallel programming.

A program unit or subprogram that contains an internal procedure or module.

The process by which an internal procedure, module procedure, or derived type definition accesses the entities of its host.

An executable program that is created using at least one shared library. Copies of shared library routines are not present in an incomplete executable; instead, the executable has a linkage table that lists the routines' addresses in the shared library.

An intrinsic function whose return value provides information based on the principal arguments' properties and not the arguments' values.

An attribute of a dummy argument that indicates whether the argument is used for transferring data into the procedure, out of the procedure, or both.

A variable that is used as a file storage medium for formatted I/O. Internal files are stored in memory and typically are used to convert data from a machine representation to a character representation by use of edit descriptors.

A procedure contained in a main program or another subprogram.

Assignment statements, data types, operations, and procedures are intrinsic if they are defined in the Fortran 90 Standard and may be used, without being defined, in any scoping unit.

1024 bytes (2¹⁰ bytes).

An integer parameter whose value determines the range for an intrinsic data type; for example INTEGER(KIND=2). The kind type parameter also determines the precision for complex and real data types.

An integer, one to five digits long, that precedes a statement and identifies it with a unique number. A statement's label provides a way to transfer control to the statement or to reference it as a FORMAT statement.

A file that contains object code for subroutines and data that can be used by programs written in Fortran 90, among other languages.

The ld utility. The linker resolves references in a program's source to routines that are not in the source file being compiled. The linker matches each reference, if possible, to the corresponding library routine.

A constant that does not have a name. A literal constant's value is written directly into a program.

The first program unit that starts executing when a program is run. The first statement of a main program usually is the PROGRAM statement.

1048576 bytes (2²⁰ bytes).

A program unit that contains definitions of derived types, procedures, namelists, and variables that are made accessible to other program units. A module begins with the MODULE statement and its public definitions are made available to other program units by means of the USE statement.

A procedure that is contained in a module and is not an internal procedure.

A letter followed by up to 254 alphanumeric characters (letters, digits, underscores, and $) that identifies an entity in an HP Fortran 90 program unit, such as a common block, dummy argument, procedure, program unit, or variable.

A constant that has a name.

A complex, double precision, integer, or real data type.

A feature defined in the FORTRAN 77 Standard that still is in common use but is considered to be redundant, such as the arithmetic IF statement.

The use of obsolescent features is discouraged. The Fortran 90 Standard summarizes the obsolescent features.

An expression that precedes or follows an operator. For example, in a + b, both a and b are operands.

A computation performed on one or two operands.

A sequence of one or more characters in an expression that specifies an operation. For example, in a + b, + is an operator.

A dummy argument that does not require a corresponding actual argument to be supplied when its procedure is invoked.

A variable that has the POINTER attribute, which enables it to reference (point to) variables of a specified data type (rather than storing the data itself).

The process by which a pointer becomes associated with the storage space of its target. Pointer association occurs during pointer assignment or a valid ALLOCATE statement.

Three input/output units are preconnected to files by the operating system and need not be connected by the OPEN statement. The preconnected units are:

An optional dummy argument is present in an instance of a procedure if it is associated with an actual argument passed by the invoking procedure.

A unit of program code that may be invoked. A procedure can be either a function or a subroutine.

A sequence of instructions for execution by a computer to perform a specific task. See also executable program.

A main program, a module, an external procedure, or a block data subprogram.

The number of dimensions of an array. Scalars have a rank of zero.

A sequence of values treated as a whole within a file.

The default storage method for arrays in C. Memory representation is such that the rows of an array are stored contiguously. For example, for the array a[3][4], the element a[1][0] immediately follows a[0][3].

A data item that has a rank of zero and therefore is not an array.

The part of an executable program in which a name or declaration has a single interpretation.

A derived-type definition, an interface body (excluding derived-type definitions or interface bodies it contains), or a program unit or subprogram (excluding any derived-type definitions, interface bodies, or subprograms it contains).

An array's extent (number of elements) in each dimension and rank (number of dimensions).

The total number of elements in an array; the product of all its extents.

A procedure for which each actual argument must be of a specific data type.

A sequence of characters that represents an instruction or step in a program. A single statement usually, but not always, occupies one line of a program.

A statement may consist of multiple lines by using the ampersand (&) continuation character. Similarly, multiple statements may appear on a single line separated by semicolons (;).

A function that returns a scalar value and is defined by a single scalar expression.

A word that is part of a statement's syntax, such as CHARACTER, DO, ELSE, or FORMAT.

The increment that may optionally be specified in a subscript triplet. If it is not specified, the stride has a value of one.

A data object that is scalar and is of derived type.

A procedure that is referenced by a CALL statement; values returned by a subroutine are usually provided through the subroutine's arguments.

A scalar value within the bounds of one dimension of an array. To specify a single array element, a subscript must be specified for each of the array's dimensions.

An array section specification that consists of a starting element, an ending element, and (optionally) a stride separated by colons (:).

A contiguous segment of a scalar character string. Note that a substring is not an array section.

A named data object that may be associated with a pointer. A target is specified in a TARGET statement or in a type declaration statement that has the TARGET attribute.

1099511627776 bytes (2⁴⁰ bytes).

A statement that specifies the data type and, optionally, attributes for one or more constants, functions, or variables.

A logical number that can be connected to a file to provide a means for referring to the file in input/output statements.

The association of names among different scoping units as specified by a USE statement.

A data object whose value may be defined and redefined during a program's execution. For example, array elements or array sections, named data objects, structure components, and substrings all can be variables.

A method of referencing multiple, possibly discontinuous elements of an array by using a rank-one array of integer values as a subscript.

An array with at least one dimension that has at least one extent of zero. A zero-sized array has a size of zero and contains no elements.