HP Fortran for OpenVMS
Language Reference Manual

child process: A process initiated by another process (the parent). The child process can operate independently from the parent process. See also parent process.

comment: Text that documents or explains a program. In free source form, a comment begins with an exclamation point (!), unless it appears in a Hollerith or character constant.

In fixed and tab source form, a comment begins with a letter C or an asterisk (*) in column 1. A comment can also begin with an exclamation point anywhere in a source line (except in a Hollerith or character constant) or in column 6 of a fixed-format line. The comment extends from the exclamation point to the end of the line.

The compiler does not process comments, but shows them in program listings. See also compiler directive.

common block: A physical storage area shared by one or more program units. This storage area is defined by a COMMON statement. If the common block is given a name, it is a named common block; if it is not given a name, it is a blank common. See also blank common and named common block.

compilation unit: The source file or files that are compiled together to form a single object file, possibly using interprocedural optimization across source files. Only one f90 command is used for each compilation, but one f90 command can specify that multiple compilation units be used.

compiler directive: A structured comment that tells the compiler to perform certain tasks when it compiles a source program unit.

complex constant: A constant that is a pair of real or integer constants representing a complex number; the pair is separated by a comma and enclosed in parentheses. The first constant represents the real part of the number; the second constant represents the imaginary part. The following types of complex constants are available on all systems: COMPLEX (COMPLEX(4)) and DOUBLE COMPLEX (COMPLEX(8)). COMPLEX(16) is also available.

complex type: A data type that represents the values of complex numbers. The value is expressed as a complex constant. See also data type.

component: Part of a derived-type definition. There must be at least one component (intrinsic or derived type) in every derived-type definition.

concatenate: The combination of two items into one by placing one of the items after the other. In Fortran 95/90, the concatenation operator (//) is used to combine character items. See also character expression.

conformable: Pertains to dimensionality. Two arrays are conformable if they have the same shape. A scalar is conformable with any array.

conformance: See shape conformance.

conservative automatic inlining: The inline expansion of small procedures, with conservative heuristics to limit extra code.

constant: A data object whose value does not change during the execution of a program; the value is defined at the time of compilation. A constant can be named (using the PARAMETER attribute or statement) or unnamed. An unnamed constant is called a literal constant. The value of a constant can be numeric or logical, or it can be a character string. Contrast with variable.

constant expression: An expression whose value does not change during program execution.

construct: A series of statements starting with a DO, CASE, IF, WHERE, or FORALL statement and ending with a corresponding terminal statement.

contiguous: Pertaining to entities that are adjacent (next to one another) without intervening blanks (spaces); for example, contiguous characters or contiguous areas of storage.

control edit descriptor: A format descriptor that directly displays text or affects the conversions performed by subsequent data edit descriptors. Except for the slash descriptor, control edit descriptors are nonrepeatable.

control statement: A statement that alters the normal order of execution by transferring control to another part of a program unit or a subprogram. A control statement can be conditional (such as the IF construct or computed GO TO statement) or unconditional (such as the STOP or GO TO statement).

data abstraction: A style of programming in which you define types to represent objects in your program, define a set of operations for objects of each type, and restrict the operations to only this set, making the types abstract. The Fortran 95/90 modules, derived types, and defined operators, support this programming paradigm.

data edit descriptor: A repeatable format descriptor that causes the transfer or conversion of data to or from its internal representation. In FORTRAN 77, this term was called a field descriptor.

data entity: A data object that has a data type. It is the result of the evaluation of an expression, or the result of the execution of a function reference (the function result).

data item: A unit of data (or value) to be processed. Includes constants, variables, arrays, character substrings, or records.

data object: A constant, variable, or subobject of a constant.

data type: The properties and internal representation that characterize data and functions. Each intrinsic and user-defined data type has a name, a set of operators, a set of values, and a way to show these values in a program. The basic intrinsic data types are integer, real, complex, logical, and character. The data value of an intrinsic data type depends on the value of the type parameter. See also type parameter.

data type declaration: See type declaration statement.

data type length specifier: The form *n appended to HP Fortran-specific data type names. For example, in REAL*4, the *4 is the data type length specifier.

declaration: See specification statement.

default character: The kind for character constants if no kind parameter is specified. Currently, the only kind parameter for character constants is CHARACTER(1), the default character kind.

default complex: The kind for complex constants if no kind parameter is specified. The default complex kind is affected by compiler options that specify real size. If no compiler option is specified, default complex is COMPLEX(4) (COMPLEX*8). See also default real.

default integer: The kind for integer constants if no kind parameter is specified. The default integer kind is affected by compiler options that specify integer size. If no compiler option is specified, default integer is INTEGER(4) (INTEGER*4).

If a compiler option affecting integer size has been specified, the integer has the kind specified, unless it is outside the range of the kind specified by the option. In this case, the kind of the integer is the smallest integer kind which can hold the integer.

default logical: The kind for logical constants if no kind parameter is specified. The default logical kind is affected by compiler options that specify integer size. If no compiler option is specified, default logical is LOGICAL(4) (LOGICAL*4). See also default integer.

default real: The kind for real constants if no kind parameter is specified. The default real kind is determined by the compiler option specifying real size. If no compiler option is specified, default real is REAL(4) (REAL*4).

If a real constant is encountered that is outside the range for the default, an error occurs.

deferred-shape array: An array pointer (an array with the POINTER attribute) or an allocatable array (an array with the ALLOCATABLE attribute). The size in each dimension is determined by pointer assignment or when the array is allocated.

The declared bounds are specified by a colon (:).

definable: A property of variables. A variable is definable if its value can be changed by the appearance of its name or designator on the left of an assignment statement. An example of a variable that is not definable is an allocatable array that has not been allocated.

defined: For a data object, the property of having or being given a valid value.

defined assignment: An assignment statement that is not intrinsic, but is defined by a subroutine and an interface block. See also derived type.

defined operation: An operation that is not intrinsic, but is defined by a function subprogram containing a generic interface block with the specifier OPERATOR. See also interface block.

denormalized number: A computational floating-point result smaller than the lowest value in the normal range of a data type (the smallest representable normalized number). You cannot write a constant for a denormalized number.

derived type: A data type that is user-defined and not intrinsic. It requires a type definition to name the type and specify its components (which can be intrinsic or user-defined types). A structure constructor can be used to specify a value of derived type. A component of a structure is referenced using a percent sign (%).

Operations on objects of derived types (structures) must be defined by a function with an OPERATOR interface. Assignment for derived types can be defined intrinsically, or be redefined by a subroutine with an ASSIGNMENT interface. Structures can be used as procedure arguments and function results, and can appear in input and output lists. Also called a user-defined type. See also record, the first definition.

designator: A name that references a subobject (part of an object). A designator is the name of the object followed by a selector that selects the subobject. For example, B(3) is a designator for an array element. Also called a subobject designator. See also selector and subobject.

dimension: A range of values for one subscript or index of an array. An array can have from 1 to 7 dimensions. The number of dimensions is the rank of the array.

dimension bounds: See bounds.

direct access: A method for retrieving or storing data in which the data (record) is identified by the record number, or the position of the record in the file. The record is accessed directly (nonsequentially); therefore, all information is equally accessible. Also called random access. Contrast with sequential access.

double-precision constant: A processor approximation to the value of a real number that occupies 8 bytes of memory and can assume a positive, negative, or zero value. The precision is greater than a constant of real (single-precision) type. For the precise ranges of the double-precision constants, see the HP Fortran for OpenVMS User Manual. See also denormalized number.

dummy aliasing: The sharing of memory locations between dummy (formal) arguments and other dummy arguments or COMMON variables that are assigned.

dummy argument: A variable whose name appears in the parenthesized list following the procedure name in a FUNCTION statement, a SUBROUTINE statement, an ENTRY statement, or a statement function statement. A dummy argument takes the value of the corresponding actual argument in the calling program unit (through argument association). Also called a formal argument.

dummy procedure: Is a dummy argument that is specified as a procedure or appears in a procedure reference. The corresponding actual argument must be a procedure.

edit descriptor: A descriptor in a format specification. It can be a data edit descriptor, control edit descriptor, or string edit descriptor. See also control edit descriptor, data edit descriptor, and string edit descriptor.

element: See array element.

elemental: Pertains to an intrinsic operation, intrinsic procedure, or assignment statement that is independently applied to either of the following:

• The elements of an array
• Corresponding elements of a set of conformable arrays and scalars

end-of-file: The condition that exists when all records in a file open for sequential access have been read.

entity: A general term referring to any Fortran 95/90 concept; for example, a constant, a variable, a program unit, a statement label, a common block, a construct, an I/O unit and so forth.

environment variable: A symbolic variable that represents some element of the operating system, such as logical names or a filename, or other literal data.

error number: An integer value denoting an I/O error condition, obtained by using the IOSTAT specifier in an I/O statement.

exceptional values: For floating-point numbers, values outside the range of normalized numbers, including denormal (subnormal) numbers, infinity, Not-a-Number (NaN) values, zero, and other architecture-defined numbers.

executable construct: A CASE, DO, IF, WHERE, or FORALL construct.

executable program: A set of program units that include only one main program.

executable statement: A statement that specifies an action to be performed or controls one or more computational instructions.

explicit interface: A procedure interface whose properties are known within the scope of the calling program, and do not have to be assumed. These properties are the names of the procedure and its dummy arguments, the attributes of a procedure (if it is a function), and the attributes and order of the dummy arguments.

The following have explicit interfaces:

• Internal and module procedures (explicit by definition)
• Intrinsic procedures
• External procedures that have an interface block
• External procedures that are defined by the scoping unit and are recursive
• Dummy procedures that have an interface block

explicit-shape array: An array whose rank and bounds are specified when the array is declared.

expression: Is either a data reference or a computation, and is formed from operands, operands, and parentheses. The result of an expression is either a scalar value or an array of scalar values.

extension: See language extension.

extent: The size of (number of elements in) one dimension of an array.

external file: A sequence of records that exists in a medium external to the executing program.

external procedure: A procedure that is contained in an external subprogram. External procedures can be used to share information (such as source files, common blocks, and public data in modules) and can be used independently of other procedures and program units. Also called an external routine.

external subprogram: A subroutine or function that is not contained in a main program, module, or other subprogram. A module is not a subprogram.

field: Can be either of the following:

• A set of contiguous characters, considered as a single item, in a record or line.
• A substructure of a STRUCTURE declaration.

field descriptor: See data edit descriptor.

field separator: The comma (,) or slash (/) that separates edit descriptors in a format specification.

field width: The total number of characters in the field. See also field, the first definition.

file: A collection of logically related records. If the file is in internal storage, it is an internal file; if the file is on an input/output device, it is an external file.

file access: The way records are accessed (and stored) in a file. The Fortran 95/90 file access modes are sequential and direct. You can also use a keyed mode of access.

file organization: The way records in a file are physically arranged on a storage device. Fortran 95/90 files can have sequential or relative organization. Files can also have indexed organization.

fixed-length record type: A file format in which all the records are the same length.

foreign file: An unformatted file that contains data from a foreign platform, such as data from a CRAY, IBM, or big endian IEEE machine.

format: A specific arrangement of data. A FORMAT statement specifies how data is to be read or written.

format specification: The part of a FORMAT statement that specifies explicit data arrangement. It is a list within parentheses that can include edit descriptors and field separators. A character expression can also specify format; the expression must evaluate to a valid format specification.

formatted data: Data written to a file by using formatted I/O statements. Such data contains ASCII representations of binary values.

formatted I/O statement: An I/O statement specifying a format for data transfer. The format specified can be explicit (specified in a format specification) or implicit (specified using list-directed or namelist formatting). Contrast with unformatted I/O statement. See also list-directed I/O statement and namelist I/O statement.

full pathname: See absolute pathname.

function: A series of statements that perform some operation and return a single value (through the function or result name) to the calling program unit. A function is invoked by a function reference in a main program unit or a subprogram unit.

In Fortran 95/90, a function can be used to define a new operator or extend the meaning of an intrinsic operator symbol. The function is invoked by the appearance of the new or extended operator in the expression (along with the appropriate operands). For example, the symbol * can be defined for logical operands, extending its intrinsic definition for numeric operands. See also function subprogram, statement function, and subroutine.

function reference: Used in an expression to invoke a function, it consists of the function name and its actual arguments. A function reference returns a value (through the function or result name) which is used to evaluate the calling expression.

function result: The result value associated with a particular execution or call to a function. This result can be of any data type (including derived type) and can be array-valued. In a FUNCTION statement, the RESULT option can be used to give the result a name different from the function name. This option is required for a recursive function that directly calls itself.

function subprogram: A sequence of statements beginning with a FUNCTION (or optional OPTIONS) statement that is not in an interface block and ending with the corresponding END statement. See also function.

generic identifier: A generic name, operator, or assignment specified in an INTERFACE statement that is associated with all of the procedures within the interface block. Also called a generic specification.

global entity: An entity (a program unit, common block, or external procedure) that can be used with the same meaning throughout the executable program. A global entity has global scope; it is accessible throughout an executable program. See also local entity.

global section: A data structure (for example, global COMMON) or shareable image section potentially available to all processes in the system.

global symbol: A name defined in a source file, object file, or image file, that is available for reference by another source file.

handle: A value (often, but not always, a 32-bit integer) that identifies some operating system resource, for example, a window or a process. The handle value is returned from an operating system call when the resource is created; your program then passes that value as an argument to subsequent operating system routines to identify which resource is being accessed.

Your program should consider the handle value a "private" type and not try to interpret it as having any specific meaning (for example, an address).

hexadecimal constant: A constant that is a string of hexadecimal (base 16) digits (range 0 to 9, or an uppercase or lowercase letter in the range A to F) enclosed by apostrophes or quotation marks and preceded by the letter Z.

Hollerith constant: A constant that is a string of printable ASCII characters preceded by nH, where n is the number of characters in the string (including blanks and tabs).

host: Either the main program or subprogram that contains an internal procedure, or the module that contains a module procedure. The data environment of the host is available to the (internal or module) procedure.

host association: The process by which a module procedure, internal procedure, or derived-type definition accesses the entities of its host.

implicit interface: A procedure interface whose properties (the collection of names, attributes, and arguments of the procedure) are not known within the scope of the calling program, and have to be assumed. The information is assumed by the calling program from the properties of the procedure name and actual arguments in the procedure call.

implicit typing: The mechanism by which the data type for a variable is determined by the beginning letter of the variable name.

index: Can be any of the following:

• The variable used as a loop counter in a DO statement.
• An intrinsic function specifying the starting position of a substring inside a string.
• An internal data structure that provides a guide, based on key values, to file components in an indexed file.

indexed file organization: A file organization that allows random retrieval of records by key value and sequential retrieval of records within the key of reference. Each file contains records and a primary key index; it can also optionally have one or more alternate key indexes.

initialization expression: A form of constant expression that is used to specify an initial value for an entity.

initialize: The assignment of an initial value to a variable.

inlining: An optimization that replaces a subprogram reference (CALL statement or function invocation) with the replicated code of the subprogram.

input/output (I/O): The data that a program reads or writes. Also, devices to read and write data.

inquiry function: An intrinsic function whose result depends on properties of the principal argument, not the value of the argument.

integer constant: A constant that is a whole number with no decimal point. It can have a leading sign and is interpreted as a decimal number.

intent: An attribute of a dummy argument that is not a pointer or procedure. It indicates whether the argument is used to transfer data into the procedure, out of the procedure, or both.

interactive process: A process that must periodically get user input to do its work. Contrast with background process or batch process.

interface block: The sequence of statements starting with an INTERFACE statement and ending with the corresponding END INTERFACE statement.

interface body: The sequence of statements in an interface block starting with a FUNCTION or SUBROUTINE statement and ending with the corresponding END statement. Also called a procedure interface body.

internal file: The designated internal storage space (or variable buffer) that is manipulated during input and output. An internal file can be a character variable, character array, character array element, or character substring. In general, an internal file contains one record. However, an internal file that is a character array has one record for each array element.

internal procedure: A procedure (other than a statement function) that is contained within an internal subprogram. The program unit containing an internal procedure is called the host of the internal procedure. The internal procedure (which appears between a CONTAINS and END statement) is local to its host and inherits the host's environment through host association.

internal subprogram: A subprogram contained in a main program or another subprogram.

intrinsic: Describes entities defined by the Fortran 95/90 language (such as data types and procedures). Intrinsic entities can be used freely in any scoping unit.

intrinsic procedure: A subprogram supplied as part of the Fortran 95/90 library that performs array, mathematical, numeric, character, bit manipulation, and other miscellaneous functions. Intrinsic procedures are automatically available to any Fortran 95/90 program unit (unless specifically overridden by an EXTERNAL statement or a procedure interface block). Also called a built-in or library procedure.

invoke: To call upon; used especially with reference to subprograms. For example, to invoke a function is to execute the function.

I/O: See input/output.

iteration count: The number of executions of the DO range, which is determined as follows:

[(terminal value - initial value + increment value) / increment value]

key: A value in a file of indexed organization that the system uses to build indexes into the file. Each key is identified by its location within the component, its length, and its data type. Also called the key field. See also alternate key, index, and primary key.

keyed access: A method for retrieving or writing data in which the data (a record) is identified by specifying the information in a key field of the record. See also key.

key of reference: A key used to determine the index to use when sequentially accessing components of an indexed file. See also key, indexed file organization, and sequential access.

kind type parameter: Indicates the range of an intrinsic data type. For real and complex types, it also indicates precision. If a specific kind parameter is not specified (for example, INTEGER), the kind is the default for that type (for example, default integer). See also default character, default complex, default integer, default logical, and default real.