NAG Fortran Compiler, Release 7.2: Fortran 95 Statements

Navigation: Previous Up Next

8.3 Fortran 95 Statements

This section contains a quick reference guide to the statements in Fortran 95.

Syntax element definition is represented by ‘::=’.
Names in italics (e.g., ‘expr’) are syntax element names.
Items in ‘[ ]’ are optional.
Ellipsis ‘...’ indicates optional repetition of the preceding item.
‘{’ and ‘}’ are for grouping only.
Items separated by ‘|’ are a “one-of-many” selection.

Type Specification

The following syntax is used by several declaration statements.

type-spec ::=	numeric-type [ kind-specifier ] \|
	numeric-type `` digit-string* \|
	`DOUBLE PRECISION` \|
	`CHARACTER` [ char-specifier ]

numeric-type ::= COMPLEX | INTEGER | LOGICAL | REAL

kind-specifier ::= ( [ KIND = ] expr )

char-specifier ::=	`` digit-string* \|
	`* (` char-length `)` \|
	`(` char-length [ `,` [ `KIND =` ] expr ] `)` \|
	`(` `LEN =` char-length [ `, KIND =` expr ] `)` \|
	`(` `KIND =` expr [ `, LEN =` char-length ] `)`

char-length ::= * | expr

Labels and Construct Names

label ::= digit-string

Note that the digit-string in a label must contain at most 5 digits, and at least one of them must be non-zero. Leading zeroes are not significant, but do count towards the limit of 5.

Although it is not shown in the syntax definitions, all statements may be labelled and the FORMAT statement must be labelled.

construct-name ::= name

Construct names are “class 1” names, and must not be the same as any other class 1 name in a subprogram; class 1 names includes variables, procedures, program unit names, et cetera.

Entity Declaration List

The following syntax is used by both Component Declaration and Type Declaration statements.

entity-decl-list ::= entity-decl [ , entity-decl ] ...

entity-decl ::= name [ * char-length ] [ array-spec ] [ initial-value ]

array-spec ::= explicit-shape | assumed-shape | deferred-shape | assumed-size

explicit-shape ::= ( explicit-bound [ , explicit-bound ] ... )

explicit-bound ::= [ expr : ] expr

assumed-shape ::= ( assumed-bound [ , assumed-bound ] ... )

assumed-bound ::= [ expr ] :

deferred-shape ::= ( deferred-bound [ , deferred-bound ] ... )

deferred-bound ::= :

assumed-size ::= ( [ explicit-bound , ]... assumed-size-bound )

assumed-size-bound ::= [ expr : ] *

initial-value ::= = expression | => NULL()

Allocatable Statement

ALLOCATABLE [ :: ] name [ deferred-shape ] [ , name [ deferred-shape ] ] ...

Declares the listed entities to be allocatable arrays. If array bounds are present, they must be deferred.

Allocate Statement

ALLOCATE ( allocate-item [ , allocate-item ] ... [ , STAT = variable ] )

allocate-item ::= variable [ explicit-shape ]

Allocates a pointer or allocatable array. If the allocation fails and the STAT= clause is present, the STAT= variable will be assigned a non-zero value.

Arithmetic If Statement (obsolescent)

IF ( expr ) label , label , label

Branches to one of three labels depending on whether expr is negative, zero or positive respectively. The expression must be scalar and of type integer or real.

Assignment Statement

variable = expr

The expression is evaluated and assigned to the variable. For intrinsic assignment, it must be assignment-compatible with the variable, that is:

If the variable is scalar, the expression must be scalar. If the variable is an array, the expression may be scalar or an array of the same shape.
If the variable is of type LOGICAL, the expression must be LOGICAL but may be any KIND.
If the variable is of type CHARACTER, the expression must be of type CHARACTER and of the same KIND.
If the variable is of type INTEGER, REAL or COMPLEX, the expression must be of type INTEGER, REAL or COMPLEX.
If the variable is of derived type, the expression must be of that type.

For defined assignment, there must be a generic interface for ASSIGNMENT(=) which matches the types, kinds and ranks of the variable and expression; the user-specified assignment routine is called. Note that in the case of derived types, defined assignment is permitted to override the intrinsic assignment.

Backspace Statement

BACKSPACE expr

BACKSPACE ( position-spec-list )

position-spec-list ::= position-spec [ , position-spec ]

position-spec ::= { [ UNIT= ] expr } | { IOSTAT= variable } | { ERR= label }

Note: A position-spec-list is required to have a UNIT= position-spec; the UNIT= keyword and equals sign may be omitted only if it is the first in the list.

Positions the file connected to the specified unit to the record preceding the current one. An error condition is raised if the file is not connected, or the unit does not support backspacing.

The effect of each position-spec is as below:

UNIT=: Specifies the i/o unit; it must be a scalar integer expression identifying an external file.
ERR=: Transfers control to the specified label if an error condition occurs during the i/o statement.
IOSTAT=: Sets the variable to a positive number if an error occurs and to zero otherwise.

Block Data Statement

BLOCK DATA [ name ]

This is the first statement of a block data subprogram. All but one block data subprogram must be named.

Call Statement

CALL name [ ( [ actual-arg-list ] ) ]

actual-arg-list ::= actual-arg [ , actual-arg ]...

actual-arg ::= expr | * label

Calls the named subroutine.

Case Statement

CASE DEFAULT [ construct-name ]

CASE ( case-value-range [ , case-value-range ]... ) [ construct-name ]

case-value-range ::=	expr [ `:` [ expr ] ] \|
	`:` expr

Marks the beginning of a CASE part (and the end of any preceding CASE part). Statements in this part are executed if the corresponding SELECT expression value satisfies the appropriate CASE condition:

.EQ.: A case-value-range of the form (expr).
.LE.: A case-value-range of the form (:expr).
.GE.: A case-value-range of the form (expr:).
range: A case-value-range of the form (expr:expr) is satisfied for values greater than or equal to the first expression, and less than or equal to the second expression.
DEFAULT: The CASE DEFAULT clause is selected if the value does not satisfy any other CASE statements in that SELECT construct.

Note that within a SELECT construct, each CASE statement must have distinct conditions so that only one can be satisfied.

Close Statement

CLOSE expr

CLOSE ( position-spec-list )

(See the BACKSPACE statement for the position-spec-list definition.)

Closes the specified unit.

Common Statement

`COMMON`	[ / [ common-block-name ] / ] common-object-list
	[ [ `,` ] / [ common-block-name ] / common-object-list ]...

common-object-list ::= common-object [ , common-object ]...

common-object ::= name [ array-spec ]

Declares a common block. If no common-block-name is specified, “blank common” is the common block declared. Multiple COMMON statements for the same common block act as if the common-object-lists were concatenated in a single statement.

Component Definition Statement

type-spec [ [ , component-attribute-list ] :: ] entity-decl-list

component-attribute-list ::= component-attr [ , component-attr ]...

component-attr ::=	`DIMENSION` array-spec \|
	`POINTER`

Declares one or more components of a derived type. Any array-spec in a component definition must be deferred-shape if the POINTER attribute is present, and must be explicit-shape otherwise. Any initial-value that is present defines the default value for that component of any new entities of the type.

Computed Goto Statement (obsolescent)

GOTO ( label [ , label ] ... ) expr

The (integer scalar) expression is evaluated; if it is less than one or greater than the number of labels in the list, control is transferred to the next statement. Otherwise control is transferred to the corresponding label.

Contains Statement

CONTAINS

This statement separates the declarations of a module from its contained procedures, and the declarations and executables of a main program or procedure from its contained procedure.

Continue Statement

CONTINUE

This is an executable statement that has no effect. If it has a label it may be used as the terminating statement of a DO construct or as the target of a GOTO, computed-GOTO or assigned-GOTO.

Cycle Statement

CYCLE [ construct-name ]

Begins the next iteration of either the specified DO construct, or if construct-name is omitted, the innermost enclosing DO construct.

Data Statement

DATA data-set [ , data-set ]...

data-set ::= data-object-list / data-value-list /

data-object-list ::= data-object [ , data-object ]...

data-object ::= variable | data-implied-do

data-implied-do ::= ( data-object [ , data-object ]... do-spec )

data-value-list ::= data-value [ , data-value ]...

data-value ::= [ data-repeat * ] data-constant

data-repeat ::= constant | constant-subobject

data-constant ::=	literal-constant \| `NULL()` \| structure-constructor \| object \|
	{ `+` \| `-` } { real-literal \| integer-literal }

Declares the initial value of the specified objects. This implicitly declares those objects to have the SAVE attribute.

Deallocate Statement

DEALLOCATE ( expr [ , expr ] [ , STAT = variable ] )

Deallocates the storage occupied by an allocatable array or pointer. An error is raised if an allocatable array to be deallocated is not allocated, or if a pointer to be deallocated is dissociated or is associated with an object that was not allocated with ALLOCATE.

Dimension Statement

DIMENSION [ :: ] name array-spec [ , name array-spec ]...

Declares the name(s) to be arrays with the specified bounds.

Do Statement

[ construct-name : ] DO [ label ] [ , ] [ loop-control ]

loop-control ::=	do-spec \|
	`WHILE (` logical-expr `)`

do-spec ::= name = expr , expr [ , expr ]

The initial statement of a DO loop. If label is present, the loop ends on the statement with that label, which cannot be a GOTO, RETURN, STOP, EXIT, CYCLE, END or arithmetic IF statement. Nested DO loops can share the same ending statement, provided it is not an ENDDO statement. If the loop-control is missing, the DO loop terminates only if control is explicitly transferred outside the loop (e.g., by an EXIT, GOTO or RETURN statement).

If construct-name is present, the DO loop must end with an ENDDO statement identified with the same construct-name.

Else Statement

ELSE [ construct-name ]

Begins the ELSE part of an IF-THEN construct. Statements in this part are executed only if the IF condition is false and all ELSEIF conditions at the same level are false. If the IF-THEN statement had a construct-name, the ELSE statement may specify the same construct-name.

Elseif Statement

ELSE IF ( expr ) THEN [ construct-name ]

Begins a (new) ELSEIF part of an IF-THEN construct. Statements in this part are executed only if the IF condition is false, all preceding ELSEIF conditions at the same level are false, and this ELSEIF condition is true. If the IF-THEN statement had a construct-name, the ELSEIF statement may specify the same construct-name.

Elsewhere Statement

ELSEWHERE [ construct-name ]

Begins the ELSEWHERE part of a WHERE construct. The statements in this part are executed only for those elements for which the WHERE mask are false, and all ELSEWHERE masks at the same level are also false.

If the WHERE statement had a construct-name, the ELSEWHERE statement may specify the same construct-name.

Elsewhere Mask Statement

ELSEWHERE ( expr ) [ construct-name ]

Begins a masked ELSEWHERE part of a WHERE construct. The statements in this part are executed only for those elements for which the previous masks are false and this ELSEWHERE mask are true. (The previous masks are the WHERE mask and all preceding ELSEWHERE masks at the same level in this WHERE construct.) Note that the elements of the ELSEWHERE mask that do not correspond to false elements of the previous masks are not evaluated.

If the WHERE statement had a construct-name, the ELSEWHERE-mask statement may specify the same construct-name.

End Block Data Statement

END [ BLOCK DATA [ name ] ]

The last statement of a block data subprogram. If name is present, the BLOCK DATA statement at the beginning of the subprogram must have specified the same name.

Enddo Statement

END DO [ construct-name ]

Marks the end of a DO construct. The construct-name shall be present if and only if it were present on the DO statement, and must be the same construct-name if so. If the DO statement specifies an ending label, the ENDDO statement must be labelled with that label.

Endfile Statement

ENDFILE expr

ENDFILE ( position-spec-list )

(See the BACKSPACE statement for the position-spec-list definition).

Writes an endfile record to the specified external file, truncating it at the current point.

End Function Statement

END [ FUNCTION [ name ] ]

The last statement of a function subprogram. If the function subprogram is a contained subprogram, the keyword FUNCTION must be present. If name is present, it must be the name of the function.

Endif Statement

END IF [ construct-name ]

Marks the end of an IF-THEN construct. The construct-name shall be present if and only if it were present on the IF-THEN statement, and must be the same construct-name if so.

End Interface Statement

END INTERFACE [ generic-spec ]

Marks the end of an interface block. If the INTERFACE statement had a generic-spec, it may appear on the ENDINTERFACE statement.

End Module Statement

END [ MODULE [ name ] ]

The final statement of a module subprogram. If name is present, it must match the name on the MODULE statement.

End Program Statement

END [ PROGRAM [ name ] ]

The final statement of a main program unit. If name is present, the main program must have a PROGRAM statement and the names must be the same.

End Select Statement

END SELECT [ construct-name ]

Marks the end of a SELECT construct. The construct-name shall be present if and only if it were present on the SELECT statement, and must be the same construct-name if so.

End Type Statement

END TYPE [ name ]

Marks the end of a derived type definition. If name is present it must be the name of the derived type.

Endwhere Statement

ENDWHERE [ construct-name ]

Marks the end of a WHERE construct. The construct-name shall be present if and only if it were present on the WHERE statement, and must be the same construct-name if so.

Equivalence Statement

EQUIVALENCE equivalence-set [ , equivalence-set ]...

equivalence-set ::= ( variable { , variable }... )

Declares each object in an equivalence-set to occupy the same storage.

Entry Statement

ENTRY name [ ( [ arg-list ] ) ]

Declares an additional entry point to the enclosing subprogram (entry points are not allowed in block data, main program, module and internal subprograms).

External Statement

EXTERNAL name [ , name ]...

Declares the listed names to be external subprograms or block data subprograms.

Exit Statement

EXIT [ construct-name ]

Transfers control to the statement following named DO loop or, if construct-name is omitted, the innermost enclosing DO loop.

Forall Statement

FORALL ( triplet-spec [ , triplet-spec ]... [ , expr ] ) forall-assignment-stmt

triplet-spec ::= name = expr : expr [ : expr ]

The iteration space of a FORALL statement or construct is the cross-product of the sets of possible index values defined by each triplet-spec masked by the final expr (if present). Note that the scope of the index names is limited to the FORALL statement – a variable with the same name outside the FORALL statement is unaffected.

The FORALL statement executes the forall-assignment statement for each index value set in the iteration space.

Forall Assignment Statement

variable = expr

variable => expr

This is exactly like a normal assignment statement except that the expr is evaluated for each element of the iteration space before assignment or pointer assignment to each variable. Note that an assignment must not assign to the same element of an array more than once in the iteration space, and if the variable is scalar then the iteration space must be exactly one element.

Forall Construct Statement

FORALL ( triplet-spec [ , triplet-spec ]... [ , expr ] )

(See the FORALL statement for the triplet-spec definition and the explanation of the iteration space.)

Begins a FORALL construct.

Format Statement

FORMAT ( [ format-list ] )

format-list ::= format-item [ , format-item ]...

format-item ::= [ digit-string ] { data-edit | ( format-list ) } | other-edit

data-edit ::=	{ `I` \| `B` \| `O` \| `Z` } digit-string [ `.` digit-string ] \|
	{ `F` \| `D` } digit-string `.` digit-string \|
	{ `E` \| `EN` \| `ES` \| `G` }
	digit-string `.` digit-string [ `E` digit-string ] \|
	`L` digit-string \|
	`A` [ digit-string ]

other-edit ::=	digit-string { `/` \| `P` \| `X` } \|
	{ `T` \| `TR` \| `TL` } digit-string \|
	character-literal \|
	digit-string H char... \|
	`/` \| `:` \| `BN` \| `BZ` \| `S` \| `SP` \| `SS`

Note: The character-literal must not have a kind-specifier. The H edit descriptor is followed by digit-string chars, which may be any character except end-of-line; this edit descriptor is obsolescent and the character-literal one should be used instead.

Declares an i/o format.

Note: The comma between format-items may be omitted as follows:

Between a ‘P’ descriptor and a following ‘D’, ‘E’, ‘EN’, ‘ES’, ‘F’ or ‘G’ descriptor,
Before a ‘/’ descriptor with no preceding digit-string,
After a ‘/’ descriptor and
Before or after a ‘:’ descriptor.

Function Statement

[ prefix ] FUNCTION name ( [ name [ , name ] ... ] ) [ RESULT(name) ]

prefix :: = { type-spec | RECURSIVE | PURE | ELEMENTAL }...

Note: At most one occurrence of each prefix item is allowed.

This is the first statement of a function subprogram. If no RESULT variable is specified the result variable has the same name as the function name (thus for direct recursion, a RESULT clause is necessary as well as the RECURSIVE keyword).

Goto Statement

GOTO label

Branches to the specified label, which must be on a branch target statement (i.e., the subprogram END statement, an executable statement, the first statement of an executable construct or the last statement of an enclosing executable construct).

If Statement

IF ( expr ) executable

Executes the sub-statement if and only if the condition is true. The sub-statement cannot itself be an IF statement.

If Then Statement

[ construct-name : ] IF ( expr ) THEN

Begins an IF-THEN construct and the THEN part thereof. Statements in this part are executed if and only if the condition is true. This statement may have a construct-name; if it does, the corresponding ENDIF statement shall have the same construct-name and intervening ELSE and ELSEIF statements at the same level may have the same construct-name.

Implicit Statement

IMPLICIT implicit-spec [ , implicit-spec ]...

implicit-spec ::= type-spec ( letter-spec [ , letter-spec ] ... )

letter-spec ::= letter [ - letter ]

Alters the implicit type mapping from the default. The default map is

      IMPLICIT REAL(A-H,O-Z),INTEGER(I-N)

in an external subprogram or interface body, and the same as the containing subprogram in a contained subprogram.

Implicit None Statement

IMPLICIT NONE

This statement sets the implicit type mapping for each letter to null, i.e., there are no implicit types. It must occur before any PARAMETER statements or other declarations (but after any USE statements).

Inquire Statement

INQUIRE ( IOLENGTH=object ) output-item [ , output-item ]...

INQUIRE ( inquire-spec [ , inquire-spec ]... )

inquire-spec ::=	[ `UNIT=` ] expr \| `ACCESS=` variable \| `ACTION=` variable \| `BLANK=` variable \| `CONVERT=` variable \|
	`DELIM=` variable \| `DIRECT=` variable \| `ERR=` label \| `EXIST=` variable \| `FILE=` expr \|
	`FORM=` variable \| `FORMATTED=` variable \| `IOSTAT=` variable \| `NAME=` variable \|
	`NAMED=` variable \| `NEXTREC=` variable \| `NUMBER=` variable \| `OPENED=` variable \|
	`PAD=` variable \| `POSITION=` variable \| `READ=` variable \| `READWRITE=` variable \|
	`RECL=` variable \| `SEQUENTIAL=` variable \| `UNFORMATTED=` variable

output-item ::= expr | ( { output-item , } ... do-spec )

The first form enquires as to the length needed to be specified for RECL= in the OPEN statement for an unformatted sequential file to be able to write records as large as the output-item list.

The second form enquires either by unit or by file; exactly one UNIT= or FILE= clause must be present (the UNIT= keyword can be omitted if it is the first inquire-spec). If the FILE= clause is used and that file is currently connected to a unit, the effect is as if that unit were specified.

The effect of each clause is as below:

ACCESS=: Sets the scalar character object to 'SEQUENTIAL' if the unit is connected for sequential access, to 'DIRECT' if the unit is connected for direct access, and to 'UNDEFINED' if there is no connection.
ACTION=: Sets the scalar character object to 'READ' if the unit is connected for input only, to 'WRITE' if the unit is connected for output only, to 'READWRITE' if the unit is connected for both input and output, and to 'UNDEFINED' if there is no connection.
BLANK=: If the unit is connected for formatted i/o, sets the scalar character object to 'NULL' if blanks are treated as nulls on input and to 'ZERO' if they are treated as zeroes on input. Otherwise the object is set to 'UNDEFINED'.
CONVERT=: Sets the scalar character object to 'UNKNOWN' if the file is not connected for unformatted input/output, and otherwise to the value of the CONVERT= specifier in the OPEN statement or as determined by the FORT_CONVERTn environment variable. Possible values are 'NATIVE', 'BIG_NATIVE', 'LITTLE_NATIVE', 'BIG_IEEE', 'LITTLE_IEEE', 'BIG_IEEE_DD' and 'LITTLE_IEEE_DD'.
DELIM=: Sets the scalar character object to 'APOSTROPHE' if the apostrophe is used to delimit character data in list-directed or namelist output for the unit, to 'QUOTE' if the quotation mark is to be so used, to 'NONE' if no delimiter is to be used, and to 'UNDEFINED' if there is no connection.
DIRECT=: Sets the scalar character object to 'YES' if direct access is allowed for the unit, to 'NO' if direct access is not allowed, and to 'UNKNOWN' if the answer cannot be determined.
ERR=: Transfers control to the specified label if an error condition occurs during execution of the enquiry.
EXIST=: Sets the scalar default logical object to .TRUE. if the file or unit exists, and to .FALSE. otherwise.
FORM=: Sets the scalar character object to 'FORMATTED' if the unit is connected for formatted i/o, to 'UNFORMATTED' if the unit is connected for unformatted i/o, and to 'UNDEFINED' if there is no connection.
FORMATTED=: Sets the scalar character object to 'YES' if formatted i/o is allowed for the unit, to 'NO' if it is not allowed, and to 'UNKNOWN' if the answer cannot be determined.
IOSTAT=: Sets the scalar default integer object to a non-zero value to indicate an error condition occurring during the enquiry, and to zero otherwise.
NAME=: Sets the scalar character object to the name of the file connected to the unit (undefined if there is no name).
NAMED=: Sets the scalar default logical object to .TRUE. if the unit is connected to a named file, and to .FALSE. otherwise.
NEXTREC=: If the unit is connected for direct access, sets the scalar default integer object to 1 greater than the number of the record last read or written (or to 1 if no record has been read or written); otherwise the object becomes undefined.
NUMBER=: Sets the scalar default integer object to the number of the unit to which the file is connected, or to -1 if the file is not connected to a unit.
OPENED=: Sets the scalar default logical object to .TRUE. if the unit is connected to a file (or the file is connected to a unit), and to .FALSE. otherwise.
PAD=: Sets the scalar character object to 'NO' if the connection of the file to the unit included the PAD='NO' specifier; otherwise it is set to 'YES'.
POSITION=: Sets the scalar character object to 'REWIND' if the unit is positioned at the beginning of the file, to 'APPEND' if it is positioned at the end of the file, to 'ASIS' if the unit was connected with that specification (and no i/o or positioning has occurred since connection), to 'UNDEFINED' if the unit is connected for direct access or there is no connection, and to a processor-dependent value otherwise.
READ=: Sets the scalar character object to 'YES' if input is allowed for the file or unit, to 'NO' if input is not allowed for the file or unit, and to 'UNKNOWN' if the answer cannot be determined.
READWRITE=: Sets the scalar character object to 'YES' if both input and output are allowed for the file or unit, to 'NO' if at least one of input or output is not allowed for the file or unit, and to 'UNKNOWN' if the answer cannot be determined.
RECL=: Sets the scalar default integer object to the record length of a file connected for direct access or to the maximum record length of a file connected for sequential access. If there is no connection the object is undefined.
SEQUENTIAL=: Sets the scalar character object to 'YES' if sequential access is allowed for the unit, to 'NO' if sequential access is not allowed, and to 'UNKNOWN' if the answer cannot be determined.
UNFORMATTED=: Sets the scalar character object to 'YES' if unformatted i/o is allowed for the unit, to 'NO' if it is not allowed, and to 'UNKNOWN' if the answer cannot be determined.
WRITE=: Sets the scalar character object to 'YES' if output is allowed for the file or unit, to 'NO' if output is not allowed for the file or unit, and to 'UNKNOWN' if the answer cannot be determined.

Intent Statement

INTENT ( { IN | OUT | INOUT } ) [ :: ] name [ , name ]...

Declares the specified names, which must be the names of dummy arguments, to have the specified intent. INTENT(IN) arguments cannot appear in any context where they will be modified, INTENT(OUT) arguments are undefined on entry to the procedure, and INTENT(INOUT) and INTENT(OUT) arguments can only be associated with modifiable actual arguments (e.g., not expressions).

Interface Statement

INTERFACE

INTERFACE { name | ASSIGNMENT(=) | OPERATOR(operator) }

The first form introduces an interface block, containing interface bodies which specify the interfaces to external or dummy procedures. The second form additionally defines a generic name or operator by which these procedures may be referenced, and its interface block may also contain MODULE PROCEDURE statements.

Intrinsic Statement

INTRINSIC name [ , name ]...

Declares the listed names to be intrinsic procedures.

Module Statement

MODULE name

This is the first statement of a module subprogram.

Module Procedure Statement

MODULE PROCEDURE name [ , name ]...

This statement is only allowed within generic interface blocks, where it declares the listed names as module procedures to be included in the generic.

Namelist Statement

NAMELIST namelist-group [ [ , ] namelist-group ]...

namelist-group ::= /name/ name [ , name ]...

Declares one or more i/o namelists. Multiple NAMELIST specifications for the namelist group /name/ are treated as if they were concatenated. The names in a namelist group must all be variables and not automatic, adjustable, allocatable, pointer, or contain a pointer.

Nullify Statement

NULLIFY ( object [ , object ] ... )

Sets the pointer-association status of the listed objects, which must be pointers, to dissociated.

Open Statement

OPEN ( open-spec [ , open-spec ]... )

open-spec ::=	[ `UNIT=` ] expr \| `ACCESS=` expr \| `ACTION=` expr \| `BLANK=` expr \| `CONVERT=` expr \| `DELIM=` expr \|
	`ERR=` label \| `FILE=` expr \| `FORM=` expr \| `IOSTAT=` object \| `PAD=` expr \| `POSITION=` expr \|
	`RECL=` expr \| `STATUS=` expr

Connects a file to a unit with the specified properties.

Optional Statement

OPTIONAL [ :: ] name [ , name ]...

Declares the specified names, which must be the names of dummy arguments, to be optional dummy arguments.

Parameter Statement

PARAMETER ( name = expr [ , name = expr ]... )

Declares the names to be named constants with the specified values. The expressions must be initialisation expressions and must be assignment compatible with the names.

Pause Statement (deleted)

PAUSE [ constant ]

Pauses program execution. If present, the constant must be a scalar character literal with no kind-param or a digit-string with at most 5 digits.

Pointer Statement

POINTER [ :: ] name [ deferred-shape ] [ , name [ deferred-shape ] ]...

Declares the names to be pointers.

Pointer Assignment Statement

variable => expr

Associates the pointer variable with expr, which must be another pointer, a variable with the TARGET attribute, or a reference to a function that returns a pointer result.

Print Statement

PRINT format [ , output-item ]...

format ::= * | label | expr

Synonymous with a WRITE statement with ‘UNIT=*’ and a FMT=format clause.

The possibilities for format are:

‘*’: indicates list-directed formatting.
label: must be the label of a FORMAT statement.
expr: A character expression may be supplied; its value is interpreted as the text following the keyword FORMAT of a FORMAT statement. If the expression is array-valued the concatenation of all elements is interpreted in this way.
expr: (obsolescent) A default scalar integer variable name may be supplied, in which case it must have been ASSIGNed the label of a FORMAT statement.

Private Statement

PRIVATE [ [ :: ] access-id [ , access-id ]... ]

access-id ::= name | ASSIGNMENT(=) | OPERATOR(operator)

This statement can only occur in the declaration section of a module or before the component definitions in a type definition.

When this statement appears in a type definition, there can be no access-ids; it causes the components of the type to be inaccessible from outside the module in which the type is defined.

In a module's declaration section, this statement either sets the default accessibility of entities within the module to be PRIVATE, i.e., not accessible, or the accessibility of each access-id is set to be PRIVATE.

Program Statement

PROGRAM name

This is the first statement of a main program. It is optional.

Public Statement

PUBLIC [ [ :: ] access-id [ , access-id ]... ]

This statement can only occur in the declaration section of a module. With no access-id list, it confirms that the default accessibility of entities in the module is PUBLIC. With an access-id list, it explicitly sets the accessibility of those access-ids to PUBLIC.

Read Statement

READ format [ , input-item ]...

READ ( control-spec [ , control-spec ]... ) [ input-item [ , input-item ]... ]

input-item ::= variable | ( { input-item , }... do-spec )

control-spec ::=	[ `UNIT=` ] { `` \| expr* } \|
	[ `FMT=` ] format \| [ `NML=` ] name \| `ADVANCE=` expr \| `END=` label \|
	`EOR=` label \| `ERR=` label \| `IOSTAT=` expr \| `REC=` expr \| `SIZE=` expr

(See the PRINT statement for format details.)

Reads one or more records (or partial records with ADVANCE='NO') from the specified unit.

The effect of each control-specifier is as below:

UNIT=: Identifies the i/o unit; ‘*’ indicates the default unit, a scalar integer expression indicates an external unit, and a character expression indicates an internal unit.
FMT=: Establishes the format; this is absent for namelist formatting or for unformatted i/o.
NML=: Specifies a namelist group name for namelist formatted i/o.
ADVANCE=: Indicates whether non-advancing (expression evaluates to 'NO') or the usual advancing (expression evaluates to 'YES') i/o is performed. This control-specifier is only allowed for formatted sequential i/o with an explicit format (i.e., not namelist or list-directed).
END=: Transfers control to the specified label if an end-of-file condition occurs during input (not allowed in WRITE).
EOR=: Transfers control to the specified label if an end-of-record condition occurs during input (not allowed in WRITE). ADVANCE='NO' must be specified.
ERR=: Transfers control to the specified label if an error condition occurs during i/o.
IOSTAT=: Sets the object to −1 if an end-of-file occurs, to −2 if an end-of-record occurs (non-advancing only), to a positive number if an error occurs, and to zero otherwise. Note that the negative values may vary on other compilers.
REC=: Specifies the record number for direct-access i/o.
SIZE=: Sets the object to the number of characters transferred by data edit descriptors (not allowed in WRITE). ADVANCE='NO' must be specified.

Return Statement

RETURN [ expr ]

Return immediately from the procedure. If the procedure is a subroutine with alternate return arguments (obsolescent), the scalar integer expression indicates to which label control is to be transferred on return (if the expression is less than one or greater than the number of alternate return arguments, execution continues with the statement following the subroutine reference).

Rewind Statement

REWIND expr

REWIND ( position-spec-list )

(See the BACKSPACE statement for the position-spec-list definition).

Positions an i/o unit, which must be connected to a rewindable file, to the beginning of the file.

Save Statement

SAVE [ [ :: ] save-item [ , save-item ]... ]

save-item ::= variable-name | /common-block-name/

Specifies the SAVE attribute for the listed variables or common blocks, or, with no save-item list, specifies that all possible variables and common blocks in the current scoping unit should implicitly have the SAVE attribute by default.

Select Statement

[ construct-name : ] SELECT CASE ( expr )

The initial statement of a SELECT CASE construct. Control is transferred to the CASE statement satisfied by the expression's value, or to the END SELECT statement if no CASE is satisfied by the value.

Statement Function Statement (obsolescent)

name ( [ name [ , name ] ... ] ) = expr

Defines a statement function.

Stop Statement

STOP [ constant ]

Halts program execution. If present, the constant must be a scalar character literal with no kind-param or a digit-string with at most 5 digits.

Subroutine Statement

[ RECURSIVE | PURE | ELEMENTAL]... SUBROUTINE name [ ( [ arg-list ] ) ]

(Note that at most one occurrence of each keyword is allowed).

arg-list ::= arg [ , arg ]...

arg ::= name | *

This is the first statement of a subroutine subprogram. RECURSIVE must be specified if the subroutine calls itself, either directly or indirectly. If PURE is specified, the subroutine must satisfy the pure subroutine constraints and can then be called from a pure function. An arg that is ‘*’ signfies an alternate return label; this is obsolescent.

Target Statement

TARGET [ :: ] name [ array-spec ] [ , name [ array-spec ] ]...

Declares that the specified entities have the TARGET attribute.

Type Statement

TYPE name

This statement marks the beginning of the definition of the derived type name.

Type Declaration Statement

type-spec [ [ , attr-spec ] ... :: ] entity-decl-list

attr-spec ::=	`ALLOCATABLE` \| `DIMENSION` array-spec \| `EXTERNAL` \| `INTENT (` { `IN` \| `OUT` \| `INOUT` } `)` \|
	`INTRINSIC` \| `OPTIONAL` \| `PARAMETER` \| `POINTER` \| `PRIVATE` \| `PUBLIC` \| `SAVE` \| `TARGET`

Declares the listed entities to be of the specified type with the specified attributes.

Use Statement

USE name [ , rename-list ]

USE name, ONLY: only-list

rename-list ::= rename [ , rename ]...

rename ::= local-name => remote-name

only-list ::= only-item [ , only-item ]...

only-item ::= name | rename

The USE statement accesses the named module. Multiple USE statements for the same module act as if all the rename-lists and only-lists were concatenated.

If all the USE statements in a scoping unit for a particular module have the ONLY clause, only those items listed in a rename-list or only-list are accessible.

A rename causes item remote-name in the referenced module to be accessible in the local scoping unit by local-name. An only-item that is not a rename causes the name in the referenced module to be accessible in the local scoping unit by the same name.

Where Assignment Statement

variable = expr

The expression is evaluated (and the object updated) only for those elements for which the current control mask is true.

Where Statement

WHERE ( expr ) where-assignment-stmt

Executes the Where Assignment statement with the provided expression as the control mask.

Where Construct Statement

[ construct-name : ] WHERE ( expr )

Begins a Where Construct with the provided expression as the control mask.

Write Statement

WRITE ( control-spec [ , control-spec ] ... ) output-item [ , output-item ]...

(See the READ statement for control-spec details.)

Writes one or more records (or partial records with ADVANCE='NO') to the specified unit.

type-spec ::=	numeric-type [ kind-specifier ] \|
	numeric-type `` digit-string* \|
	`DOUBLE PRECISION` \|
	`CHARACTER` [ char-specifier ]

char-specifier ::=	`` digit-string* \|
	`* (` char-length `)` \|
	`(` char-length [ `,` [ `KIND =` ] expr ] `)` \|
	`(` `LEN =` char-length [ `, KIND =` expr ] `)` \|
	`(` `KIND =` expr [ `, LEN =` char-length ] `)`

data-edit ::=	{ `I` \| `B` \| `O` \| `Z` } digit-string [ `.` digit-string ] \|
	{ `F` \| `D` } digit-string `.` digit-string \|
	{ `E` \| `EN` \| `ES` \| `G` }
	digit-string `.` digit-string [ `E` digit-string ] \|
	`L` digit-string \|
	`A` [ digit-string ]

other-edit ::=	digit-string { `/` \| `P` \| `X` } \|
	{ `T` \| `TR` \| `TL` } digit-string \|
	character-literal \|
	digit-string H char... \|
	`/` \| `:` \| `BN` \| `BZ` \| `S` \| `SP` \| `SS`

inquire-spec ::=	[ `UNIT=` ] expr \| `ACCESS=` variable \| `ACTION=` variable \| `BLANK=` variable \| `CONVERT=` variable \|
	`DELIM=` variable \| `DIRECT=` variable \| `ERR=` label \| `EXIST=` variable \| `FILE=` expr \|
	`FORM=` variable \| `FORMATTED=` variable \| `IOSTAT=` variable \| `NAME=` variable \|
	`NAMED=` variable \| `NEXTREC=` variable \| `NUMBER=` variable \| `OPENED=` variable \|
	`PAD=` variable \| `POSITION=` variable \| `READ=` variable \| `READWRITE=` variable \|
	`RECL=` variable \| `SEQUENTIAL=` variable \| `UNFORMATTED=` variable