7.2.4.1. Primary

A primary is defined as follows:

A variable that is a primary must not be a whole assumed-size array or a section of an assumed-size array name, unless the last subscript position of the array is specified with a scalar subscript or a section subscript in which the upper bound is specified.

The following examples show primaries:

In the previous examples, ONE is a named constant if it has the PARAMETER attribute or appears in a PARAMETER statement. 'ABCS'(I:I) is a constant subobject even though I may be a variable because its parent ('ABCS') is a constant; the reference 'ABCS'(I:I) is a constant subobject because it cannot be defined like a variable can be defined. RATIONAL is a derived type and FCN is a user-defined function.

When an array variable is a primary, the whole array is used, except in a masked assignment statement. In a masked assignment statement, only that part of the array specified by the mask is used.

When a pointer is a primary, the target associated with (pointed to by) the pointer is used, except possibly when the pointer is an actual argument of a procedure, or is an operand of a defined operation or a defined assignment. Whether the pointer or the target is used in these exceptional cases is determined by the procedure invoked by the reference.

Recall that an assumed-size array is a dummy argument whose shape is not completely specified in the subprogram in that the extent in the last dimension is determined by its corresponding actual argument. The implementation model is that the extent in the last dimension is never known to the subprogram but is specified by the use of a subscript, section subscript, or vector subscript expression that defines an upper bound in the last dimension. Unless the extent is specified in this way, such an object must not be used as a primary in an expression. On the other hand, if a subscript, section subscript with an extent for the upper bound, or a vector subscript is specified for the last dimension, the array value has a well-defined shape and hence can be used as a primary in any expression. For example, if A is declared as REAL A(3,*), array A(:,3) has a well-defined shape and can be used as a primary in an expression.

Expressions can be used as actual arguments in procedure references (function references or subroutine calls). Because actual arguments can be expressions involving operations, actual arguments must not contain assumed-size arrays, unless their shape is well-defined, as described above. An actual argument, however, can be just a variable, which then allows the actual argument to be the name of an assumed-size array. This implies that such actual arguments can be assumed-size arrays, unless the procedure requires the shape of the argument to be specified by the actual argument. Most of the intrinsic procedures that allow array arguments require the shape to be specified for the actual array arguments, and therefore assumed-size arrays cannot be used as actual arguments for most intrinsic functions. The exceptions are all references to the intrinsic function LBOUND(3i), and certain references to the intrinsic functions UBOUND(3i) and SIZE(3i).

7.2.4.2. Defined Unary Expression

Defined unary expressions have the highest operator precedence. A defined unary expression is a defined operator followed by a primary. These are defined as follows:

A defined operator must not contain more than 31 letters.

A defined operator must not be the same as any intrinsic operator (.NOT., .AND., .OR., .EQV., .NEQV., .EQ., .NE., .GT., .GE., .LT., .LE., or .LG.) or any logical literal constant (.FALSE. or .TRUE.).

A defined operator can be the same as one of the masking or Boolean operators supported by the Cray Fortran Compiler as an extension to the Fortran standard. The corresponding Cray Fortran operator loses its intrinsic properties. Note that the abbreviations .T., .F., .A., .O., .N., and .X. are synonyms for .TRUE., .FALSE., .AND., .OR., .NOT., and .XOR., respectively. If you define the abbreviated operator for any type, the abbreviated form of the intrinsic operator also cannot be used in any scope in which the defined operator is accessible, and the redefined abbreviated logical constants can no longer be used as logical constants.

The following examples show defined unary expressions:

7.2.4.3. Exponentiation Expression

An exponentiation expression is an expression in which the operator is the exponentiation operator **. This is defined as follows:

Note that the definition is right recursive (that is, the defined term appears to the right of the operator **) which indicates that the precedence of the ** operator in contexts of equal precedence is right-to-left. Thus, the interpretation of the expression A ** B ** C is A ** ( B ** C ).

The following examples show exponentiation expressions:

7.2.4.4. Multiplication Expression

A multiplication expression is an expression in which the operator is either * or /. It is defined as follows:

Note that the definition is left recursive (that is, the defined term appears to the left of the operator * or /) which indicates that the precedence of the * and / operators in contexts of equal precedence is left-to-right. Thus, the interpretation of the expression A * B * C is (A * B) * C, or A / B * C is (A / B) * C. This left-to-right precedence rule applies to the remaining binary operators except the relational operators.

The following examples show multiplication expressions:

7.2.4.5. Summation Expression

A summation expression is an expression in which the operator is either + or -. It is defined as follows:

The following examples show summation expressions:

7.2.4.6. Concatenation Expression

A concatenation expression is an expression in which the operator is //. It is defined as follows:

The following examples show concatenation expressions:

7.2.4.7. Comparison Expression

A comparison expression is an expression in which the operator is a relational operator. It is defined as follows:

The operators ==, /=, <, <=, >, >=, and <> are synonyms in all contexts for the operators .EQ., .NE., .LT., .LE., .GT., .GE., and .LG., respectively.

Note that the definition of a comparison expression is not recursive, and therefore comparison expressions cannot contain relational operators in contexts of equal precedence.

The following examples show comparison expressions:

7.2.4.8. Not Expression

A not expression is an expression in which the operator is .NOT.. It is defined as follows:

Note that the definition of a not expression is not recursive, and therefore not expressions cannot contain adjacent .NOT. operators.

The following examples show not expressions:

7.2.4.9. Conjunct Expression

A conjunct expression is an expression in which the operator is .AND.. It is defined as follows:

Note that the definition of a conjunct expression is left recursive, and therefore the precedence of the .AND. operator in contexts of equal precedence is left-to-right. Thus, the interpretation of the expression A .AND. B .AND. C is (A .AND. B) .AND. C.

The following examples show conjunct expressions:

7.2.4.10. Inclusive Disjunct Expression

An inclusive disjunct expression is an expression in which the operator is .OR.. It is defined as follows:

Note that the definition of an inclusive disjunct expression is left recursive, and therefore the precedence of the .OR. operator in contexts of equal precedence is left-to-right. Thus, the interpretation of the expression A .OR. B .OR. C is (A .OR. B) .OR. C.

The following examples show inclusive disjunct expressions:

7.2.4.11. Equivalence Expressions and Exclusive Disjunct Expressions

An equivalence expression is an expression in which the operator is either .EQV. or .NEQV.. It is defined as follows:

An exclusive disjunct expression is an expression in which the operator is .XOR.. It is defined as follows:

Note the following:

• In the following discussion, equivalence expression means either equivalence expression or exclusive disjunct expression.

• The definition of an equivalence expression is left recursive, and therefore the precedence of the .EQV. or .NEQV. operators in contexts of equal precedence is left-to-right. Thus, the interpretation of the expression A .EQV. B .NEQV. C is (A .EQV. B) .NEQV. C.

The following examples show equivalence expressions:

7.2.4.12. Expression

The most general form of an expression is defined as follows:

Note that the definition of an expression is left recursive, and therefore the precedence of the binary defined operator in contexts of equal precedence is left-to-right. The interpretation of the expression A .PLUS. B .MINUS. C is thus (A .PLUS. B) .MINUS. C (where .MINUS. is a defined operator).

The following examples show expressions:

7.2.4.13. Summary of the Forms and Hierarchy for Expressions

The previous sections have described in detail the sorts of expressions that can be formed. These expressions form a hierarchy that can best be illustrated by a figure. Figure 7-1, describes the hierarchy by placing the simplest form of an expression, a variable, at the center of a set of nested rectangles. The more general forms of an expression are the enclosing rectangles, from a primary to an exponentiation expression, to a summation expression, and finally to a general expression using a defined binary operator .CROSS.. Figure 7-1 demonstrates that an expression is all of these special case forms, including the simplest form, a primary.

Table 7-2, illustrates the relationship between the different sorts of expressions by summarizing the definitional forms in one table. The simplest form of an expression is at the bottom and is the primary, as in Figure 7-1. The next, more general, form is second from the bottom and is the defined unary expression; it uses the primary in its definition. At the top of the table is the most general form of an expression.

7.2.8.1. Data Type and Type Parameters of a Primary

The type, type parameters, and shape of a primary that is a nonpointer variable or constant are straightforward because these properties are determined by specification statements for the variable or named constant, or by the form of the constant. For example, if A is a variable, its declaration in a specification statement such as the following determines it as an explicit-shaped array of type real with a default kind parameter:

REAL A(10, 10)

For a constant such as the following, the form of the constant indicates that it is a scalar constant of type complex and of default kind:

(1.3, 2.9)

For a pointer variable, the type, type parameters, and rank are determined by the declaration of the pointer variable. However, if the pointer is of deferred shape, the shape (in particular, the extents in each dimension) is determined by the target of the pointer. Consider the following declarations and assume that pointer A is associated with the target B:

REAL, POINTER :: A(:, :) REAL, TARGET :: B(10, 20)

The shape of A is (10, 20).

The type and type parameters of an array constructor are determined by the contents of the constructor. Unless the element is of type Boolean (or typeless), its type and type parameters are those of any element of the constructor because they must all be of the same type and type parameters. If the element is of type Boolean, the type and kind type of the array constructor are the same as the default integer type. Therefore, the type and type parameters of the following array constructor are integer and kind value 1:

(/ 1_1, 123_1, -10_1 /)

Its shape is always of rank one and of size equal to the number of elements.

The type of a structure constructor is the derived type or type alias used as the name of the constructor. A structure has no type parameters. So, the type of the following structure constructor is the derived type PERSON:

PERSON(56, 'Father')

(See Section 4.8, for the type definition PERSON.)

A structure constructor is always a scalar.

The type, type parameters, and shape of a function are determined by one of the following:

• An implicit type declaration for the function within the program unit referencing the function

• An explicit type declaration for the function within the program unit referencing the function (just like a variable)

• An explicit interface to the function. (When the interface is not explicit, the function is either an external function or a statement function.)

If the interface is explicit, the type, type parameter, and shape are determined by one of the following:

• The type and other specification statements for the function in an interface block within the program unit referencing the function

• The type and other specification statements for the internal or module procedure specifying the function

• The description of the particular intrinsic function being referenced

Note, however, that because intrinsic functions and functions with interface blocks can be generic, these properties are determined by the type, type parameters, and shapes of the actual arguments of the particular function reference.

For example, consider the following statements as part of the program unit specifying an internal function FCN:

REAL FUNCTION FCN(X) DIMENSION FCN(10, 15)

A reference to FCN(3.3) is of type default real with shape (10,15). As a second example, consider the following:

REAL(SINGLE) X(10, 10, 10) . . . . . . SIN(X) . . .

The interface to SIN(3i) is specified by the definition of the sine intrinsic function. In this case, the function reference SIN(X) is of type real with kind parameter value SINGLE and of shape (10,10,10).

The interface is implicit if the function is external (and no interface block is provided) or is a statement function. In these cases, the shape is always that of a scalar, and the type and type parameters are determined by the implicit type declaration rules in effect, or by an explicit type declaration for the function name. In the following example, FCN(X) is a scalar of type integer with kind type parameter value SHORT:

IMPLICIT INTEGER(SHORT) (A-F) . . . . . . FCN(X) . . .

The one case for variables and functions that is not straightforward is the determination of the shape of a variable when it is of deferred shape or of assumed shape. For a deferred-shape array, the rank is known from the declaration but the size of each dimension is determined as the result of executing an ALLOCATE statement or a pointer assignment statement. For an assumed-shape array, the rank is also known from the declaration but the size is determined by information passed into the subprogram. In the case of pointers, the shape of the object is that of the target associated with (pointed to by) the pointer. The shape of deferred-shape and assumed-shape arrays thus cannot be determined in general until execution time.

7.2.8.2. Type and Type Parameters of the Result of an Operation

The type of the result of an intrinsic operation is determined by the type of the operands and the intrinsic operation and is specified by Table 7-17.

For nonnumeric operations, the type parameters of the result of an operation are determined as follows:

• For the relational intrinsic operations, the kind type parameter is that for the default logical type.

• For logical intrinsic operations, the result kind type parameter depends on that of the operands. If the operands have the same kind type parameter (that is the same value for KIND=value), the kind type parameter is that of the operands. If logical operands have different kind type parameter values, the value of the result is that of the greater kind type parameter value.

• For the character intrinsic operation (//), the operands must have the same kind type parameter, so the result has that kind type parameter.

• The character length parameter value for the result is the sum of the character length parameters of the operands.

For numeric intrinsic operations, the kind type parameter value of the result is determined as follows:

• For unary operations, the kind type parameter value of the result is that of the operand.

• Floating-point operands are those of type real or type complex. If an operation includes a floating-point operand and an integer, the result type and kind type parameter value is determined as follows:

  • The result type is that of the floating-point operand.

  • The result kind type parameter value is the same as the kind type parameter value of the floating-point operand.

    See Table 7-17, for more information.

• If an operation includes operands of type complex and type real, the result type and kind type parameter value is determined as follows:

  • The result type is type complex.

  • The result kind type parameter value is that of the greater value. That is, the kind type parameter value of each operand is examined, and whichever kind type parameter value is greater is assigned to the result.

    See Table 7-17, for more information.

• For binary operations, if the operands are of the same type and kind type parameters, the kind type parameter value of the result is the kind type parameter of the operands.

• For binary operations, if the operands are both of type integer but with different kind type parameters, the kind type parameter value of the result is the kind type parameter of the operand with the larger sizes. If the sizes of the two kinds are the same, the kind type parameter value of the result is the same as each operand.

• For binary operations, if the operands are both of type real or complex but with different kind type parameters, the kind type parameter of the result is the kind type parameter of the operand with the larger precision. If the decimal precisions are the same, the kind type parameter value is that of the operands.

For numeric intrinsic operations, an easy way to remember the result type and type parameter rules is to consider that the numeric types (integer; real; complex; and Cray Fortran Boolean) are ordered by the increasing generality of numbers. Integers are contained in the set of real numbers and real numbers are contained in the set of complex numbers. Within the integer type, the kinds are ordered by increasing sizes. Within the real and complex types, the kinds for each type are ordered by increasing precision.

Using this model, the result type of a numeric intrinsic operation is the same type as the operand of the greater generality. For the result type parameter, the rule is complicated: if one or both of the operands is of type real or complex, the type parameter is that of the set of numbers of the more general type described above and with a precision as large as the precision of the operands; if both are of type integer, the result type parameter is of a set of numbers that has a range as large as the range of the operands.

To illustrate this ordering, consider Figure 7-2, which shows ordering. For integers, KIND=1 is an 8-bit format, KIND=2 is a 16-bit format, KIND=4 is a 32-bit format and KIND=8 is a 64-bit format; all are twos-complement representations. For the three kinds of real and complex data, KIND=4 is a 32-bit format, KIND=8 is a 64-bit format, and KIND=16 is a 128-bit format, with approximately 7, 16 and 34 significant decimal digits, respectively. Let variables of the 6 numeric types be I1, I2, I4, I8, R4, R8, R16, C4, C8, and C16, where the letter designates the type and the digits designate the kind type parameter. Using this ordering, Table 7-18 shows the type and type parameters of some simple expressions.

The type and type parameter values of a defined operation are determined by the interface block for the referenced operation and are the type and type parameters of the name of the function specified by the interface block. Note that the operator can be generic and therefore the type and type parameters can be determined by the operands. For example, consider the following interface:

INTERFACE OPERATOR (.PLUS.) TYPE(SET) FCN_SET_PLUS(X, Y) USE DEFINITIONS TYPE (SET) X, Y INTENT(IN) X, Y END FUNCTION FCN_SET_PLUS TYPE(RATIONAL) FCN_RAT_PLUS(X, Y) USE DEFINITIONS TYPE(RATIONAL) X, Y INTENT(IN) X, Y END FUNCTION FCN_RAT_PLUS END INTERFACE

The operation A .PLUS. B, where A and B are of type RATIONAL, is an expression of type RATIONAL with no type parameters. The operation C .PLUS. D, where C and D are of type SET is an expression of type SET with no type parameters.

7.2.8.3. Shape of an Expression

The shape of an expression is determined by the shape of each operand in the expression in the same recursive manner as for the type and type parameters for an expression. That is, the shape of an expression is the shape of the result of the last operation determined by the interpretation of the expression.

However, the shape rules are simplified considerably by the requirement that the operands of binary intrinsic operations must be in shape conformance; two operands are in shape conformance if both are arrays of the same shape, or one or both operands are scalars. The operands of a defined operation have no such requirement but must match the shape of the corresponding dummy arguments of the defining function.

For primaries that are constants, variables, constructors, or functions, the shape is that of the constant, variable, constructor, or function name. Recall that structure constructors are always scalar, and array constructors are always rank-one arrays of size equal to the number of elements in the constructor. For unary intrinsic operations, the shape of the result is that of the operand. For binary intrinsic operations, the shape is that of the array operand if there is one and is scalar otherwise. For defined operations, the shape is that of the function name specifying the operation.

For example, consider the intrinsic operation A + B where A and B are of type default integer and default real respectively; assume A is a scalar and B is an array of shape (3, 5). Then, the result is of type default real with shape (3, 5).

7.2.8.4. The Extents of an Expression

For most contexts, the lower and upper bounds of an array expression are not needed; only the sizes of each dimension are needed to satisfy array conformance requirements for expressions. The bounds of an array expression when it is the ARRAY argument (first positional argument) of the LBOUND(3i) and UBOUND(3i) intrinsic functions are needed, however.

The functions LBOUND(3i) and UBOUND(3i) have two keyword arguments ARRAY and DIM. ARRAY is an array expression and DIM, which is optional, is an integer. If the DIM argument is present, LBOUND(3i) and UBOUND(3i) return the lower and upper bounds, respectively, of the dimension specified by the DIM argument. If DIM is absent, they return a rank-one array of the lower and upper bounds, respectively, of all dimensions of the ARRAY argument. As described below, these functions distinguish the special cases when the array argument is a name or structure component with no section subscript list from the general case when the array argument is a more general expression. Note that if A is a structure with an array component B, A%B is treated as if it were an array name and not an expression.

When the ARRAY argument is an array expression that is not a name or a structure component, the function LBOUND(3i) returns 1 if the DIM argument is specified and returns a rank-one array of 1s if the DIM argument is absent. For the same conditions, the function UBOUND(3i) returns as the upper bound the size of the requested dimension or the size of all dimensions in a rank-one array.

When the ARRAY argument is an array name or a structure component with no section subscript list, there are four cases to distinguish depending on the array specifier for the name. The following sections describe these four cases.

7.2.9.1. Constant Expressions

A constant expression is one of the following constant values or is an expression consisting of intrinsic operators whose operands are any of the following constant values:

1. A literal or named constant, or a subobject of a constant where each subscript, section subscript, or starting and ending point of a substring range is a constant expression.

2. An array constructor where every subexpression has primaries that are constant expressions or are implied-DO variables of the array constructor.

3. A structure constructor where each component is a constant expression.

4. An elemental intrinsic function reference that can be evaluated at compile time.

5. A transformational intrinsic function reference that can be evaluated at compile time.

6. A reference to NULL(3i).

7. A reference to an intrinsic function that is one of the following:

   • An array inquiry function other than ALLOCATED(3i)

   • The bit inquiry function BIT_SIZE(3i)

   • The character inquiry function LEN(3i)

   • The KIND(3i) inquiry function

   • A numeric inquiry function

   Each argument of the function must be a constant expression or must be a variable whose type parameters or bounds inquired about are not assumed, defined by an expression that is not a constant expression, or definable by an ALLOCATE or pointer assignment statement.

8. An implied-DO variable within an array constructor in which the bounds and strides of the corresponding implied-DO are constant expressions.

9. A constant expression enclosed in parentheses.

The restriction in item 4 to intrinsic functions that can be evaluated at compile-time eliminates the use of the intrinsic functions PRESENT(3i), ALLOCATED(3i), and ASSOCIATED(3i). It also requires that each argument of the intrinsic function reference be a constant expression or a variable whose type parameters or bounds are known at compile time. This restriction excludes, for example, named variables that are assumed-shape arrays, assumed-size arrays for inquiries requiring the size of the last dimension, and variables that are pointer arrays or allocatable arrays. For example, if an array X has explicit bounds in all dimensions, an inquiry such as SIZE(X) can be computed at compile-time, and SIZE(X) + 10 is considered a constant expression.

Constant expressions can be used in any executable statement where general expressions (that is, unrestricted expressions) are permitted.

The following examples show constant expressions:

7.2.9.2. Initialization Expressions

An initialization expression is a constant expression restricted as follows:

• The exponentiation operator (**) is allowed only when the power (second operand) is of type integer; that is, X ** Y is allowed only if Y is of type integer.

• Subscripts, section subscripts, starting and ending points of substring ranges, components of structure constructors, and arguments of intrinsic functions must be initialization expressions.

• The elements of array constructors must be initialization expressions or implied-DOs for which the array constructor values and implied-DO parameters are expressions whose primaries are initialization expressions or implied-DO variables.

• An elemental intrinsic function in an initialization expression must have arguments that are initialization expressions and are of type integer or character. These elemental intrinsic functions must return a result of type integer or character.

• A transformational intrinsic function in an initialization expression must be one of the intrinsic functions NULL(3i), REPEAT(3i), RESHAPE(3i), SELECTED_INT_KIND(3i), SELECTED_REAL_KIND(3i), TRANSFER(3i), and TRIM(3i), and must have initialization expressions as arguments; this excludes the use of the transformational functions ALL(3i), ANY(3i), COUNT(3i), CSHIFT(3i), DOT_PRODUCT(3i), EOSHIFT(3i), MATMUL(3i), MAXLOC(3i), MAXVAL(3i), MINLOC(3i), MINVAL(3i), PACK(3i), PRODUCT(3i), SPREAD(3i), SUM(3i), TRANSPOSE(3i), and UNPACK(3i).

• An inquiry intrinsic function is allowed, except that the arguments must either be initialization expressions or variables whose type parameters or bounds inquired about are not assumed, not defined by an ALLOCATE statement, or not defined by pointer assignment.

• Any subexpression enclosed in parentheses must be an initialization expression.

All but the last examples in Section 7.2.9.1, are initialization expressions. The last are not because initialization expressions cannot contain functions that return results of type real (REAL(3i), LOG(3i)), must not reference certain transformational functions (COUNT(3i), SUM(3i)), or cannot use the exponentiation operator when the second operand is of type real.

The following are examples of initialization expressions:

Initialization expressions must be used in the following contexts:

• As initial values following the equal signs in PARAMETER statements and in type declaration statements with the PARAMETER attribute.

• As initial values following the equal signs in type declaration statements for variables.

• As expressions in structure constructors in DATA statement value lists.

• As expressions in default initializers.

• As kind type parameter values in type declaration statements; in this case, they also must be scalar and of type integer.

• As actual arguments for the KIND(3i) dummy argument of the conversion intrinsic functions AINT(3i), ANINT(3i), CHAR(3i), INT(3i), LOGICAL(3i), NINT(3i), REAL(3i), CMPLX(3i); in this case, they also must be scalar and of type integer.

• As case values in the CASE statement; in this situation, they must be scalar and of type integer, logical, or character.

• As subscript or substring range expressions of equivalence objects in an EQUIVALENCE statement; in this case, they must be scalar and of type integer.

Initialization expressions must be used for situations where the value of the expression is needed at compile time. Note that the initialization expressions do not include intrinsic functions that return values of type real, logical, or complex, or have arguments of type real, logical, or complex.

7.2.9.3. Specification Expressions

A specification expression is a restricted expression that has a scalar value and is of type integer. Specification expressions are used as bounds for arrays and length parameter values for character entities in type declarations, attribute specifications, dimension declarations, and other specification statements (see Table 7-19). A constant specification expression is a specification expression that is also a constant.

Specification expressions are forms of restricted expressions (defined below), limited in type and rank. Briefly, a restricted expression is limited to constants and certain variables accessible to the scoping unit whose values can be determined on entry to the program unit before any executable statement is executed. For example, variables that are dummy arguments, are in a common block, are in a host program unit, or are in a module made accessible to the program unit can be evaluated on entry to a program unit. Array constructors, structure constructors, intrinsic function references, and parenthesized expressions made up of these primaries must depend only on restricted expressions as building blocks for operands in a restricted expression.

A restricted expression is an expression in which each operation is intrinsic and each primary is limited to one of the following:

• A constant or constant subobject.

• A variable that is a dummy argument with neither the OPTIONAL nor the INTENT(OUT) attribute.

• A variable that is in a common block.

• A variable made accessible from a module.

• A variable from the host program unit.

• A variable accessible through USE association.

• An array constructor in which every expression has primaries that are restricted expressions or are implied-DO variables of the array constructor.

• A structure constructor in which each component is a restricted expression.

• An elemental intrinsic function whose result is of type integer or character and whose arguments are all restricted expressions of type integer or character.

• One of the transformational intrinsic functions (REPEAT(3i), RESHAPE(3i), SELECTED_INT_KIND(3i), SELECTED_REAL_KIND(3i), TRANSFER(3i), or TRIM(3i)), in which each argument is a restricted expression of type integer or character (this excludes the use of the transformational functions ALL(3i), ANY(3i), COUNT(3i), CSHIFT(3i), DOT_PRODUCT(3i), EOSHIFT(3i), MATMUL(3i), MAXLOC(3i), MAXVAL(3i), MINLOC(3i), MINVAL(3i), PACK(3i), PRODUCT(3i), SPREAD(3i), SUM(3i), TRANSPOSE(3i), and UNPACK(3i)).

• An inquiry intrinsic function (except for PRESENT(3i), ALLOCATED(3i), and ASSOCIATED(3i)), in which each argument is one of the following:

  • A restricted expression. Any subscript, section subscript, and starting or ending point of a substring range is a restricted expression.

  • A variable whose bounds or type parameters inquired about are not assumed, not defined by an ALLOCATE statement, and not defined by a pointer assignment statement

• A reference to any other intrinsic function in which each argument is a restricted expression.

• A reference to an external function whose result is a nonpointer scalar intrinsic type.

• A reference to a specification function in which each argument is a restricted expression.

A function is a specification function if it is a pure function, is not an intrinsic function, is not an internal function, is not a statement function, does not have a dummy procedure argument, and is not RECURSIVE.

7.2.9.4. Initialization and Specification Expressions in Declarations

The following rules and restrictions apply to the use of initialization and specification expressions in specification statements.

The type and type parameters of a variable or named constant in one of these expressions must be specified in a prior specification in the same scoping unit, in a host scoping unit, in a module scoping unit made accessible to the current scoping unit, or by the implicit typing rules in effect. If the variable or named constant is explicitly given these attributes in a subsequent type declaration statement, it must confirm the implicit type and type parameters.

If an element of an array is referenced in one of these expressions, the array bounds must be specified in a prior specification.

If a specification expression includes a variable that provides a value within the expression, the expression must appear within the specification part of a subprogram. For example, consider variable N in the following program segment:

INTEGER N COMMON N REAL A (N)

N is providing a value that determines the size of the array A. This program segment must not appear in a main program but may appear in the specification part of a subprogram.

A prior specification in the above cases may be in the same specification statement, but to the left of the reference. For example, the following declarations are valid:

INTEGER, DIMENSION(4), PARAMETER :: A = (/4, 3, 2, 1 /) REAL, DIMENSION(A (2)) :: B, C(SIZE(B))

B and C are of size 3 (the second element of the array A). The following declaration, however, is invalid because SIZE(E) precedes E:

REAL, DIMENSION(2) :: D(SIZE(E)), E

7.2.9.5. Uses of the Various Kinds of Expressions

The various kinds of expressions may be somewhat confusing, and it can be difficult to remember where they can be used. To summarize the differences, Section 7.2.4, specifies the most general kind of expression; the other kinds of expressions are restrictions of the most general kind. The classification of expressions forms two orders, each from most general to least general, as follows:

• Expression, restricted expression, and specification expression

• Expression, constant expression, and initialization expression

The relationship between the various kinds of expression can be seen in the diagram in Figure 7-3.

Initialization expressions are not a subset of specification expressions because the result of an initialization expression can be of any type, whereas the result of a specification expression must be of type integer and scalar. Also, specification expressions are not a subset of initialization expressions because specification expressions allow certain variables (such as dummy arguments and variables in common blocks) to be primaries, where as initialization expressions do not allow such variables.

Table 7-19, describes the differences between initialization and specification expressions. Table 7-20, summarizes where each kind of expression is used and gives the restrictions as to their type and rank when used in the various contexts. For example, Table 7-19, indicates that initialization and specification expressions are different in that initialization expressions can be array valued, whereas specification expressions are scalar. A consequence of this difference, as indicated in Table 7-20, is that an initialization expression is used in a type declaration statement or a PARAMETER statement to specify the value of a named constant array, whereas a specification expression is used to specify the bounds of an array in a declaration statement.

Example 1: The expressions I*3, 1+2*J, 5*J/3, 1, and 10 in the following statement, are all expressions allowed in subscripts and implied-DO parameter expressions in an implied-DO list in a DATA statement:

DATA ((A(I*3), I = 1+2*J, 5*J/3), J = 1, 10) /.../

Example 2: An expression such as RADIX(I) is not allowed as a data implied-DO parameter or subscript of a DATA statement object.

An expression such as N, where N is a variable in the scoping unit that contains the DATA statement, is not allowed because N is neither a named constant nor an implied-DO variable in a containing implied-DO list.

Such special expressions in DATA statements are restricted forms of initialization expressions in the sense that the primaries must not include references to any intrinsic function. On the other hand, they are extended forms of initialization expressions in the sense that they permit the use of implied-DO variables that have the scope of the implied-DO list.