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. See also dummy argument.

A dummy argument that is an array having at least one nonconstant dimension.

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.

A library of routines that can be linked to an executable program at link-time. See also shared library.

(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. See also bounds and dimension.

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.

The order in arrays are laid out in memory. The array element order for HP Fortran 90 arrays is column-major order. Array element order can also be used to determine sequence association.

An array that has the POINTER attribute and may therefore be used to point to a target object.

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. For example, an array-valued function has a return value that is an array.

The mechanism by which two or more names may refer to the same entity. See also argument association, host association, pointer association, sequence association, storage association, and use association.

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 (:). See also assumed-size array.

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 (*). See also assumed-shape array.

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. Fortran 90 supports automatic arrays and automatic character string variables.

A binary digit, either 1 or 0. See also byte.

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 program unit begins with a BLOCK DATA statement.

The minimum and maximum values permitted as a subscript of an array for each dimension. For each dimension, there are two bounds—the upper and lower bounds—that define the range of values for subscripts.

A literal constant that can be formatted as binary, octal, or hexadecimal. See also typeless constant.

%REF and %VAL—HP extensions that can be used to change argument-passing rules in procedure references.

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. See Appendix B, “Character set”.

A sequence of zero or more consecutive characters.

The default storage method for arrays in HP Fortran 90. Memory representation of an array is such that the columns are stored contiguously. For example, given the array a(2,3), element a(1,1) would be stored in the first location, element a(2,1)in the second location, element a(1,2)in the third location, and so on. See also row-major order.

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 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.

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. See also derived type.

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

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.

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.

See compiler directive.

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.

A dummy argument that is an explicit-shape array.

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.

See array element.

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.

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 is any of the following:

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. See also constant expression, initialization expression, and specification expression.

See defined operator.

The number of elements in one dimension of an array.

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

The name of an object referenced by a program unit, as it appears to the linker. Case is not significant in the names that appear in Fortran source files; but it is significant in external names.

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).

See also external file and internal file.

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.

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.

A more restricted form of constant expression that is used to initialize data.

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.

A Fortran 90 feature that allows an actual argument to appear anywhere in the argument list to a procedure reference.

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. See also linker.

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. See also named constant.

See bounds.

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

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. See also literal constant.

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 sequence of one or more characters in an expression that specifies an operation. For example, in a + b, + is an operator.

See compile-line option.

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:

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. A program is executable after successful compilation and linking.

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.

A feature of the USE statement that allows module entities to be renamed within the program unit having access to the entities by use association.

See function result.

The default storage method for arrays in C. Memory representation is such that the rows of an array are stored contiguously. For example, given the array a[3][2], the element a[0][0] would be stored in the first location, element a[0][1] in the second location, element a[1][0] in the third location, and so on. See also column-major order.

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

The part of a 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).

The association between dummy argument and actual argument that occurs when the two differ in rank or character length. Dummy and actual arguments are matched element by element or character by character, starting with the first and proceeding in order. See also array element order and column-major order.

A derived type whose definition includes the SEQUENCE statement. The components of a sequence derived type are in the storage sequence as specified in the definition of the derived type.

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

A library of routines that can be linked to an executable program at runtime, allowing the shared library to be used by several programs simultaneously. See also archive library.

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. See also generic procedure.

A limited form of an expression that can appear in a specification statement—for example, a type declaration statement—and can be evaluated on entry to a procedure.

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 function that returns a scalar value and is defined by a single scalar expression.

See label.

The association of different Fortran objects with the same storage. Storage association is achieved by means of common blocks and equivalencing.

The order in which Fortran objects are laid out in memory. Programmers can control storage sequence by means of common blocks and equivalencing, and by defining sequence derived types. The storage sequence of arrays is determined by array element order.

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.

See component.

See procedure.

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.

See data type.

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

A literal constant that is formatted to represent a bit pattern and therefore does not imply the type of the constant. BOZ constants and Hollerith constants are both typeless.

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

See bounds.

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

See defined assignment.

See defined operator.

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 reference—for example, in a type declaration statement—that consists of the array name alone, without the subscript notation. Whole array operations affect every element in the array, not just a single, subscripted element.

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.