WORKING DRAFT





         J3/02-007R3





   September 20, 2002 12:22





This is an internal working document of J3.




SEP 2002                                   WORKING DRAFT                                           J3/02-007R3





Contents


1    Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .        1
     1.1    Scope . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .      1
     1.2    Processor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .      1
     1.3    Inclusions    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .    1
     1.4    Exclusions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .       1
     1.5    Conformance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .        2
     1.6    Compatibility . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .        3
            1.6.1    Fortran 95 compatibility . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .          3
            1.6.2    Fortran 90 compatibility . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .          3
            1.6.3    FORTRAN 77 compatibility           . . . . . . . . . . . . . . . . . . . . . . . . . . . . .    3
     1.7    Notation used in this standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .         4
            1.7.1    Informative notes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .         4
            1.7.2    Syntax rules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .        4
            1.7.3    Constraints      . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .    5
            1.7.4    Assumed syntax rules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .          6
            1.7.5    Syntax conventions and characteristics . . . . . . . . . . . . . . . . . . . . . . .            6
            1.7.6    Text conventions       . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .    6
     1.8    Deleted and obsolescent features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .         6
            1.8.1    Nature of deleted features       . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .    7
            1.8.2    Nature of obsolescent features . . . . . . . . . . . . . . . . . . . . . . . . . . . .          7
     1.9    Normative references . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .         7

2    Fortran terms and concepts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .          9
     2.1    High level syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .        9
     2.2    Program unit concepts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
            2.2.1    Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
            2.2.2    Main program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
            2.2.3    Procedure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
            2.2.4    Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
     2.3    Execution concepts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
            2.3.1    Executable/nonexecutable statements . . . . . . . . . . . . . . . . . . . . . . . . 13
            2.3.2    Statement order . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
            2.3.3    The END statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
            2.3.4    Execution sequence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
     2.4    Data concepts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
            2.4.1    Type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
            2.4.2    Data value . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
            2.4.3    Data entity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
            2.4.4    Scalar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
            2.4.5    Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
            2.4.6    Pointer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
            2.4.7    Storage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
     2.5    Fundamental terms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
            2.5.1    Name and designator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
            2.5.2    Keyword . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
            2.5.3    Association . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
            2.5.4    Declaration      . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19




SEP 2002                                            WORKING DRAFT                                                    i


J3/02-007R3                                      WORKING DRAFT                                          SEP 2002



             2.5.5     Definition     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
             2.5.6     Reference . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
             2.5.7     Intrinsic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
             2.5.8     Operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
             2.5.9     Sequence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
             2.5.10    Companion processors        . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

3     Characters, lexical tokens, and source form        . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
      3.1    Processor character set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
             3.1.1     Letters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
             3.1.2     Digits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
             3.1.3     Underscore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
             3.1.4     Special characters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
             3.1.5     Other characters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
      3.2    Low-level syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
             3.2.1     Names . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
             3.2.2     Constants     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
             3.2.3     Operators     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
             3.2.4     Statement labels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
             3.2.5     Delimiters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
      3.3    Source form . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
             3.3.1     Free source form . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
             3.3.2     Fixed source form . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
      3.4    Including source text . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

4     Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
      4.1    The concept of type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
             4.1.1     Set of values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
             4.1.2     Constants     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
             4.1.3     Operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
      4.2    Type parameters        . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
      4.3    Relationship of types and values to objects . . . . . . . . . . . . . . . . . . . . . . . . . . 33
      4.4    Intrinsic types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
             4.4.1     Integer type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
             4.4.2     Real type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
             4.4.3     Complex type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
             4.4.4     Character type      . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
             4.4.5     Logical type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
      4.5    Derived types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
             4.5.1     Derived-type definition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
             4.5.2     Determination of derived types        . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
             4.5.3     Extensible types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
             4.5.4     Component order . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
             4.5.5     Type parameter order . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
             4.5.6     Derived-type values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
             4.5.7     Derived-type specifier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
             4.5.8     Construction of derived-type values . . . . . . . . . . . . . . . . . . . . . . . . . 57
             4.5.9     Derived-type operations and assignment          . . . . . . . . . . . . . . . . . . . . . . 59
             4.5.10    The finalization process . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
      4.6    Type aliases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
      4.7    Enumerations and enumerators          . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
      4.8    Construction of array values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

5     Data object declarations and specifications         . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67




ii                                       WORKING DRAFT                                                  SEP 2002


SEP 2002                                   WORKING DRAFT                                          J3/02-007R3



     5.1    Type declaration statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
            5.1.1     Type specifiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
            5.1.2     Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
     5.2    Attribute specification statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
            5.2.1     Accessibility statements     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
            5.2.2     ALLOCATABLE statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
            5.2.3     ASYNCHRONOUS statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
            5.2.4     BIND statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
            5.2.5     DATA statement        . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
            5.2.6     DIMENSION statement          . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
            5.2.7     INTENT statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
            5.2.8     OPTIONAL statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
            5.2.9     PARAMETER statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
            5.2.10    POINTER statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
            5.2.11    PROTECTED statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
            5.2.12    SAVE statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
            5.2.13    TARGET statement         . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
            5.2.14    VALUE statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
            5.2.15    VOLATILE statement          . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
     5.3    IMPLICIT statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
     5.4    NAMELIST statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
     5.5    Storage association of data objects      . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
            5.5.1     EQUIVALENCE statement            . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
            5.5.2     COMMON statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

6    Use of data objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
     6.1    Scalars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
            6.1.1     Substrings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
            6.1.2     Structure components . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
            6.1.3     Type parameter inquiry       . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
     6.2    Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
            6.2.1     Whole arrays     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
            6.2.2     Array elements and array sections . . . . . . . . . . . . . . . . . . . . . . . . . . 105
     6.3    Dynamic association       . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
            6.3.1     ALLOCATE statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
            6.3.2     NULLIFY statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
            6.3.3     DEALLOCATE statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

7    Expressions and assignment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
     7.1    Expressions    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
            7.1.1     Form of an expression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
            7.1.2     Intrinsic operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
            7.1.3     Defined operations      . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
            7.1.4     Type, type parameters, and shape of an expression . . . . . . . . . . . . . . . . 123
            7.1.5     Conformability rules for elemental operations        . . . . . . . . . . . . . . . . . . . 125
            7.1.6     Specification expression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
            7.1.7     Initialization expression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
            7.1.8     Evaluation of operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
     7.2    Interpretation of operations     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
            7.2.1     Numeric intrinsic operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
            7.2.2     Character intrinsic operation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
            7.2.3     Relational intrinsic operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
            7.2.4     Logical intrinsic operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
     7.3    Precedence of operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136




SEP 2002                                           WORKING DRAFT                                                  iii


J3/02-007R3                                     WORKING DRAFT                                           SEP 2002



      7.4    Assignment      . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
             7.4.1    Assignment statement        . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
             7.4.2    Pointer assignment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
             7.4.3    Masked array assignment � WHERE . . . . . . . . . . . . . . . . . . . . . . . . 145
             7.4.4    FORALL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148

8     Execution control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
      8.1    Executable constructs containing blocks        . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
             8.1.1    Rules governing blocks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
             8.1.2    IF construct . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
             8.1.3    CASE construct . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
             8.1.4    ASSOCIATE construct . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
             8.1.5    SELECT TYPE construct . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
             8.1.6    DO construct      . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
      8.2    Branching . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
             8.2.1    GO TO statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
             8.2.2    Computed GO TO statement            . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
             8.2.3    Arithmetic IF statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
      8.3    CONTINUE statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
      8.4    STOP statement       . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170

9     Input/output statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
      9.1    Records . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
             9.1.1    Formatted record . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
             9.1.2    Unformatted record . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
             9.1.3    Endfile record . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
      9.2    External files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
             9.2.1    File existence    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
             9.2.2    File access . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
             9.2.3    File position . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
             9.2.4    File storage units . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
      9.3    Internal files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
      9.4    File connection    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
             9.4.1    Connection modes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
             9.4.2    Unit existence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
             9.4.3    Connection of a file to a unit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
             9.4.4    Preconnection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
             9.4.5    The OPEN statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
             9.4.6    The CLOSE statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
      9.5    Data transfer statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
             9.5.1    Control information list . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
             9.5.2    Data transfer input/output list       . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
             9.5.3    Execution of a data transfer input/output statement . . . . . . . . . . . . . . . 193
             9.5.4    Termination of data transfer statements         . . . . . . . . . . . . . . . . . . . . . . 203
      9.6    Waiting on pending data transfer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
             9.6.1    WAIT statement        . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
             9.6.2    Wait operation       . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
      9.7    File positioning statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
             9.7.1    BACKSPACE statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
             9.7.2    ENDFILE statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
             9.7.3    REWIND statement          . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
      9.8    FLUSH statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
      9.9    File inquiry    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
             9.9.1    Inquiry specifiers     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208




iv                                      WORKING DRAFT                                                   SEP 2002


SEP 2002                                    WORKING DRAFT                                           J3/02-007R3



           9.9.2       Restrictions on inquiry specifiers . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
           9.9.3       Inquire by output list . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
   9.10    Error, end-of-record, and end-of-file conditions . . . . . . . . . . . . . . . . . . . . . . . . 214
           9.10.1      Error conditions and the ERR= specifier . . . . . . . . . . . . . . . . . . . . . . 214
           9.10.2      End-of-file conditions and the END= specifier . . . . . . . . . . . . . . . . . . . 215
           9.10.3      End-of-record conditions and the EOR= specifier . . . . . . . . . . . . . . . . . 215
           9.10.4      IOSTAT= specifier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
           9.10.5      IOMSG= specifier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
   9.11    Restrictions on input/output statements . . . . . . . . . . . . . . . . . . . . . . . . . . . 216

10 Input/output editing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
   10.1    Explicit format specification methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
           10.1.1      FORMAT statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
           10.1.2      Character format specification . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
   10.2    Form of a format item list . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
           10.2.1      Edit descriptors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
           10.2.2      Fields . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
   10.3    Interaction between input/output list and format . . . . . . . . . . . . . . . . . . . . . . 222
   10.4    Positioning by format control         . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
   10.5    Decimal symbol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224
   10.6    Data edit descriptors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224
           10.6.1      Numeric editing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224
           10.6.2      Logical editing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
           10.6.3      Character editing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
           10.6.4      Generalized editing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230
           10.6.5      User-defined derived-type editing . . . . . . . . . . . . . . . . . . . . . . . . . . 231
   10.7    Control edit descriptors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232
           10.7.1      Position editing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232
           10.7.2      Slash editing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
           10.7.3      Colon editing    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
           10.7.4      SS, SP, and S editing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
           10.7.5      P editing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234
           10.7.6      BN and BZ editing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234
           10.7.7      RU, RD, RZ, RN, RC, and RP editing . . . . . . . . . . . . . . . . . . . . . . . 234
           10.7.8      DC and DP editing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234
   10.8    Character string edit descriptors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
   10.9    List-directed formatting        . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
           10.9.1      List-directed input     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
           10.9.2      List-directed output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238
   10.10 Namelist formatting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
           10.10.1 Namelist input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
           10.10.2 Namelist output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243

11 Program units        . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
   11.1    Main program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
   11.2    Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
           11.2.1      Module reference       . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
           11.2.2      The USE statement and use association . . . . . . . . . . . . . . . . . . . . . . . 247
   11.3    Block data program units . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249

12 Procedures        . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
   12.1    Procedure classifications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
           12.1.1      Procedure classification by reference . . . . . . . . . . . . . . . . . . . . . . . . . 251
           12.1.2      Procedure classification by means of definition . . . . . . . . . . . . . . . . . . . 251




SEP 2002                                             WORKING DRAFT                                                   v


J3/02-007R3                                     WORKING DRAFT                                           SEP 2002



      12.2    Characteristics of procedures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252
              12.2.1    Characteristics of dummy arguments . . . . . . . . . . . . . . . . . . . . . . . . 252
              12.2.2    Characteristics of function results . . . . . . . . . . . . . . . . . . . . . . . . . . 253
      12.3    Procedure interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253
              12.3.1    Implicit and explicit interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253
              12.3.2    Specification of the procedure interface . . . . . . . . . . . . . . . . . . . . . . . 254
      12.4    Procedure reference . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
              12.4.1    Actual arguments, dummy arguments, and argument association . . . . . . . . . 264
              12.4.2    Function reference . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
              12.4.3    Subroutine reference    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
              12.4.4    Resolving procedure references . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
      12.5    Procedure definition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
              12.5.1    Intrinsic procedure definition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
              12.5.2    Procedures defined by subprograms . . . . . . . . . . . . . . . . . . . . . . . . . 275
              12.5.3    Definition and invocation of procedures by means other than Fortran . . . . . . 280
              12.5.4    Statement function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281
      12.6    Pure procedures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281
      12.7    Elemental procedures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
              12.7.1    Elemental procedure declaration and interface . . . . . . . . . . . . . . . . . . . 283
              12.7.2    Elemental function actual arguments and results . . . . . . . . . . . . . . . . . . 284
              12.7.3    Elemental subroutine actual arguments . . . . . . . . . . . . . . . . . . . . . . . 284

13 Intrinsic procedures and modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
      13.1    Classes of intrinsic procedures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
      13.2    Arguments to intrinsic procedures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
              13.2.1    The shape of array arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288
              13.2.2    Mask arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288
      13.3    Bit model    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288
      13.4    Numeric models . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289
      13.5    Standard generic intrinsic procedures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290
              13.5.1    Numeric functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290
              13.5.2    Mathematical functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290
              13.5.3    Character functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291
              13.5.4    Kind functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291
              13.5.5    Miscellaneous type conversion functions . . . . . . . . . . . . . . . . . . . . . . . 291
              13.5.6    Numeric inquiry functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291
              13.5.7    Array inquiry functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292
              13.5.8    Other inquiry functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292
              13.5.9    Bit manipulation procedures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292
              13.5.10 Floating-point manipulation functions . . . . . . . . . . . . . . . . . . . . . . . . 292
              13.5.11 Vector and matrix multiply functions . . . . . . . . . . . . . . . . . . . . . . . . 293
              13.5.12 Array reduction functions       . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293
              13.5.13 Array construction functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293
              13.5.14 Array location functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293
              13.5.15 Null function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293
              13.5.16 Random number subroutines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293
              13.5.17 System environment procedures . . . . . . . . . . . . . . . . . . . . . . . . . . . 294
      13.6    Specific names for standard intrinsic functions . . . . . . . . . . . . . . . . . . . . . . . . 294
      13.7    Specifications of the standard intrinsic procedures . . . . . . . . . . . . . . . . . . . . . . 296
      13.8    Standard intrinsic modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353
              13.8.1    The ISO C BINDING module . . . . . . . . . . . . . . . . . . . . . . . . . . . 353
              13.8.2    The IEEE modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353
              13.8.3    The ISO FORTRAN ENV intrinsic module . . . . . . . . . . . . . . . . . . . . 353





vi                                      WORKING DRAFT                                                   SEP 2002


SEP 2002                                 WORKING DRAFT                                          J3/02-007R3



14 Exceptions and IEEE arithmetic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355
   14.1    Derived types and constants defined in the modules . . . . . . . . . . . . . . . . . . . . . 356
   14.2    The exceptions     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357
   14.3    The rounding modes       . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359
   14.4    Halting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359
   14.5    The floating point status . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359
   14.6    Exceptional values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360
   14.7    IEEE arithmetic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360
   14.8    Tables of the procedures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361
           14.8.1    Inquiry functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361
           14.8.2    Elemental functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
           14.8.3    Kind function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
           14.8.4    Elemental subroutines     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
           14.8.5    Nonelemental subroutines      . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
   14.9    Specifications of the procedures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363
   14.10 Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376

15 Interoperability with C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381
   15.1    The ISO C BINDING intrinsic module . . . . . . . . . . . . . . . . . . . . . . . . . . . 381
           15.1.1    Named constants and derived types in the module . . . . . . . . . . . . . . . . . 381
           15.1.2    Procedures in the module      . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382
   15.2    Interoperability between Fortran and C entities . . . . . . . . . . . . . . . . . . . . . . . 385
           15.2.1    Interoperability of intrinsic types    . . . . . . . . . . . . . . . . . . . . . . . . . . 385
           15.2.2    Interoperability with C pointer types . . . . . . . . . . . . . . . . . . . . . . . . 386
           15.2.3    Interoperability of derived types and C struct types . . . . . . . . . . . . . . . . 386
           15.2.4    Interoperability of scalar variables . . . . . . . . . . . . . . . . . . . . . . . . . . 388
           15.2.5    Interoperability of array variables . . . . . . . . . . . . . . . . . . . . . . . . . . 388
           15.2.6    Interoperability of procedures and procedure interfaces . . . . . . . . . . . . . . 389
   15.3    Interoperation with C global variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391
           15.3.1    Binding labels for common blocks and variables . . . . . . . . . . . . . . . . . . 392
   15.4    Interoperation with C functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392
           15.4.1    Binding labels for procedures     . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392

16 Scope, association, and definition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395
   16.1    Scope of global entities . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395
   16.2    Scope of local entities . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396
           16.2.1    Local entities that have the same names as common blocks . . . . . . . . . . . . 397
           16.2.2    Function results . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397
           16.2.3    Restrictions on generic declarations . . . . . . . . . . . . . . . . . . . . . . . . . 397
           16.2.4    Components, type parameters, and bindings . . . . . . . . . . . . . . . . . . . . 398
           16.2.5    Argument keywords . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398
   16.3    Statement and construct entities . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399
   16.4    Association . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400
           16.4.1    Name association . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400
           16.4.2    Pointer association . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403
           16.4.3    Storage association . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405
           16.4.4    Inheritance association . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408
           16.4.5    Establishing associations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408
   16.5    Definition and undefinition of variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409
           16.5.1    Definition of objects and subobjects . . . . . . . . . . . . . . . . . . . . . . . . . 409
           16.5.2    Variables that are always defined       . . . . . . . . . . . . . . . . . . . . . . . . . . 409
           16.5.3    Variables that are initially defined . . . . . . . . . . . . . . . . . . . . . . . . . . 409
           16.5.4    Variables that are initially undefined . . . . . . . . . . . . . . . . . . . . . . . . 409
           16.5.5    Events that cause variables to become defined . . . . . . . . . . . . . . . . . . . 410




SEP 2002                                        WORKING DRAFT                                                  vii


J3/02-007R3                                 WORKING DRAFT                                            SEP 2002



          16.5.6    Events that cause variables to become undefined . . . . . . . . . . . . . . . . . . 411
          16.5.7    Variable definition context . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413

A Glossary of technical terms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415

B Decremental features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 427
   B.1    Deleted features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 427
   B.2    Obsolescent features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 428
          B.2.1     Alternate return . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 428
          B.2.2     Computed GO TO statement          . . . . . . . . . . . . . . . . . . . . . . . . . . . . 428
          B.2.3     Statement functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 428
          B.2.4     DATA statements among executables . . . . . . . . . . . . . . . . . . . . . . . . 429
          B.2.5     Assumed character length functions . . . . . . . . . . . . . . . . . . . . . . . . . 429
          B.2.6     Fixed form source . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429
          B.2.7     CHARACTER* form of CHARACTER declaration . . . . . . . . . . . . . . . . 429

C Extended notes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 431
   C.1    Section 4 notes    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 431
          C.1.1     Intrinsic and derived types (4.4, 4.5)     . . . . . . . . . . . . . . . . . . . . . . . . 431
          C.1.2     Selection of the approximation methods (4.4.2)         . . . . . . . . . . . . . . . . . . 432
          C.1.3     Extensible types (4.5.3) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 432
          C.1.4     Pointers (4.5.1) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433
          C.1.5     Structure constructors and generic names . . . . . . . . . . . . . . . . . . . . . . 434
          C.1.6     Final subroutines (4.5.1.7, 4.5.10, 4.5.10.1, 4.5.10.2) . . . . . . . . . . . . . . . . 436
   C.2    Section 5 notes    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 438
          C.2.1     The POINTER attribute (5.1.2.11) . . . . . . . . . . . . . . . . . . . . . . . . . 438
          C.2.2     The TARGET attribute (5.1.2.14) . . . . . . . . . . . . . . . . . . . . . . . . . . 439
          C.2.3     The VOLATILE attribute (5.1.2.16) . . . . . . . . . . . . . . . . . . . . . . . . . 439
   C.3    Section 6 notes    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 440
          C.3.1     Structure components (6.1.2) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 440
          C.3.2     Allocation with dynamic type (6.3.1) . . . . . . . . . . . . . . . . . . . . . . . . 442
          C.3.3     Pointer allocation and association . . . . . . . . . . . . . . . . . . . . . . . . . . 442
   C.4    Section 7 notes    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443
          C.4.1     Character assignment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443
          C.4.2     Evaluation of function references     . . . . . . . . . . . . . . . . . . . . . . . . . . 443
          C.4.3     Pointers in expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444
          C.4.4     Pointers on the left side of an assignment . . . . . . . . . . . . . . . . . . . . . . 444
          C.4.5     An example of a FORALL construct containing a WHERE construct . . . . . . 445
          C.4.6     Examples of FORALL statements . . . . . . . . . . . . . . . . . . . . . . . . . . 446
   C.5    Section 8 notes    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446
          C.5.1     Loop control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446
          C.5.2     The CASE construct . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446
          C.5.3     Examples of DO constructs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446
          C.5.4     Examples of invalid DO constructs         . . . . . . . . . . . . . . . . . . . . . . . . . 449
   C.6    Section 9 notes    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 450
          C.6.1     External files (9.2)    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 450
          C.6.2     Nonadvancing input/output (9.2.3.1) . . . . . . . . . . . . . . . . . . . . . . . . 451
          C.6.3     Asynchronous input/output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 452
          C.6.4     OPEN statement (9.4.5) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453
          C.6.5     Connection properties (9.4.3) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454
          C.6.6     CLOSE statement (9.4.6) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455
   C.7    Section 10 notes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455
          C.7.1     Number of records (10.3, 10.4, 10.7.2) . . . . . . . . . . . . . . . . . . . . . . . . 455
          C.7.2     List-directed input (10.9.1) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456




viii                                 WORKING DRAFT                                                   SEP 2002


SEP 2002                                 WORKING DRAFT                                          J3/02-007R3



   C.8     Section 11 notes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 457
           C.8.1     Main program and block data program unit (11.1, 11.3)           . . . . . . . . . . . . . 457
           C.8.2     Dependent compilation (11.2) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 457
           C.8.3     Examples of the use of modules . . . . . . . . . . . . . . . . . . . . . . . . . . . 459
   C.9     Section 12 notes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 465
           C.9.1     Portability problems with external procedures (12.3.2.2) . . . . . . . . . . . . . 465
           C.9.2     Procedures defined by means other than Fortran (12.5.3) . . . . . . . . . . . . . 466
           C.9.3     Procedure interfaces (12.3) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 466
           C.9.4     Argument association and evaluation (12.4.1.2)        . . . . . . . . . . . . . . . . . . 466
           C.9.5     Pointers and targets as arguments (12.4.1.2) . . . . . . . . . . . . . . . . . . . . 467
           C.9.6     Polymorphic Argument Association (12.4.1.3) . . . . . . . . . . . . . . . . . . . 469
           C.9.7     Generic resolution and dynamic dispatch (12.4.4) . . . . . . . . . . . . . . . . . 470
   C.10 Section 15 notes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 470
           C.10.1    Runtime environments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 470
           C.10.2    Examples of Interoperation between Fortran and C Functions . . . . . . . . . . 470
   C.11 Section 16 notes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 476
           C.11.1    Examples of host association (16.4.1.3) . . . . . . . . . . . . . . . . . . . . . . . 476
           C.11.2    Rules ensuring unambiguous generics (16.2.3) . . . . . . . . . . . . . . . . . . . 477
   C.12 Array feature notes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 482
           C.12.1    Summary of features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 482
           C.12.2    Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 483
           C.12.3    FORmula TRANslation and array processing            . . . . . . . . . . . . . . . . . . . 488
           C.12.4    Sum of squared residuals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 489
           C.12.5    Vector norms: infinity-norm and one-norm . . . . . . . . . . . . . . . . . . . . . 489
           C.12.6    Matrix norms: infinity-norm and one-norm . . . . . . . . . . . . . . . . . . . . . 489
           C.12.7    Logical queries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 489
           C.12.8    Parallel computations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 490
           C.12.9    Example of element-by-element computation . . . . . . . . . . . . . . . . . . . . 490
           C.12.10 Bit manipulation and inquiry procedures . . . . . . . . . . . . . . . . . . . . . . 490

D Index of syntax rules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493

E Index     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 533





SEP 2002                                         WORKING DRAFT                                                  ix


J3/02-007R3       WORKING DRAFT    SEP 2002





x              WORKING DRAFT       SEP 2002


SEP 2002                              WORKING DRAFT                                         J3/02-007R3





List of Tables

  2.1    Requirements on statement ordering . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

  2.2    Statements allowed in scoping units          . . . . . . . . . . . . . . . . . . . . . . . . . . . 14


  3.1    Special characters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24


  6.1    Subscript order value . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106


  7.1    Type of operands and results for intrinsic operators . . . . . . . . . . . . . . . . . 121

  7.2    Interpretation of the numeric intrinsic operators . . . . . . . . . . . . . . . . . . . 133

  7.3    Interpretation of the character intrinsic operator // . . . . . . . . . . . . . . . . . 134

  7.4    Interpretation of the relational intrinsic operators . . . . . . . . . . . . . . . . . . 135

  7.5    Interpretation of the logical intrinsic operators . . . . . . . . . . . . . . . . . . . . 136

  7.6    The values of operations involving logical intrinsic operators . . . . . . . . . . . . 136

  7.7    Categories of operations and relative precedence . . . . . . . . . . . . . . . . . . . 136

  7.8    Type conformance for the intrinsic assignment statement . . . . . . . . . . . . . . 139

  7.9    Numeric conversion and the assignment statement . . . . . . . . . . . . . . . . . . 140


  13.1 Characteristics of the result of NULL ( ) . . . . . . . . . . . . . . . . . . . . . . . . 335


  15.1 Names of C characters with special semantics . . . . . . . . . . . . . . . . . . . . . 382

  15.2 Interoperability between Fortran and C types . . . . . . . . . . . . . . . . . . . . . 385





SEP 2002                                      WORKING DRAFT                                                xi


J3/02-007R3                              WORKING DRAFT                                    SEP 2002


Foreword

ISO (the International Organization for Standardization) and IEC (the International Electrotechni-
cal Commission) form the specialized system for worldwide standardization. National bodies that are
members of ISO or IEC participate in the development of International Standards through technical
committees established by the respective organization to deal with particular fields of technical activ-
ity. ISO and IEC technical committees collaborate in fields of mutual interest. Other international
organizations, governmental and nongovernmental, in liaison with ISO and IEC, also take part in the
work.

In the field of information technology, ISO and IEC have established a joint technical committee,
ISO/IEC JTC 1. Draft International Standards adopted by the joint technical committee are circu-
lated to national bodies for voting. Publication of an International Standard requires approval by at
least 75% of the national bodies casting a vote.

International Standard ISO/IEC 1539-1 was prepared by Joint Technical Committee ISO/IEC/JTC1,
Information technology, Subcommittee SC22, Programming languages, their environments and system
software interfaces.

This fourth edition cancels and replaces the third edition (ISO/IEC 1539-1:1997), which has been tech-
nically revised.

ISO/IEC 1539 consists of the following parts, under the general title Information technology -- Pro-
gramming languages -- Fortran:

-- Part 1: Base language

-- Part 2: Varying length character strings

-- Part 3: Conditional Compilation

The annexes of this part of ISO/IEC 1539 are for information only.





xii                               WORKING DRAFT                                           SEP 2002


SEP 2002                                  WORKING DRAFT                                    J3/02-007R3


Introduction

Standard programming language Fortran

This part of the international standard comprises the specification of the base Fortran language, infor-
mally known as Fortran 2000. With the limitations noted in 1.6.2, the syntax and semantics of Fortran
95 are contained entirely within Fortran 2000. Therefore, any standard-conforming Fortran 95 program
not affected by such limitations is a standard conforming Fortran 2000 program. New features of Fortran
2000 can be compatibly incorporated into such Fortran 95 programs, with any exceptions indicated in
the text of this part of the standard.

Fortran 2000 contains several extensions to Fortran 95; among them are:

      (1)     Derived-type enhancements: parameterized derived types (allows the kind, length, or shape
              of a derived type's components to be chosen when the derived type is used), mixed compo-
              nent accessibility (allows different components to have different accessibility), public entities
              of private type, improved structure constructors, and finalizers.

      (2)     Object oriented programming support: enhanced data abstraction (allows one type to ex-
              tend the definition of another type), polymorphism (allows the type of a variable to vary
              at runtime), dynamic type allocation, SELECT TYPE construct (allows a choice of execu-
              tion flow depending upon the type a polymorphic object currently has), and type-bound
              procedures.

      (3)     The ASSOCIATE construct (allows a complex expression or object to be denoted by a
              simple symbol).

      (4)     Data manipulation enhancements: allocatable components, deferred type parameters, VOL-
              ATILE attribute, explicit type specification in array constructors, INTENT specification of
              pointer arguments, specified lower bounds of pointer assignment and pointer rank remap-
              ping, extended initialization expressions, MAX and MIN intrinsics for character type, and
              enhanced complex constants.

      (5)     Input/output enhancements: asynchronous transfer operations (allows a program to con-
              tinue to process data while an input/output transfer occurs), stream access (allows access to
              a file without reference to any record structure), user specified transfer operations for derived
              types, user specified control of rounding during format conversions, the FLUSH statement,
              named constants for preconnected units, regularization of input/output keywords, and ac-
              cess to input/output error messages.

      (6)     Procedure pointers.

      (7)     Scoping enhancements: the ability to rename defined operators (supports greater data ab-
              straction) and control of host association into interface bodies.

      (8)     Support for IEC 60559 (IEEE 754) exceptions and arithmetic (to the extent a processor's
              arithmetic supports the IEC standard).

      (9)     Interoperability with the C programming language (allows portable access to many libraries
              and the low-level facilities provided by C and allows the portable use of Fortran libraries by
              programs written in C).

      (10)    Support for international usage: (ISO 10646) and choice of decimal or comma in numeric
              formatted input/output.

      (11)    Enhanced integration with the host operating system: access to command line arguments
              and environment variables, and access to the processor's error messages (improves the ability
              to handle exceptional conditions).





SEP 2002                                      WORKING DRAFT                                              xiii


J3/02-007R3                                WORKING DRAFT                                 SEP 2002


Organization of this part of ISO/IEC 1539

This part of ISO/IEC 1539 is organized in 16 sections, dealing with 8 conceptual areas. These 8 areas,
and the sections in which they are treated, are:




                         High/low level concepts          Sections 1, 2, 3
                         Data concepts                    Sections 4, 5, 6
                         Computations                     Sections 7, 13, 14
                         Execution control                Section 8
                         Input/output                     Sections 9, 10
                         Program units                    Sections 11, 12
                         Interoperability with C          Section 15
                         Scoping and association rules    Section 16


It also contains the following nonnormative material:




                         Glossary                         Annex A
                         Decremental features             Annex B
                         Extended notes                   Annex C
                         Index of syntax rules            Annex D
                         Index                            Annex E





xiv                                  WORKING DRAFT                                       SEP 2002


      SEP 2002                              WORKING DRAFT                                    J3/02-007R3





 1    Information technology -- Programming languages --
 2    Fortran --

 3    Part 1:
 4    Base Language

 5    Section 1: Overview

 6    1.1      Scope

 7    ISO/IEC 1539 is a multipart International Standard; the parts are published separately. This publi-
 8    cation, ISO/IEC 1539-1, which is the first part, specifies the form and establishes the interpretation
 9    of programs expressed in the base Fortran language. The purpose of this part of ISO/IEC 1539 is to
10    promote portability, reliability, maintainability, and efficient execution of Fortran programs for use on
11    a variety of computing systems. The second part, ISO/IEC 1539-2, defines additional facilities for the
12    manipulation of character strings of variable length. The third part, ISO/IEC 1539-3, defines a stan-
13    dard conditional compilation facility for Fortran. A processor conforming to part 1 need not conform to
14    ISO/IEC 1539-2 or ISO/IEC 1539-3; however, conformance to either assumes conformance to this part.
15    Throughout this publication, the term "this standard" refers to ISO/IEC 1539-1.


16    1.2      Processor

17    The combination of a computing system and the mechanism by which programs are transformed for use
18    on that computing system is called a processor in this standard.


19    1.3      Inclusions

20    This standard specifies

21           (1)    The forms that a program written in the Fortran language may take,

22           (2)    The rules for interpreting the meaning of a program and its data,

23           (3)    The form of the input data to be processed by such a program, and

24           (4)    The form of the output data resulting from the use of such a program.


25    1.4      Exclusions

26    This standard does not specify

27           (1)    The mechanism by which programs are transformed for use on computing systems,

28           (2)    The operations required for setup and control of the use of programs on computing systems,

29           (3)    The method of transcription of programs or their input or output data to or from a storage
30                  medium,

31           (4)    The program and processor behavior when this standard fails to establish an interpretation
32                  except for the processor detection and reporting requirements in items (2) through (8) of



      SEP 2002                                     WORKING DRAFT                                            1


      J3/02-007R3                                 WORKING DRAFT                                      SEP 2002



 1                  1.5,

 2           (5)    The size or complexity of a program and its data that will exceed the capacity of any
 3                  particular computing system or the capability of a particular processor,

 4           (6)    The physical properties of the representation of quantities and the method of rounding,
 5                  approximating, or computing numeric values on a particular processor,

 6           (7)    The physical properties of input/output records, files, and units, or

 7           (8)    The physical properties and implementation of storage.


 8    1.5      Conformance

 9    A program (2.2.1) is a standard-conforming program if it uses only those forms and relationships
10    described herein and if the program has an interpretation according to this standard. A program unit
11    (2.2) conforms to this standard if it can be included in a program in a manner that allows the program
12    to be standard conforming.

13    A processor conforms to this standard if

14           (1)    It executes any standard-conforming program in a manner that fulfills the interpretations
15                  herein, subject to any limits that the processor may impose on the size and complexity of
16                  the program;

17           (2)    It contains the capability to detect and report the use within a submitted program unit of
18                  a form designated herein as obsolescent, insofar as such use can be detected by reference to
19                  the numbered syntax rules and constraints;

20           (3)    It contains the capability to detect and report the use within a submitted program unit of
21                  an additional form or relationship that is not permitted by the numbered syntax rules or
22                  constraints, including the deleted features described in Annex B;

23           (4)    It contains the capability to detect and report the use within a submitted program unit of
24                  kind type parameter values (4.4) not supported by the processor;

25           (5)    It contains the capability to detect and report the use within a submitted program unit of
26                  source form or characters not permitted by Section 3;

27           (6)    It contains the capability to detect and report the use within a submitted program of name
28                  usage not consistent with the scope rules for names, labels, operators, and assignment
29                  symbols in Section 16;

30           (7)    It contains the capability to detect and report the use within a submitted program unit of
31                  intrinsic procedures whose names are not defined in Section 13; and

32           (8)    It contains the capability to detect and report the reason for rejecting a submitted program.

33    However, in a format specification that is not part of a FORMAT statement (10.1.1), a processor need not
34    detect or report the use of deleted or obsolescent features, or the use of additional forms or relationships.

35    A standard-conforming processor may allow additional forms and relationships provided that such ad-
36    ditions do not conflict with the standard forms and relationships. However, a standard-conforming
37    processor may allow additional intrinsic procedures even though this could cause a conflict with the
38    name of a procedure in a standard-conforming program. If such a conflict occurs and involves the name
39    of an external procedure, the processor is permitted to use the intrinsic procedure unless the name is
40    given the EXTERNAL attribute (5.1.2.6) in the scoping unit (16). A standard-conforming program
41    shall not use nonstandard intrinsic procedures or modules that have been added by the processor.

42    Because a standard-conforming program may place demands on a processor that are not within the
43    scope of this standard or may include standard items that are not portable, such as external procedures
44    defined by means other than Fortran, conformance to this standard does not ensure that a program will
45    execute consistently on all or any standard-conforming processors.




      2                                  WORKING DRAFT                                               SEP 2002


      SEP 2002                                 WORKING DRAFT                                   J3/02-007R3



 1    In some cases, this standard allows the provision of facilities that are not completely specified in the
 2    standard. These facilities are identified as processor dependent. They shall be provided, with methods
 3    or semantics determined by the processor.

             NOTE 1.1

             The processor should be accompanied by documentation that specifies the limits it imposes on the
             size and complexity of a program and the means of reporting when these limits are exceeded, that
             defines the additional forms and relationships it allows, and that defines the means of reporting
             the use of additional forms and relationships and the use of deleted or obsolescent forms. In this
             context, the use of a deleted form is the use of an additional form.

             The processor should be accompanied by documentation that specifies the methods or semantics
             of processor-dependent facilities.



 4    1.6       Compatibility

 5    Each standard since ISO 1539:1980 (informally referred to as Fortran 77), defines more intrinsic
 6    procedures than the previous one. Therefore, a Fortran program conforming to an older standard may
 7    have a different interpretation under a newer standard if it invokes an external procedure having the
 8    same name as one of the new standard intrinsic procedures, unless that procedure is specified to have
 9    the EXTERNAL attribute.


10    1.6.1          Fortran 95 compatibility

11    Except as identified in this section, this standard is an upward compatible extension to the preceding
12    Fortran International Standard, ISO/IEC 1539:1997 (Fortran 95). Any standard-conforming Fortran 95
13    program remains standard-conforming under this standard. The following Fortran 95 features may have
14    different interpretations in this standard:

15            (1)      Earlier Fortran standards had the concept of printing, meaning that column one of format-
16                     ted output had special meaning for a processor-dependent (possibly empty) set of logical
17                     units. This could be neither detected nor specified by a standard-specified means. The
18                     interpretation of the first column is not specified by this standard.

19            (2)      This standard specifies a different output format for real zero values in list-directed and
20                     namelist output.


21    1.6.2          Fortran 90 compatibility

22    Except for the deleted features noted in Annex B.1, and except as identified in this section, this stan-
23    dard is an upward compatible extension to ISO/IEC 1539:1991 (Fortran 90). Any standard-conforming
24    Fortran 90 program that does not use one of the deleted features remains standard-conforming under
25    this standard.

26    The PAD= specifier in the INQUIRE statement in this standard returns the value UNDEFINED if there
27    is no connection or the connection is for unformatted input/output. Fortran 90 specified YES.

28    Fortran 90 specified that if the second argument to MOD or MODULO was zero, the result was processor
29    dependent. This standard specifies that the second argument shall not be zero.


30    1.6.3          FORTRAN 77 compatibility

31    Except for the deleted features noted in Annex B.1, and except as identified in this section, this standard
32    is an upward compatible extension to ISO 1539:1980 (Fortran 77). Any standard-conforming For-
33    tran 77 program that does not use one of the deleted features noted in Annex B.1 and that does not



      SEP 2002                                         WORKING DRAFT                                          3


      J3/02-007R3                                  WORKING DRAFT                                      SEP 2002



 1    depend on the differences specified here remains standard conforming under this standard. This stan-
 2    dard restricts the behavior for some features that were processor dependent in Fortran 77. Therefore,
 3    a standard-conforming Fortran 77 program that uses one of these processor-dependent features may
 4    have a different interpretation under this standard, yet remain a standard-conforming program. The
 5    following Fortran 77 features may have different interpretations in this standard:

 6           (1)      Fortran 77 permitted a processor to supply more precision derived from a real constant
 7                    than can be represented in a real datum when the constant is used to initialize a data
 8                    object of type double precision real in a DATA statement. This standard does not permit
 9                    a processor this option.

10           (2)      If a named variable that was not in a common block was initialized in a DATA statement and
11                    did not have the SAVE attribute specified, Fortran 77 left its SAVE attribute processor
12                    dependent. This standard specifies (5.2.5) that this named variable has the SAVE attribute.

13           (3)      Fortran 77 specified that the number of characters required by the input list was to be
14                    less than or equal to the number of characters in the record during formatted input. This
15                    standard specifies (9.5.3.4.2) that the input record is logically padded with blanks if there
16                    are not enough characters in the record, unless the PAD= specifier with the value 'NO' is
17                    specified in an appropriate OPEN or READ statement.

18           (4)      A value of 0 for a list item in a formatted output statement will be formatted in a differ-
19                    ent form for some G edit descriptors. In addition, this standard specifies how rounding of
20                    values will affect the output field form, but Fortran 77 did not address this issue. There-
21                    fore, some Fortran 77 processors may produce an output form different from the output
22                    form produced by Fortran 2000 processors for certain combinations of values and G edit
23                    descriptors.

24           (5)      If the processor can distinguish between positive and negative real zero, the behavior of the
25                    SIGN intrinsic function when the second argument is negative real zero is changed by this
26                    standard.


27    1.7      Notation used in this standard

28    In this standard, "shall" is to be interpreted as a requirement; conversely, "shall not" is to be interpreted
29    as a prohibition. Except where stated otherwise, such requirements and prohibitions apply to programs
30    rather than processors.


31    1.7.1         Informative notes

32    Informative notes of explanation, rationale, examples, and other material are interspersed with the
33    normative body of this publication. The informative material is nonnormative; it is identified by being
34    in shaded, framed boxes that have numbered headings beginning with "NOTE."


35    1.7.2         Syntax rules

36    Syntax rules describe the forms that Fortran lexical tokens, statements, and constructs may take. These
37    syntax rules are expressed in a variation of Backus-Naur form (BNF) in which:

38           (1)      Characters from the Fortran character set (3.1) are interpreted literally as shown, except
39                    where otherwise noted.

40           (2)      Lower-case italicized letters and words (often hyphenated and abbreviated) represent gen-
41                    eral syntactic classes for which particular syntactic entities shall be substituted in actual
42                    statements.





      4                                    WORKING DRAFT                                              SEP 2002


      SEP 2002                                              WORKING DRAFT                                  J3/02-007R3



 1                       Common abbreviations used in syntactic terms are:


                                         arg         for     argument        attr     for    attribute
                                         decl        for     declaration     def      for    definition
                                         desc        for     descriptor      expr     for    expression
                                         int         for     integer         op       for    operator
                                         spec        for     specifier        stmt     for    statement


 2          (3)          The syntactic metasymbols used are:


                                          is           introduces a syntactic class definition
                                          or           introduces a syntactic class alternative
                                          [ ]          encloses an optional item
                                          [ ] ...      encloses an optionally repeated item
                                                            that may occur zero or more times
                                                       continues a syntax rule


 3          (4)          Each syntax rule is given a unique identifying number of the form Rsnn, where s is a one-
 4                       or two-digit section number and nn is a two-digit sequence number within that section.
 5                       The syntax rules are distributed as appropriate throughout the text, and are referenced by
 6                       number as needed. Some rules in Sections 2 and 3 are more fully described in later sections;
 7                       in such cases, the section number s is the number of the later section where the rule is
 8                       repeated.

 9          (5)          The syntax rules are not a complete and accurate syntax description of Fortran, and cannot
10                       be used to generate a Fortran parser automatically; where a syntax rule is incomplete, it is
11                       restricted by corresponding constraints and text.

           NOTE 1.2

           An example of the use of the syntax rules is:

                         digit-string                          is    digit [ digit ] ...

           The following are examples of forms for a digit string allowed by the above rule:


                    digit
                    digit digit
                    digit digit digit digit
                    digit digit digit digit digit digit digit digit


           If particular entities are substituted for digit , actual digit strings might be:


                    4
                    67
                    1999
                    10243852



12    1.7.3        Constraints

13    Each constraint is given a unique identifying number of the form Csnn, where s is a one- or two-digit
14    section number and nn is a two-digit sequence number within that section.

15    Often a constraint is associated with a particular syntax rule. Where that is the case, the constraint is
16    annotated with the syntax rule number in parentheses. A constraint that is associated with a syntax
17    rule constitutes part of the definition of the syntax term defined by the rule. It thus applies in all places



      SEP 2002                                                       WORKING DRAFT                                  5


      J3/02-007R3                                        WORKING DRAFT                                 SEP 2002



 1    where the syntax term appears.

 2    Some constraints are not associated with particular syntax rules. The effect of such a constraint is similar
 3    to that of a restriction stated in the text, except that a processor is required to have the capability to
 4    detect and report violations of constraints (1.5). In some cases, a broad requirement is stated in text
 5    and a subset of the same requirement is also stated as a constraint. This indicates that a standard-
 6    conforming program is required to adhere to the broad requirement, but that a standard-conforming
 7    processor is required only to have the capability of diagnosing violations of the constraint.


 8    1.7.4          Assumed syntax rules

 9    In order to minimize the number of additional syntax rules and convey appropriate constraint informa-
10    tion, the following rules are assumed; an explicit syntax rule for a term overrides an assumed rule. The
11    letters "xyz " stand for any syntactic class phrase:

12    R101       xyz-list                          is    xyz [ , xyz ] ...
13    R102       xyz-name                          is    name
14    R103       scalar-xyz                        is    xyz

15    C101       (R103) scalar-xyz shall be scalar.


16    1.7.5          Syntax conventions and characteristics
17            (1)      Any syntactic class name ending in "-stmt " follows the source form statement rules: it shall
18                     be delimited by end-of-line or semicolon, and may be labeled unless it forms part of another
19                     statement (such as an IF or WHERE statement). Conversely, everything considered to be
20                     a source form statement is given a "-stmt " ending in the syntax rules.

21            (2)      The rules on statement ordering are described rigorously in the definition of program-unit
22                     (R202). Expression hierarchy is described rigorously in the definition of expr (R722).

23            (3)      The suffix "-spec" is used consistently for specifiers, such as input/output statement speci-
24                     fiers. It also is used for type declaration attribute specifications (for example, "array-spec"
25                     in R515), and in a few other cases.

26            (4)      Where reference is made to a type parameter, including the surrounding parentheses, the
27                     suffix "-selector " is used. See, for example, "kind-selector " (R507) and "length-selector "
28                     (R511).

29            (5)      The term "subscript " (for example, R618, R619, and R620) is used consistently in array
30                     definitions.


31    1.7.6          Text conventions

32    In the descriptive text, an equivalent English word is frequently used in place of a syntactic term.
33    Particular statements and attributes are identified in the text by an upper-case keyword, e.g., "END
34    statement". Boldface words are used in the text where they are first defined with a specialized meaning.
35    The descriptions of obsolescent features appear in a smaller type size.

             NOTE 1.3

             This sentence is an example of the type size used for obsolescent features.



36    1.8       Deleted and obsolescent features

37    This standard protects the users' investment in existing software by including all but five of the language
38    elements of Fortran 90 that are not processor dependent. This standard identifies two categories of
39    outmoded features. There are five in the first category, deleted features, which consists of features
40    considered to have been redundant in Fortran 77 and largely unused in Fortran 90. Those in the second


      6                                        WORKING DRAFT                                           SEP 2002


      SEP 2002                                   WORKING DRAFT                                      J3/02-007R3



 1    category, obsolescent features, are considered to have been redundant in Fortran 90 and Fortran 95,
 2    but are still frequently used.


 3    1.8.1         Nature of deleted features
 4           (1)      Better methods existed in Fortran 77.
 5           (2)      These features are not included in Fortran 95 or this revision of Fortran.


 6    1.8.2         Nature of obsolescent features
 7           (1)      Better methods existed in Fortran 90 and Fortran 95.

 8           (2)      It is recommended that programmers use these better methods in new programs and convert
 9                    existing code to these methods.

10           (3)      These features are identified in the text of this document by a distinguishing type font
11                    (1.7.6).

12           (4)      If the use of these features becomes insignificant, future Fortran standards committees should
13                    consider deleting them.

14           (5)      The next Fortran standards committee should consider for deletion only those language
15                    features that appear in the list of obsolescent features.

16           (6)      Processors supporting the Fortran language should support these features as long as they
17                    continue to be used widely in Fortran programs.


18    1.9      Normative references

19    The following standards contain provisions which, through reference in this standard, constitute provi-
20    sions of this standard. At the time of publication, the editions indicated were valid. All standards are
21    subject to revision, and parties to agreements based on this standard are encouraged to investigate the
22    possibility of applying the most recent editions of the standards indicated below. Members of IEC and
23    ISO maintain registers of currently valid International Standards.

24    ISO/IEC 646:1991, Information technology--ISO 7-bit coded character set for information interchange.
25    ISO/IEC 646:1991 (International Reference Version) is the international equivalent of ANSI X3.4-1986,
26    commonly known as ASCII. This standard refers to it as the ASCII standard.

27    ISO 8601:1988, Data elements and interchange formats--Information interchange--
28    Representation of dates and times.

29    ISO/IEC 9989:1999, Information technology--Programming languages--C.
30    This standard refers to ISO/IEC 9899:1999 as the C standard.

31    ISO/IEC 10646-1:2000, Information technology--Universal multiple-octet coded character set (UCS)--
32    Part 1: Architecture and basic multilingual plane.

33    IEC 60559 (1989-01), Binary floating-point arithmetic for microprocessor systems.
34    Since IEC 60559 (1989-01) was originally IEEE 754-1985, Standard for binary floating-point arithmetic,
35    and is widely known by this name, this standard refers to it as the IEEE standard.





      SEP 2002                                           WORKING DRAFT                                           7


J3/02-007R3       WORKING DRAFT    SEP 2002





8              WORKING DRAFT       SEP 2002


      SEP 2002                              WORKING DRAFT                                      J3/02-007R3





 1    Section 2: Fortran terms and concepts

 2    2.1       High level syntax

 3    This section introduces the terms associated with program units and other Fortran concepts above the
 4    construct, statement, and expression levels and illustrates their relationships. The notation used in this
 5    standard is described in 1.7.

             NOTE 2.1

             Constraints and other information related to the rules that do not begin with R2 appear in the
             appropriate section.


 6    R201      program                     is    program-unit
 7                                                    [ program-unit ] ...

 8    A program shall contain exactly one main-program program-unit or a main program defined by means
 9    other than Fortran, but not both.

10    R202      program-unit                is    main-program
11                                          or external-subprogram
12                                          or module
13                                          or block-data
14    R1101 main-program                    is    [ program-stmt ]
15                                                    [ specification-part ]
16                                                    [ execution-part ]
17                                                    [ internal-subprogram-part ]
18                                                    end-program-stmt
19    R203      external-subprogram         is    function-subprogram
20                                          or subroutine-subprogram
21    R1223 function-subprogram             is    function-stmt
22                                                    [ specification-part ]
23                                                    [ execution-part ]
24                                                    [ internal-subprogram-part ]
25                                                    end-function-stmt
26    R1230 subroutine-subprogram           is    subroutine-stmt
27                                                    [ specification-part ]
28                                                    [ execution-part ]
29                                                    [ internal-subprogram-part ]
30                                                    end-subroutine-stmt
31    R1104 module                          is    module-stmt
32                                                    [ specification-part ]
33                                                    [ module-subprogram-part ]
34                                                    end-module-stmt
35    R1116 block-data                      is    block-data-stmt
36                                                    [ specification-part ]
37                                                    end-block-data-stmt
38    R204      specification-part           is    [ use-stmt ] ...
39                                                    [ import-stmt ] ...
40                                                    [ implicit-part ]
41                                                    [ declaration-construct ] ...



      SEP 2002                                       WORKING DRAFT                                            9


      J3/02-007R3                                WORKING DRAFT                           SEP 2002



 1    R205    implicit-part                is    [ implicit-part-stmt ] ...
 2                                                   implicit-stmt
 3    R206    implicit-part-stmt           is    implicit-stmt
 4                                         or parameter-stmt
 5                                         or format-stmt
 6                                         or entry-stmt
 7    R207    declaration-construct        is    derived-type-def
 8                                         or entry-stmt
 9                                         or enum-alias-def
10                                         or format-stmt
11                                         or interface-block
12                                         or parameter-stmt
13                                         or procedure-declaration-stmt
14                                         or specification-stmt
15                                         or type-alias-stmt
16                                         or type-declaration-stmt
17                                         or stmt-function-stmt
18    R208    execution-part               is    executable-construct
19                                                   [ execution-part-construct ] ...
20    R209    execution-part-construct     is    executable-construct
21                                         or format-stmt
22                                         or entry-stmt
23                                         or data-stmt
24    R210    internal-subprogram-part     is    contains-stmt
25                                                   internal-subprogram
26                                                   [ internal-subprogram ] ...
27    R211    internal-subprogram          is    function-subprogram
28                                         or subroutine-subprogram
29    R1107 module-subprogram-part         is    contains-stmt
30                                                   module-subprogram
31                                                   [ module-subprogram ] ...
32    R1108 module-subprogram              is    function-subprogram
33                                         or subroutine-subprogram
34    R212    specification-stmt            is    access-stmt
35                                         or allocatable-stmt
36                                         or asynchronous-stmt
37                                         or bind-stmt
38                                         or common-stmt
39                                         or data-stmt
40                                         or dimension-stmt
41                                         or equivalence-stmt
42                                         or external-stmt
43                                         or intent-stmt
44                                         or intrinsic-stmt
45                                         or namelist-stmt
46                                         or optional-stmt
47                                         or pointer-stmt
48                                         or protected-stmt
49                                         or save-stmt
50                                         or target-stmt
51                                         or volatile-stmt
52                                         or value-stmt
53    R213    executable-construct         is    action-stmt
54                                         or associate-construct



      10                                  WORKING DRAFT                                  SEP 2002


      SEP 2002                            WORKING DRAFT                                      J3/02-007R3



 1                                        or case-construct
 2                                        or do-construct
 3                                        or forall-construct
 4                                        or if-construct
 5                                        or select-type-construct
 6                                        or where-construct
 7    R214    action-stmt                 is    allocate-stmt
 8                                        or assignment-stmt
 9                                        or backspace-stmt
10                                        or call-stmt
11                                        or close-stmt
12                                        or continue-stmt
13                                        or cycle-stmt
14                                        or deallocate-stmt
15                                        or endfile-stmt
16                                        or end-function-stmt
17                                        or end-program-stmt
18                                        or end-subroutine-stmt
19                                        or exit-stmt
20                                        or flush-stmt
21                                        or forall-stmt
22                                        or goto-stmt
23                                        or if-stmt
24                                        or inquire-stmt
25                                        or nullify-stmt
26                                        or open-stmt
27                                        or pointer-assignment-stmt
28                                        or print-stmt
29                                        or read-stmt
30                                        or return-stmt
31                                        or rewind-stmt
32                                        or stop-stmt
33                                        or wait-stmt
34                                        or where-stmt
35                                        or write-stmt
36                                        or arithmetic-if-stmt
37                                        or computed-goto-stmt

38    C201    (R208) An execution-part shall not contain an end-function-stmt , end-program-stmt , or end-
39            subroutine-stmt .


40    2.2     Program unit concepts

41    Program units are the fundamental components of a Fortran program.        A program unit may be
42    a main program, an external subprogram, a module, or a block data program unit. A subprogram
43    may be a function subprogram or a subroutine subprogram. A module contains definitions that are
44    to be made accessible to other program units. A block data program unit is used to specify initial
45    values for data objects in named common blocks. Each type of program unit is described in Section
46    11 or 12. An external subprogram is a subprogram that is not in a main program, a module, or
47    another subprogram. An internal subprogram is a subprogram that is in a main program or another
48    subprogram. A module subprogram is a subprogram that is in a module but is not an internal
49    subprogram.

50    A program unit consists of a set of nonoverlapping scoping units. A scoping unit is



      SEP 2002                                    WORKING DRAFT                                        11


      J3/02-007R3                                   WORKING DRAFT                                    SEP 2002



 1           (1)       A program unit or subprogram, excluding any scoping units in it,

 2           (2)       A derived-type definition (4.5.1), or

 3           (3)       An interface body, excluding any scoping units in it.

 4    A scoping unit that immediately surrounds another scoping unit is called the host scoping unit (often
 5    abbreviated to host).


 6    2.2.1         Program

 7    A program consists of exactly one main program, any number (including zero) of other kinds of program
 8    units, and any number (including zero) of external procedures and other entities defined by means other
 9    than Fortran.

            NOTE 2.2

            There is a restriction that there shall be no more than one unnamed block data program unit
            (11.3).

            This standard places no ordering requirement on the program units that constitute a program, but
            since the public portions of a module are required to be available by the time a module reference
            (11.2.1) is processed, a processor may require a particular order of processing of the program units.


10    2.2.2         Main program

11    The Fortran main program is described in 11.1.


12    2.2.3         Procedure

13    A procedure encapsulates an arbitrary sequence of actions that may be invoked directly during program
14    execution. Procedures are either functions or subroutines. A function is a procedure that is invoked
15    in an expression; its invocation causes a value to be computed which is then used in evaluating the
16    expression. The variable that returns the value of a function is called the result variable. A subroutine
17    is a procedure that is invoked in a CALL statement, by a defined assignment statement, or by some
18    operations on derived-type entities. Unless it is a pure procedure, a subroutine may be used to change
19    the program state by changing the values of any of the data objects accessible to the subroutine; unless
20    it is a pure procedure, a function may do this in addition to computing the function value.

21    Procedures are described further in Section 12.


22    2.2.3.1       External procedure

23    An external procedure is a procedure that is defined by an external subprogram or by means other
24    than Fortran. An external procedure may be invoked by the main program or by any procedure of a
25    program.


26    2.2.3.2       Module procedure

27    A module procedure is a procedure that is defined by a module subprogram (R1108). A module
28    procedure may be invoked by another module subprogram in the module or by any scoping unit that
29    accesses the module procedure by use association (11.2.2). The module containing the subprogram is
30    the host scoping unit of the module procedure.


31    2.2.3.3       Internal procedure

32    An internal procedure is a procedure that is defined by an internal subprogram (R211). The containing
33    main program or subprogram is the host scoping unit of the internal procedure. An internal procedure



      12                                     WORKING DRAFT                                           SEP 2002


      SEP 2002                               WORKING DRAFT                                      J3/02-007R3



 1    is local to its host in the sense that the internal procedure is accessible within the host scoping unit and
 2    all its other internal procedures but is not accessible elsewhere.


 3    2.2.3.4       Interface block

 4    An interface body describes an abstract interface or the interface of a dummy procedure, external
 5    procedure, procedure pointer, or type-bound procedure.

 6    An interface block is a specific interface block, an abstract interface block, or a generic interface block.
 7    A specific interface block is a collection of interface bodies. A generic interface block may also be used
 8    to specify that procedures may be invoked

 9           (1)      By using a generic name,

10           (2)      By using a defined operator,

11           (3)      By using a defined assignment, or

12           (4)      For derived-type input/output.


13    2.2.4         Module

14    A module contains (or accesses from other modules) definitions that are to be made accessible to other
15    program units. These definitions include data object declarations, type definitions, procedure definitions,
16    and interface blocks. A scoping unit in another program unit may access the definitions in a module.
17    Modules are further described in Section 11.


18    2.3        Execution concepts

19    Each Fortran statement is classified as either an executable statement or a nonexecutable statement.
20    There are restrictions on the order in which statements may appear in a program unit, and not all
21    executable statements may appear in all contexts.


22    2.3.1         Executable/nonexecutable statements

23    Program execution is a sequence, in time, of actions. An executable statement is an instruction to
24    perform or control one or more of these actions. Thus, the executable statements of a program unit
25    determine the behavior of the program unit. The executable statements are all of those that make up
26    the syntactic class executable-construct .

27    Nonexecutable statements do not specify actions; they are used to configure the program environment
28    in which actions take place. The nonexecutable statements are all those not classified as executable.


29    2.3.2         Statement order

30    The syntax rules of subclause 2.1 specify the statement order within program units and subprograms.
31    These rules are illustrated in Table 2.1 and Table 2.2. Table 2.1 shows the ordering rules for state-
32    ments and applies to all program units and subprograms. Vertical lines delineate varieties of statements
33    that may be interspersed and horizontal lines delineate varieties of statements that shall not be in-
34    terspersed. Internal or module subprograms shall follow a CONTAINS statement. Between USE and
35    CONTAINS statements in a subprogram, nonexecutable statements generally precede executable state-
36    ments, although the ENTRY statement, FORMAT statement, and DATA statement may appear among
37    the executable statements. Table 2.2 shows which statements are allowed in a scoping unit.





      SEP 2002                                          WORKING DRAFT                                         13


     J3/02-007R3                                    WORKING DRAFT                                             SEP 2002



                                Table 2.1: Requirements on statement ordering

                                       PROGRAM, FUNCTION, SUBROUTINE,
                                        MODULE, or BLOCK DATA statement

                                                      USE statements

                                                    IMPORT statements

                                                              IMPLICIT NONE
                                           PARAMETER                         IMPLICIT
                                                statements                   statements
                                                                  Derived-type definitions,
                              FORMAT                                      interface blocks,
                                and        PARAMETER            type declaration statements,
                              ENTRY             and DATA               type alias definitions,
                           statements           statements        enumeration declarations,
                                                                       procedure declarations,
                                                                  specification statements,

                                                                and statement function statements

                                                  DATA                       Executable
                                                statements                   constructs

                                                   CONTAINS statement

                                                   Internal subprograms
                                                  or module subprograms

                                                      END statement



                                Table 2.2: Statements allowed in scoping units
      Kind of scoping unit:             Main       Module      Block      External    Module      Internal     Interface
                                       program                 data        subprog    subprog     subprog       body

      USE statement                      Yes         Yes        Yes          Yes           Yes       Yes         Yes
      IMPORT statement                   No           No        No           No            No        No          Yes
      ENTRY statement                    No           No        No           Yes           Yes       No           No
      FORMAT statement                   Yes          No        No           Yes           Yes       Yes          No
      Misc. decls (see note)             Yes         Yes        Yes          Yes           Yes       Yes         Yes
      DATA statement                     Yes         Yes        Yes          Yes           Yes       Yes          No
      Derived-type definition             Yes         Yes        Yes          Yes           Yes       Yes         Yes
      Interface block                    Yes         Yes        No           Yes           Yes       Yes         Yes
      Executable statement               Yes          No        No           Yes           Yes       Yes          No
      CONTAINS statement                 Yes         Yes        No           Yes           Yes       No           No

      Statement function statement       Yes          No        No           Yes           Yes       Yes          No

      Notes for Table 2.2:
               1) Misc. declarations are PARAMETER statements, IMPLICIT statements, type
               declaration statements, type alias statements, enum statements, procedure declara-
               tion statements, and specification statements.
               2) The scoping unit of a module does not include any module subprograms that the
               module contains.



1    2.3.3    The END statement

2    An end-program-stmt , end-function-stmt , end-subroutine-stmt , end-module-stmt , or end-block-data-stmt
3    is an END statement. Each program unit, module subprogram, and internal subprogram shall have
4    exactly one END statement. The end-program-stmt , end-function-stmt , and end-subroutine-stmt state-
5    ments are executable, and may be branch target statements (8.2). Executing an end-program-stmt causes



     14                                    WORKING DRAFT                                                      SEP 2002


      SEP 2002                                    WORKING DRAFT                                  J3/02-007R3



 1    normal termination of execution of the program. Executing an end-function-stmt or end-subroutine-stmt
 2    is equivalent to executing a return-stmt with no scalar-int-expr.

 3    The end-module-stmt and end-block-data-stmt statements are nonexecutable.


 4    2.3.4         Execution sequence

 5    If a program contains a Fortran main program, execution of the program begins with the first executable
 6    construct of the main program. The execution of a main program or subprogram involves execution of
 7    the executable constructs within its scoping unit. When a procedure is invoked, execution begins with
 8    the first executable construct appearing after the invoked entry point. With the following exceptions,
 9    the effect of execution is as if the executable constructs are executed in the order in which they appear
10    in the main program or subprogram until a STOP, RETURN, or END statement is executed. The
11    exceptions are the following:

12           (1)      Execution of a branching statement (8.2) changes the execution sequence. These statements
13                    explicitly specify a new starting place for the execution sequence.

14           (2)      CASE constructs, DO constructs, IF constructs, and SELECT TYPE constructs contain
15                    an internal statement structure and execution of these constructs involves implicit internal
16                    branching. See Section 8 for the detailed semantics of each of these constructs.

17           (3)      END=, ERR=, and EOR= specifiers may result in a branch.

18           (4)      Alternate returns may result in a branch.


19    Internal subprograms may precede the END statement of a main program or a subprogram.                   The
20    execution sequence excludes all such definitions.

21    Normal termination of execution of the program occurs if a STOP statement or end-program-stmt is
22    executed. Normal termination of execution of a program also may occur during execution of a procedure
23    defined by a companion processor (C standard 5.1.2.2.3 and 7.20.4.3). If normal termination of execution
24    occurs within a Fortran program unit and the program incorporates procedures defined by a companion
25    processor, the process of execution termination shall include the effect of executing the C exit() function
26    (C standard 7.20.4.3).


27    2.4        Data concepts

28    Nonexecutable statements are used to specify the characteristics of the data environment. This includes
29    typing variables, declaring arrays, and defining new types.


30    2.4.1         Type

31    A type is a named category of data that is characterized by a set of values, a syntax for denoting
32    these values, and a set of operations that interpret and manipulate the values. This central concept is
33    described in 4.1.

34    A type may be parameterized, in which case the set of data values, the syntax for denoting them, and
35    the set of operations depend on the values of one or more parameters. Such a parameter is called a type
36    parameter (4.2).

37    There are two categories of types: intrinsic types and derived types.


38    2.4.1.1       Intrinsic type

39    An intrinsic type is a type that is defined by the language, along with operations, and is always
40    accessible. The intrinsic types are integer, real, complex, character, and logical. The properties of
41    intrinsic types are described in 4.4. The intrinsic type parameters are KIND and LEN.



      SEP 2002                                            WORKING DRAFT                                       15


      J3/02-007R3                                  WORKING DRAFT                                     SEP 2002



 1    The kind type parameter indicates the decimal exponent range for the integer type (4.4.1), the
 2    decimal precision and exponent range for the real and complex types (4.4.2, 4.4.3), and the representation
 3    methods for the character and logical types (4.4.4, 4.4.5). The character length parameter specifies
 4    the number of characters for the character type.


 5    2.4.1.2     Derived type

 6    A derived type is a type that is not defined by the language but requires a type definition to declare its
 7    components. A scalar object of such a derived type is called a structure (5.1.1.7). Derived types may
 8    be parameterized. Assignment of structures is defined intrinsically (7.4.1.3), but there are no intrinsic
 9    operations for structures. For each derived type, a structure constructor is available to provide values
10    (4.5.8). In addition, data objects of derived type may be used as procedure arguments and function
11    results, and may appear in input/output lists. If additional operations are needed for a derived type,
12    they shall be supplied as procedure definitions.

13    Derived types are described further in 4.5.


14    2.4.2      Data value

15    Each intrinsic type has associated with it a set of values that a datum of that type may take, depending
16    on the values of the type parameters. The values for each intrinsic type are described in 4.4. The values
17    that objects of a derived type may assume are determined by the type definition, type parameter values,
18    and the sets of values of its components.


19    2.4.3      Data entity

20    A data entity is a data object, the result of the evaluation of an expression, or the result of the execution
21    of a function reference (called the function result). A data entity has a type and type parameters; it
22    may have a data value (an exception is an undefined variable). Every data entity has a rank and is thus
23    either a scalar or an array.


24    2.4.3.1     Data object

25    A data object (often abbreviated to object) is a constant (4.1.2), a variable (6), or a subobject of a
26    constant. The type and type parameters of a named data object may be specified explicitly (5.1) or
27    implicitly (5.3).

28    Subobjects are portions of certain objects that may be referenced and defined (variables only) inde-
29    pendently of the other portions. These include portions of arrays (array elements and array sections),
30    portions of character strings (substrings), portions of complex objects (real and imaginary parts), and
31    portions of structures (components). Subobjects are themselves data objects, but subobjects are refer-
32    enced only by object designators or intrinsic functions. In contexts where a structure component that is
33    a pointer refers to its target, the structure component is not a subobject of the structure. A subobject
34    of a variable is a variable. Subobjects are described in Section 6.

35    Objects referenced by a name are:

                 a named scalar                 (a scalar object)
36               a named array                  (an array object)

37    Subobjects referenced by an object designator are:

                 an array element               (a scalar subobject)
                 an array section               (an array subobject)
                 a structure component          (a scalar or an array subobject)
38               a substring                    (a scalar subobject)



      16                                   WORKING DRAFT                                             SEP 2002


      SEP 2002                                    WORKING DRAFT                               J3/02-007R3



 1    Subobjects of complex objects may also be referenced by intrinsic functions.


 2    2.4.3.1.1     Variable

 3    A variable may have a value and may be defined and redefined during execution of a program.

 4    A named local variable of the scoping unit of a module, main program, or subprogram, is a named
 5    variable that is a local entity of the scoping unit, is not a dummy argument, is not in COMMON, does
 6    not have the BIND attribute, and is not accessed by use or host association. A subobject of a named
 7    local variable is also a local variable.


 8    2.4.3.1.2     Constant

 9    A constant has a value and cannot become defined, redefined, or undefined during execution of a
10    program. A constant with a name is called a named constant and has the PARAMETER attribute
11    (5.1.2.10). A constant without a name is called a literal constant (4.4).


12    2.4.3.1.3     Subobject of a constant

13    A subobject of a constant is a portion of a constant. The portion referenced may depend on the
14    value of a variable.

           NOTE 2.3

           For example, given:


           CHARACTER (LEN = 10), PARAMETER :: DIGITS = '0123456789'
           CHARACTER (LEN = 1)                       :: DIGIT
           INTEGER :: I
                 ...
           DIGIT = DIGITS (I:I)


           DIGITS is a named constant and DIGITS (I:I) designates a subobject of the constant DIGITS.


15    2.4.3.2      Expression

16    An expression (7.1) produces a data entity when evaluated. An expression represents either a data
17    reference or a computation; it is formed from operands, operators, and parentheses. The type, type
18    parameters, value, and rank of an expression result are determined by the rules in Section 7.


19    2.4.3.3      Function reference

20    A function reference (12.4.2) produces a data entity when the function is executed during expression
21    evaluation. The type, type parameters, and rank of a function result are determined by the interface of
22    the function (12.2.2). The value of a function result is determined by execution of the function.


23    2.4.4        Scalar

24    A scalar is a datum that is not an array. Scalars may be of any intrinsic type or derived type.

           NOTE 2.4

           A structure is scalar even if it has arrays as components.


25    The rank of a scalar is zero. The shape of a scalar is represented by a rank-one array of size zero.





      SEP 2002                                       WORKING DRAFT                                            17


      J3/02-007R3                                WORKING DRAFT                                     SEP 2002


 1    2.4.5    Array

 2    An array is a set of scalar data, all of the same type and type parameters, whose individual elements
 3    are arranged in a rectangular pattern. An array element is one of the individual elements in the array
 4    and is a scalar. An array section is a subset of the elements of an array and is itself an array.

 5    An array may have up to seven dimensions, and any extent (number of elements) in any dimension.
 6    The rank of the array is the number of dimensions; its size is the total number of elements, which is
 7    equal to the product of the extents. An array may have zero size. The shape of an array is determined
 8    by its rank and its extent in each dimension, and may be represented as a rank-one array whose elements
 9    are the extents. All named arrays shall be declared, and the rank of a named array is specified in its
10    declaration. The rank of a named array, once declared, is constant; the extents may be constant or may
11    vary during execution.

12    Two arrays are conformable if they have the same shape. A scalar is conformable with any array. Any
13    intrinsic operation defined for scalar objects may be applied to conformable objects. Such operations
14    are performed element-by-element to produce a resultant array conformable with the array operands.
15    Element-by-element operation means corresponding elements of the operand arrays are involved in a
16    scalar operation to produce the corresponding element in the result array, and all such element operations
17    may be performed in any order or simultaneously. Such an operation is described as elemental.

18    A rank-one array may be constructed from scalars and other arrays and may be reshaped into any
19    allowable array shape (4.8).

20    Arrays may be of any intrinsic type or derived type and are described further in 6.2.


21    2.4.6    Pointer

22    A data pointer is a data entity that has the POINTER attribute. A procedure pointer is a procedure
23    entity that has the POINTER attribute. A pointer is either a data pointer or a procedure pointer.

24    A pointer is associated with a target by pointer assignment (7.4.2). A data pointer may also be
25    associated with a target by allocation (6.3.1). A pointer is disassociated following execution of a
26    NULLIFY statement, following pointer assignment with a disassociated pointer, by default initialization,
27    or by explicit initialization. A data pointer may also be disassociated by execution of a DEALLOCATE
28    statement. A disassociated pointer is not associated with a target (16.4.2).

29    A pointer that is not associated shall not be referenced or defined.

30    If a data pointer is an array, the rank is declared, but the extents are determined when the pointer is
31    associated with a target.


32    2.4.7    Storage

33    Many of the facilities of this standard make no assumptions about the physical storage characteristics of
34    data objects. However, program units that include storage association dependent features shall observe
35    the storage restrictions described in 16.4.3.


36    2.5      Fundamental terms

37    The following terms are defined here and used throughout this standard.





      18                                  WORKING DRAFT                                            SEP 2002


      SEP 2002                                  WORKING DRAFT                                     J3/02-007R3


 1    2.5.1          Name and designator

 2    A name is used to identify a program constituent, such as a program unit, named variable, named
 3    constant, dummy argument, or derived type. The rules governing the construction of names are given
 4    in 3.2.1. A designator is a name followed by zero or more component selectors, array section selectors,
 5    array element selectors, and substring selectors.

 6    An object designator is a designator for a data object. A procedure designator is a designator for
 7    a procedure.

           NOTE 2.5

           An object name is a special case of an object designator.


 8    2.5.2          Keyword

 9    The term keyword is used in two ways.

10            (1)      It is used to describe a word that is part of the syntax of a statement. These keywords are
11                     not reserved words; that is, names with the same spellings are allowed. In the syntax rules,
12                     such keywords appear literally. In descriptive text, this meaning is denoted by the term
13                     "keyword" without any modifier. Examples of statement keywords are: IF, READ, UNIT,
14                     KIND, and INTEGER.

15            (2)      It is used to denote names that identify items in a list. In actual argument lists, type
16                     parameter lists, and structure constructors, items may be identified by a preceding keyword =
17                     rather than their position within the list. An argument keyword is the name of a dummy
18                     argument in the interface for the procedure being referenced, a type parameter keyword
19                     is the name of a type parameter in the type being specified, and a component keyword
20                     is the name of a component in a structure constructor.

21    R215      keyword                         is    name

           NOTE 2.6

           Use of keywords rather than position to identify items in a list can make such lists more readable
           and allows them to be reordered. This facilitates specification of a list in cases where optional
           items are omitted.


22    2.5.3          Association

23    Association may be name association (16.4.1), pointer association (16.4.2), storage association (16.4.3),
24    or inheritance association (16.4.4). Name association may be argument association, host association,
25    use association, linkage association, or construct association.

26    Storage association causes different entities to use the same storage. Any association permits an entity
27    to be identified by different names in the same scoping unit or by the same name or different names in
28    different scoping units.


29    2.5.4          Declaration

30    The term declaration refers to the specification of attributes for various program entities. Often this
31    involves specifying the type of a named data object or specifying the shape of a named array object.


32    2.5.5          Definition

33    The term definition is used in two ways.




      SEP 2002                                         WORKING DRAFT                                           19


      J3/02-007R3                                 WORKING DRAFT                                       SEP 2002



 1          (1)      It refers to the specification of derived types and procedures.

 2          (2)      When an object is given a valid value during program execution, it is said to become
 3                   defined. This is often accomplished by execution of an assignment or input statement.
 4                   When a variable does not have a predictable value, it is said to be undefined. Similarly,
 5                   when a pointer is associated with a target or nullified, its pointer association status is said
 6                   to become defined. When the association status of a pointer is not predictable, its pointer
 7                   association status is said to be undefined.

 8    Section 16 describes the ways in which variables may become defined and undefined.


 9    2.5.6        Reference

10    A data object reference is the appearance of the data object designator in a context requiring its
11    value at that point during execution.

12    A procedure reference is the appearance of the procedure designator, operator symbol, or assignment
13    symbol in a context requiring execution of the procedure at that point. An occurrence of user-defined
14    derived-type input/output (10.6.5) or derived-type finalization (4.5.10) is also a procedure reference.

15    The appearance of a data object designator or procedure designator in an actual argument list does not
16    constitute a reference to that data object or procedure unless such a reference is necessary to complete
17    the specification of the actual argument.

18    A module reference is the appearance of a module name in a USE statement (11.2.1).


19    2.5.7        Intrinsic

20    The qualifier intrinsic has two meanings.

21          (1)      The qualifier signifies that the term to which it is applied is defined in this standard. In-
22                   trinsic applies to types, procedures, modules, assignment statements, and operators. All
23                   intrinsic types, procedures, assignments, and operators may be used in any scoping unit
24                   without further definition or specification. Intrinsic modules may be accessed by use as-
25                   sociation. Intrinsic procedures and modules defined in this standard are called standard
26                   intrinsic procedures and standard intrinsic modules, respectively.

27          (2)      The qualifier applies to procedures or modules that are provided by a processor but are not
28                   defined in this standard (13, 14, 15.1). Such procedures and modules are called nonstandard
29                   intrinsic procedures and nonstandard intrinsic modules, respectively.


30    2.5.8        Operator

31    An operator specifies a computation involving one (unary operator) or two (binary operator) data values
32    (operands). This standard specifies a number of intrinsic operators (e.g., the arithmetic operators +, �,
33    *, /, and ** with numeric operands and the logical operators .AND., .OR., etc. with logical operands).
34    Additional operators may be defined within a program (7.1.3).


35    2.5.9        Sequence

36    A sequence is a set ordered by a one-to-one correspondence with the numbers 1, 2, through n. The
37    number of elements in the sequence is n. A sequence may be empty, in which case it contains no elements.

38    The elements of a nonempty sequence are referred to as the first element, second element, etc. The
39    nth element, where n is the number of elements in the sequence, is called the last element. An empty
40    sequence has no first or last element.





      20                                   WORKING DRAFT                                              SEP 2002


      SEP 2002                             WORKING DRAFT                                    J3/02-007R3


 1    2.5.10    Companion processors

 2    A processor has one or more companion processors. A companion processor is a processor-dependent
 3    mechanism by which global data and procedures may be referenced or defined. A companion processor
 4    may be a mechanism that references and defines such entities by a means other than Fortran (12.5.3),
 5    it may be the Fortran processor itself, or it may be another Fortran processor. If there is more than
 6    one companion processor, the means by which the Fortran processor selects among them are processor
 7    dependent.

 8    If a procedure is defined by means of a companion processor that is not the Fortran processor itself,
 9    this standard refers to the C function that defines the procedure, although the procedure need not be
10    defined by means of the C programming language.

          NOTE 2.7

          A companion processor might or might not be a mechanism that conforms to the requirements of
          the C standard.

          For example, a processor may allow a procedure defined by some language other than Fortran or
          C to be linked (12.5.3) with a Fortran procedure if it can be described by a C prototype as defined
          in 6.5.5.3 of the C standard.





      SEP 2002                                   WORKING DRAFT                                           21


J3/02-007R3       WORKING DRAFT    SEP 2002





22             WORKING DRAFT       SEP 2002


      SEP 2002                                        WORKING DRAFT                          J3/02-007R3





 1    Section 3: Characters, lexical tokens, and source form

 2    This section describes the Fortran character set and the various lexical tokens such as names and oper-
 3    ators. This section also describes the rules for the forms that Fortran programs may take.


 4    3.1       Processor character set

 5    The processor character set is processor dependent. The structure of a processor character set is:

 6            (1)      Control characters ("newline", for example)

 7            (2)      Graphic characters

 8                     (a)      Letters (3.1.1)

 9                     (b)      Digits (3.1.2)

10                     (c)      Underscore (3.1.3)

11                     (d)      Special characters (3.1.4)

12                     (e)      Other characters (3.1.5)


13    The letters, digits, underscore, and special characters make up the Fortran character set.

14    R301      character                             is    alphanumeric-character
15                                                    or special-character
16    R302      alphanumeric-character                is    letter
17                                                    or digit
18                                                    or underscore

19    Except for the currency symbol, the graphics used for the characters shall be as given in 3.1.1, 3.1.2,
20    3.1.3, and 3.1.4. However, the style of any graphic is not specified.


21    3.1.1          Letters

22    The twenty-six letters are:

23        A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

24    The set of letters defines the syntactic class letter . The processor character set shall include lower-
25    case and upper-case letters. A lower-case letter is equivalent to the corresponding upper-case letter in
26    program units except in a character context (3.3).

             NOTE 3.1

             The following statements are equivalent:


             CALL BIG_COMPLEX_OPERATION (NDATE)
             call big_complex_operation (ndate)
             Call Big_Complex_Operation (NDate)



27    3.1.2          Digits

28    The ten digits are:




      SEP 2002                                                WORKING DRAFT                                 23


      J3/02-007R3                                       WORKING DRAFT                                   SEP 2002



 1          0 1 2 3 4 5 6 7 8 9

 2    The ten digits define the syntactic class digit .


 3    3.1.3        Underscore

 4    R303         underscore                     is

 5    The underscore may be used as a significant character in a name.


 6    3.1.4        Special characters

 7    The special characters are shown in Table 3.1.


                                                 Table 3.1: Special characters
                       Character    Name of character           Character    Name of character

                                    Blank                           ;        Semicolon
                           =        Equals                          !        Exclamation point
                           +        Plus                            "        Quotation mark or quote
                           -        Minus                          %         Percent
                           *        Asterisk                       &         Ampersand
                           /        Slash                           ~        Tilde
                           \        Backslash                      <         Less than
                           (        Left parenthesis               >         Greater than
                           )        Right parenthesis               ?        Question mark
                           [        Left square bracket             '        Apostrophe
                           ]        Right square bracket           `         Grave accent
                           {        Left curly bracket              ^        Circumflex accent
                           }        Right curly bracket             |        Vertical bar
                           ,        Comma                           $        Currency symbol
                           .        Decimal point or period         #        Number sign
                           :        Colon                          @         Commercial at



 8    The special characters define the syntactic class special-character . Some of the special characters are
 9    used for operator symbols, bracketing, and various forms of separating and delimiting other lexical
10    tokens.


11    3.1.5        Other characters

12    Additional characters may be representable in the processor, but may appear only in comments (3.3.1.1,
13    3.3.2.1), character constants (4.4.4), input/output records (9.1.1), and character string edit descriptors
14    (10.2.1).

15    The default character type shall support a character set that includes the Fortran character set. By
16    supplying nondefault character types, the processor may support additional character sets. The char-
17    acters available in the nondefault character types are not specified, except that one character in each
18    nondefault character type shall be designated as a blank character to be used as a padding character.


19    3.2        Low-level syntax

20    The low-level syntax describes the fundamental lexical tokens of a program unit. Lexical tokens are
21    sequences of characters that constitute the building blocks of a program. They are keywords, names,




      24                                        WORKING DRAFT                                           SEP 2002


      SEP 2002                               WORKING DRAFT                                     J3/02-007R3



 1    literal constants other than complex literal constants, operators, labels, delimiters, comma, =, =>, :, ::,
 2    ;, and %.


 3    3.2.1          Names

 4    Names are used for various entities such as variables, program units, dummy arguments, named con-
 5    stants, and derived types.

 6    R304      name                         is    letter [ alphanumeric-character ] ...

 7    C301      (R304) The maximum length of a name is 63 characters.

           NOTE 3.2

           Examples of names:

               A1
               NAME LENGTH            (single underscore)
               S P R E A D O U T      (two consecutive underscores)
               TRAILER                (trailing underscore)



           NOTE 3.3

           The word "name" always denotes this particular syntactic form. The word "identifier" is used
           where entities may be identified by other syntactic forms or by values; its particular meaning
           depends on the context in which it is used.


 8    3.2.2          Constants

 9    R305      constant                     is    literal-constant
10                                           or named-constant
11    R306      literal-constant             is    int-literal-constant
12                                           or real-literal-constant
13                                           or complex-literal-constant
14                                           or logical-literal-constant
15                                           or char-literal-constant
16                                           or boz-literal-constant
17    R307      named-constant               is    name
18    R308      int-constant                 is    constant

19    C302      (R308)int-constant shall be of type integer.

20    R309      char-constant                is    constant

21    C303      (R309) char-constant shall be of type character.


22    3.2.3          Operators

23    R310      intrinsic-operator           is    power-op
24                                           or mult-op
25                                           or add-op
26                                           or concat-op
27                                           or rel-op
28                                           or not-op
29                                           or and-op
30                                           or or-op




      SEP 2002                                       WORKING DRAFT                                           25


      J3/02-007R3                                    WORKING DRAFT                                    SEP 2002



 1                                             or equiv-op
 2    R707        power-op                     is    **
 3    R708        mult-op                      is    *
 4                                             or /
 5    R709        add-op                       is    +
 6                                             or �
 7    R711        concat-op                    is    //
 8    R713        rel-op                       is    .EQ.
 9                                             or .NE.
10                                             or .LT.
11                                             or .LE.
12                                             or .GT.
13                                             or .GE.
14                                             or ==
15                                             or /=
16                                             or <
17                                             or <=
18                                             or >
19                                             or >=
20    R718        not-op                       is    .NOT.
21    R719        and-op                       is    .AND.
22    R720        or-op                        is    .OR.
23    R721        equiv-op                     is    .EQV.
24                                             or .NEQV.
25    R311        defined-operator              is    defined-unary-op
26                                             or defined-binary-op
27                                             or extended-intrinsic-op
28    R703        defined-unary-op              is    . letter [ letter ] ... .
29    R723        defined-binary-op             is    . letter [ letter ] ... .
30    R312        extended-intrinsic-op        is    intrinsic-operator


31    3.2.4        Statement labels

32    A statement label provides a means of referring to an individual statement.

33    R313        label                        is    digit [ digit [ digit [ digit [ digit ] ] ] ]

34    C304        (R313) At least one digit in a label shall be nonzero.

35    If a statement is labeled, the statement shall contain a nonblank character. The same statement label
36    shall not be given to more than one statement in a scoping unit. Leading zeros are not significant in
37    distinguishing between statement labels.

            NOTE 3.4

            For example:


            99999
            10
              010


            are all statement labels. The last two are equivalent.

            There are 99999 unique statement labels and a processor shall accept any of them as a statement





      26                                    WORKING DRAFT                                             SEP 2002


      SEP 2002                                  WORKING DRAFT                                      J3/02-007R3



             NOTE 3.4 (cont.)

             label. However, a processor may have an implementation limit on the total number of unique
             statement labels in one program unit.


 1    Any statement may have a statement label, but the labels are used only in the following ways:

 2            (1)      The label on a branch target statement (8.2) is used to identify that statement as the
 3                     possible destination of a branch.

 4            (2)      The label on a FORMAT statement (10.1.1) is used to identify that statement as the format
 5                     specification for a data transfer statement (9.5).

 6            (3)      In some forms of the DO construct (8.1.6), the range of the DO construct is identified by
 7                     the label on the last statement in that range.


 8    3.2.5          Delimiters

 9    Delimiters are used to enclose syntactic lists. The following pairs are delimiters:

10    ( ... )


11    / ... /

12    [ ... ]

13    (/ ... /)


14    3.3        Source form

15    A Fortran program unit is a sequence of one or more lines, organized as Fortran statements, comments,
16    and INCLUDE lines. A line is a sequence of zero or more characters. Lines following a program unit
17    END statement are not part of that program unit. A Fortran statement is a sequence of one or more
18    complete or partial lines.

19    A character context means characters within a character literal constant (4.4.4) or within a character
20    string edit descriptor (10.2.1).

21    A comment may contain any character that may occur in any character context.

22    There are two source forms: free and fixed. Free form and fixed form shall not be mixed in the same program unit.

23    The means for specifying the source form of a program unit are processor dependent.


24    3.3.1          Free source form

25    In free source form there are no restrictions on where a statement (or portion of a statement) may
26    appear within a line. A line may contain zero characters. If a line consists entirely of characters of
27    default kind (4.4.4), it may contain at most 132 characters. If a line contains any character that is not
28    of default kind, the maximum number of characters allowed on the line is processor dependent.

29    Blank characters shall not appear within lexical tokens other than in a character context or in a format
30    specification. Blanks may be inserted freely between tokens to improve readability; for example, blanks
31    may occur between the tokens that form a complex literal constant. A sequence of blank characters
32    outside of a character context is equivalent to a single blank character.

33    A blank shall be used to separate names, constants, or labels from adjacent keywords, names, constants,
34    or labels.




      SEP 2002                                          WORKING DRAFT                                            27


      J3/02-007R3                                WORKING DRAFT                                     SEP 2002



            NOTE 3.5

            For example, the blanks after REAL, READ, 30, and DO are required in the following:


            REAL X
            READ 10
            30 DO K=1,3



 1    One or more blanks shall be used to separate adjacent keywords except in the following cases, where
 2    blanks are optional:


                                Adjacent keywords where separating blanks are optional

                                BLOCK DATA                    DOUBLE PRECISION
                                ELSE IF                       ELSE WHERE
                                END ASSOCIATE                 END BLOCK DATA
                                END DO                        END ENUM
                                END FILE                      END FORALL
                                END FUNCTION                  END IF
                                END INTERFACE                 END MODULE
                                END PROGRAM                   END SELECT
                                END SUBROUTINE                END TYPE
                                END WHERE                     GO TO
                                IN OUT                        SELECT CASE
                                SELECT TYPE



 3    3.3.1.1    Free form commentary

 4    The character "!"       initiates a comment except where it appears within a character context.      The
 5    comment extends to the end of the line. If the first nonblank character on a line is an "!", the line
 6    is a comment line. Lines containing only blanks or containing no characters are also comment lines.
 7    Comments may appear anywhere in a program unit and may precede the first statement of a program
 8    unit. Comments have no effect on the interpretation of the program unit.

            NOTE 3.6

            The standard does not restrict the number of consecutive comment lines.


 9    3.3.1.2    Free form statement continuation

10    The character "&" is used to indicate that the current statement is continued on the next line that is not
11    a comment line. Comment lines cannot be continued; an "&" in a comment has no effect. Comments may
12    occur within a continued statement. When used for continuation, the "&" is not part of the statement.
13    No line shall contain a single "&" as the only nonblank character or as the only nonblank character
14    before an "!" that initiates a comment.

15    If a noncharacter context is to be continued, an "&" shall be the last nonblank character on the line,
16    or the last nonblank character before an "!". There shall be a later line that is not a comment; the
17    statement is continued on the next such line. If the first nonblank character on that line is an "&", the
18    statement continues at the next character position following that "&"; otherwise, it continues with the
19    first character position of that line.

20    If a lexical token is split across the end of a line, the first nonblank character on the first following
21    noncomment line shall be an "&" immediately followed by the successive characters of the split token.

22    If a character context is to be continued, an "&" shall be the last nonblank character on the line and



      28                                    WORKING DRAFT                                          SEP 2002


      SEP 2002                                      WORKING DRAFT                                                J3/02-007R3



 1    shall not be followed by commentary. There shall be a later line that is not a comment; an "&" shall be
 2    the first nonblank character on the next such line and the statement continues with the next character
 3    following that "&".


 4    3.3.1.3       Free form statement termination

 5    If a statement is not continued, a comment or the end of the line terminates the statement.

 6    A statement may alternatively be terminated by a ";" character that appears other than in a character
 7    context or in a comment. The ";" is not part of the statement. After a ";" terminator, another statement
 8    may appear on the same line, or begin on that line and be continued. A ";" shall not appear as the first
 9    nonblank character on a line. A sequence consisting only of zero or more blanks and one or more ";"
10    terminators, in any order, is equivalent to a single ";" terminator.


11    3.3.1.4       Free form statements

12    A label may precede any statement not forming part of another statement.

            NOTE 3.7

            No Fortran statement begins with a digit.


13    A statement shall not have more than 255 continuation lines.


14    3.3.2      Fixed source form

15    In fixed source form, there are restrictions on where a statement may appear within a line. If a source line contains only

16    default kind characters, it shall contain exactly 72 characters; otherwise, its maximum number of characters is processor

17    dependent.


18    Except in a character context, blanks are insignificant and may be used freely throughout the program.


19    3.3.2.1       Fixed form commentary

20    The character "!" initiates a comment except where it appears within a character context or in character position 6. The
21    comment extends to the end of the line. If the first nonblank character on a line is an "!" in any character position other
22    than character position 6, the line is a comment line. Lines beginning with a "C" or "*" in character position 1 and lines
23    containing only blanks are also comment lines. Comments may appear anywhere in a program unit and may precede the
24    first statement of the program unit. Comments have no effect on the interpretation of the program unit.


            NOTE 3.8

            The standard does not restrict the number of consecutive comment lines.



25    3.3.2.2       Fixed form statement continuation

26    Except within commentary, character position 6 is used to indicate continuation. If character position 6 contains a blank
27    or zero, the line is the initial line of a new statement, which begins in character position 7. If character position 6 contains
28    any character other than blank or zero, character positions 7�72 of the line constitute a continuation of the preceding
29    noncomment line.


            NOTE 3.9

            An "!" or ";" in character position 6 is interpreted as a continuation indicator unless it appears within commentary
            indicated by a "C" or "*" in character position 1 or by an "!" in character positions 1�5.



30    Comment lines cannot be continued. Comment lines may occur within a continued statement.


31    3.3.2.3       Fixed form statement termination

32    If a statement is not continued, a comment or the end of the line terminates the statement.




      SEP 2002                                              WORKING DRAFT                                                         29


      J3/02-007R3                                           WORKING DRAFT                                             SEP 2002



 1    A statement may alternatively be terminated by a ";" character that appears other than in a character context, in a

 2    comment, or in character position 6. The ";" is not part of the statement. After a ";" terminator, another statement may

 3    begin on the same line, or begin on that line and be continued. A ";" shall not appear as the first nonblank character on

 4    a line, except in character position 6. A sequence consisting only of zero or more blanks and one or more ";" terminators,

 5    in any order, is equivalent to a single ";" terminator.


 6    3.3.2.4           Fixed form statements


 7    A label, if present, shall occur in character positions 1 through 5 of the first line of a statement; otherwise, positions 1

 8    through 5 shall be blank. Blanks may appear anywhere within a label. A statement following a ";" on the same line shall

 9    not be labeled. Character positions 1 through 5 of any continuation lines shall be blank. A statement shall not have more

10    than 255 continuation lines. The program unit END statement shall not be continued. A statement whose initial line

11    appears to be a program unit END statement shall not be continued.



12    3.4          Including source text

13    Additional text may be incorporated into the source text of a program unit during processing. This is
14    accomplished with the INCLUDE line, which has the form

15          INCLUDE char-literal-constant

16    The char-literal-constant shall not have a kind type parameter value that is a named-constant .

17    An INCLUDE line is not a Fortran statement.

18    An INCLUDE line shall appear on a single source line where a statement may appear; it shall be the
19    only nonblank text on this line other than an optional trailing comment. Thus, a statement label is not
20    allowed.

21    The effect of the INCLUDE line is as if the referenced source text physically replaced the INCLUDE line
22    prior to program processing. Included text may contain any source text, including additional INCLUDE
23    lines; such nested INCLUDE lines are similarly replaced with the specified source text. The maximum
24    depth of nesting of any nested INCLUDE lines is processor dependent. Inclusion of the source text
25    referenced by an INCLUDE line shall not, at any level of nesting, result in inclusion of the same source
26    text.

27    When an INCLUDE line is resolved, the first included statement line shall not be a continuation line
28    and the last included statement line shall not be continued.

29    The interpretation of char-literal-constant is processor dependent. An example of a possible valid inter-
30    pretation is that char-literal-constant is the name of a file that contains the source text to be included.

               NOTE 3.10

               In some circumstances, for example where source code is maintained in an INCLUDE file for use in programs whose

               source form might be either fixed or free, observing the following rules allows the code to be used with either source

               form:


                         (1)    Confine statement labels to character positions 1 to 5 and statements to character positions 7 to 72;

                         (2)    Treat blanks as being significant;

                         (3)    Use only the exclamation mark (!) to indicate a comment, but do not start the comment in character

                                position 6;

                         (4)    For continued statements, place an ampersand (&) in both character position 73 of a continued line

                                and character position 6 of a continuing line.





      30                                            WORKING DRAFT                                                     SEP 2002


      SEP 2002                                WORKING DRAFT                                      J3/02-007R3





 1    Section 4: Types

 2    Fortran provides an abstract means whereby data may be categorized without relying on a particular
 3    physical representation. This abstract means is the concept of type.

 4    An intrinsic type is one that is defined by the language. The intrinsic types are integer, real, complex,
 5    character, and logical.

 6    A derived type is one that is defined by a derived-type definition ((4.5.1)).

 7    A derived type may be used only where its definition is accessible (4.5.1.8). An intrinsic type is always
 8    accessible.


 9    4.1       The concept of type

10    A type has a name, a set of valid values, a means to denote such values (constants), and a set of
11    operations to manipulate the values.

             NOTE 4.1

             For example, the logical type has a set of two values, denoted by the lexical tokens .TRUE. and
             .FALSE., which are manipulated by logical operations.

             An example of a less restricted type is the integer type. This type has a processor-dependent set of
             integer numeric values, each of which is denoted by an optional sign followed by a string of digits,
             and which may be manipulated by integer arithmetic operations and relational operations.


12    4.1.1      Set of values

13    For each type, there is a set of valid values. The set of valid values may be completely determined, as is
14    the case for logical, or may be determined by a processor-dependent method, as is the case for integer,
15    character, and real. For complex or derived types, the set of valid values consists of the set of all the
16    combinations of the values of the individual components.


17    4.1.2      Constants

18    The syntax for literal constants of each intrinsic type is specified in 4.4.

19    The syntax for denoting a value indicates the type, type parameters, and the particular value.

20    A constant value may be given a name (5.1.2.10, 5.2.9).

21    A structure constructor (4.5.8) may be used to construct a constant value of derived type from an
22    appropriate sequence of initialization expressions (7.1.7). Such a constant value is considered to be a
23    scalar even though the value may have components that are arrays.


24    4.1.3      Operations

25    For each of the intrinsic types, a set of operations and corresponding operators is defined intrinsically.
26    These are described in Section 7. The intrinsic set may be augmented with operations and operators
27    defined by functions with the OPERATOR interface (12.3.2.1). Operator definitions are described in
28    Sections 7 and 12.



      SEP 2002                                      WORKING DRAFT                                             31


      J3/02-007R3                                    WORKING DRAFT                                   SEP 2002



 1    For derived types, there are no intrinsic operations. Operations on derived types may be defined by the
 2    program (4.5.9).


 3    4.2       Type parameters

 4    A type may be parameterized. In this case, the set of values, the syntax for denoting the values, and
 5    the set of operations on the values of the type depend on the values of the parameters.

 6    The intrinsic types are all parameterized. Derived types may be defined to be parameterized.

 7    A type parameter is either a kind type parameter or a nonkind type parameter.

 8    A kind type parameter may be used in initialization and specification expressions within the derived-type
 9    definition (4.5.1) for the type; it participates in generic resolution (16.2.3). Each of the intrinsic types
10    has a kind type parameter named KIND, which is used to distinguish multiple representations of the
11    intrinsic type.

             NOTE 4.2

             By design, the value of a kind type parameter is known at compile time. Some parameterizations
             that involve multiple representation forms need to be distinguished at compile time for practical
             implementation and performance. Examples include the multiple precisions of the intrinsic real
             type and the possible multiple character sets of the intrinsic character type.

             A type parameter of a derived type may be specified to be a kind type parameter in order to
             allow generic resolution based on the parameter; that is to allow a single generic to include two
             specific procedures that have interfaces distinguished only by the value of a kind type parameter
             of a dummy argument. Generics are designed to be resolvable at compile time.


12    A nonkind type parameter may be used in specification expressions within the derived-type definition
13    for the type, but it may not be used in initialization expressions. The intrinsic character type has a
14    nonkind type parameter named LEN, which is the length of the string.

             NOTE 4.3

             A typical use of a nonkind type parameter is to specify a size. An example is the length of an
             entity of intrinsic character type.


15    A type parameter value may be specified with a type specification (5.1, 4.5.7).

16    R401      type-param-value               is    scalar-int-expr
17                                             or *
18                                             or :

19    C401      (R401) The type-param-value for a kind type parameter shall be an initialization expression.

20    C402      (R401) A colon may be used as a type-param-value only in the declaration of an entity or
21              component that has the POINTER or ALLOCATABLE attribute.

22    A deferred type parameter is a nonkind type parameter whose value can change during execution of
23    the program. A colon as a type-param-value specifies a deferred type parameter.

24    The values of the deferred type parameters of an object are determined by successful execution of an
25    ALLOCATE statement (6.3.1), execution of a derived-type intrinsic assignment statement (7.4.1.2),
26    execution of a pointer assignment statement (7.4.2), or by argument association (12.4.1.2).





      32                                    WORKING DRAFT                                            SEP 2002


      SEP 2002                                WORKING DRAFT                                      J3/02-007R3



             NOTE 4.4

             Deferred type parameters of functions, including function procedure pointers, have no values.
             Instead, they indicate that those type parameters of the function result will be determined by
             execution of the function, if it returns an allocated allocatable result or an associated pointer
             result.


 1    An assumed type parameter is a nonkind type parameter for a dummy argument that assumes
 2    the type parameter value from the corresponding actual argument. An asterisk as a type-param-value
 3    specifies an assumed type parameter.


 4    4.3       Relationship of types and values to objects

 5    The name of a type serves as a type specifier and may be used to declare objects of that type. A
 6    declaration specifies the type of a named object. A data object may be declared explicitly or implicitly.
 7    Data objects may have attributes in addition to their types. Section 5 describes the way in which a data
 8    object is declared and how its type and other attributes are specified.

 9    Scalar data of any intrinsic or derived type may be shaped in a rectangular pattern to compose an array
10    of the same type and type parameters. An array object has a type and type parameters just as a scalar
11    object does.

12    Variables may be objects or subobjects. The type and type parameters of a variable determine which
13    values that variable may take. Assignment provides one means of defining or redefining the value of a
14    variable of any type. Assignment is defined intrinsically for all types where the type, type parameters,
15    and shape of both the variable and the value to be assigned to it are identical. Assignment between
16    objects of certain differing intrinsic types, type parameters, and shapes is described in Section 7. A
17    subroutine and a generic interface (4.5.1, 12.3.2.1) whose generic specifier is ASSIGNMENT (=) define
18    an assignment that is not defined intrinsically or redefine an intrinsic derived-type assignment (7.4.1.4).

             NOTE 4.5

             For example, assignment of a real value to an integer variable is defined intrinsically.


19    The type of a variable determines the operations that may be used to manipulate the variable.


20    4.4       Intrinsic types

21    The intrinsic types are:

                numeric types:                  integer, real, and complex
22              nonnumeric types:               character and logical

23    The numeric types are provided for numerical computation. The normal operations of arithmetic,
24    addition (+), subtraction (�), multiplication (*), division (/), exponentiation (**), identity (unary +),
25    and negation (unary �), are defined intrinsically for the numeric types.


26    4.4.1      Integer type

27    The set of values for the integer type is a subset of the mathematical integers. A processor shall
28    provide one or more representation methods that define sets of values for data of type integer. Each
29    such method is characterized by a value for a type parameter called the kind type parameter. The kind
30    type parameter of a representation method is returned by the intrinsic inquiry function KIND (13.7.57).
31    The decimal exponent range of a representation method is returned by the intrinsic function RANGE
32    (13.7.92). The intrinsic function SELECTED INT KIND (13.7.101) returns a kind value based on a



      SEP 2002                                       WORKING DRAFT                                         33


      J3/02-007R3                                       WORKING DRAFT                             SEP 2002



 1    specified decimal range requirement. The integer type includes a zero value, which is considered neither
 2    negative nor positive. The value of a signed integer zero is the same as the value of an unsigned integer
 3    zero.

 4    The type specifier for the integer type uses the keyword INTEGER (R503).

 5    If the kind type parameter is not specified, the default kind value is KIND (0) and the data entity is of
 6    type default integer.

 7    Any integer value may be represented as a signed-int-literal-constant .

 8    R402        signed-int-literal-constant     is    [ sign ] int-literal-constant
 9    R403        int-literal-constant            is    digit-string [    kind-param ]
10    R404        kind-param                      is    digit-string
11                                                or scalar-int-constant-name
12    R405        signed-digit-string             is    [ sign ] digit-string
13    R406        digit-string                    is    digit [ digit ] ...
14    R407        sign                            is    +
15                                                or �

16    C403        (R404) A scalar-int-constant-name shall be a named constant of type integer.

17    C404        (R404) The value of kind-param shall be nonnegative.

18    C405        (R403) The value of kind-param shall specify a representation method that exists on the pro-
19                cessor.

20    The optional kind type parameter following digit-string specifies the kind type parameter of the integer
21    constant; if it is not present, the constant is of type default integer.

22    An integer constant is interpreted as a decimal value.

               NOTE 4.6

               Examples of signed integer literal constants are:


               473
               +56
               -101
               21_2
               21_SHORT
               1976354279568241_8


               where SHORT is a scalar integer named constant.


23    R408        boz-literal-constant            is    binary-constant
24                                                or octal-constant
25                                                or hex-constant
26    R409        binary-constant                 is    B ' digit [ digit ] ... '
27                                                or B " digit [ digit ] ... "

28    C406        (R409) digit shall have one of the values 0 or 1.

29    R410        octal-constant                  is    O ' digit [ digit ] ... '
30                                                or O " digit [ digit ] ... "

31    C407        (R410) digit shall have one of the values 0 through 7.




      34                                         WORKING DRAFT                                    SEP 2002


      SEP 2002                                     WORKING DRAFT                                     J3/02-007R3



 1    R411      hex-constant                       is    Z ' hex-digit [ hex-digit ] ... '
 2                                                 or Z " hex-digit [ hex-digit ] ... "
 3    R412      hex-digit                          is    digit
 4                                                 or A
 5                                                 or B
 6                                                 or C
 7                                                 or D
 8                                                 or E
 9                                                 or F

10    Binary, octal and hexadecimal constants are interpreted according to their respective number systems.
11    The hex-digit s A through F represent the numbers ten through fifteen, respectively; they may be repre-
12    sented by their lower-case equivalents.

13    C408      (R408) A boz-literal-constant shall appear only as a data-stmt-constant in a DATA statement, as
14              the actual argument associated with the dummy argument A of the numeric intrinsic functions
15              DBLE, REAL or INT, or as the actual argument associated with the X or Y dummy argument
16              of the intrinsic CMPLX function.


17    4.4.2          Real type

18    The real type has values that approximate the mathematical real numbers. A processor shall provide
19    two or more approximation methods that define sets of values for data of type real. Each such method
20    has a representation method and is characterized by a value for a type parameter called the kind type
21    parameter. The kind type parameter of an approximation method is returned by the intrinsic inquiry
22    function KIND (13.7.57).           The decimal precision and decimal exponent range of an approximation
23    method are returned by the intrinsic functions PRECISION (13.7.86) and RANGE (13.7.92).                     The
24    intrinsic function SELECTED REAL KIND (13.7.102) returns a kind value based on specified precision
25    and decimal range requirements.

           NOTE 4.7

           See C.1.2 for remarks concerning selection of approximation methods.


26    The real type includes a zero value. Processors that distinguish between positive and negative zeros
27    shall treat them as equivalent

28            (1)      in all relational operations,

29            (2)      as actual arguments to intrinsic procedures other than those for which it is explicitly specified
30                     that negative zero is distinguished, and

31            (3)      as the scalar-numeric-expr in an arithmetic IF.


           NOTE 4.8

           On a processor that can distinguish between 0.0 and -0.0,


                ( X >= 0.0 )


           evaluates to true if X = 0.0 or if X = -0.0,


                ( X < 0.0 )


           evaluates to false for X = -0.0, and





      SEP 2002                                             WORKING DRAFT                                           35


      J3/02-007R3                                      WORKING DRAFT                                           SEP 2002



            NOTE 4.8 (cont.)

                IF (X) 1,2,3



            causes a transfer of control to the branch target statement with the statement label "2" for both X = 0.0 and X =

            -0.0.


            In order to distinguish between 0.0 and -0.0, a program should use the SIGN function.
            SIGN(1.0,X) will return -1.0 if X < 0.0 or if the processor distinguishes between 0.0 and -0.0
            and X has the value -0.0.


            NOTE 4.9

            Historically some systems had a distinct negative zero value that presented some difficulties. For-
            tran standards were specified such that these difficulties had to be handled by the processor and
            not the user. The IEEE standard introduced a negative zero with particular properties. For
            example, when the exact result of an operation is negative but rounding produces a zero, the
            value specified by the IEEE standard is -0.0. This standard includes adjustments intended to
            permit IEEE-compliant processors to behave in accordance with that standard without violating
            this standard.


 1    The type specifier for the real type uses the keyword REAL (R503). The keyword DOUBLE PRECISION
 2    (R503) is an alternate specifier for one kind of real type.

 3    If the type keyword REAL is specified and the kind type parameter is not specified, the default kind value
 4    is KIND (0.0) and the data entity is of type default real. If the type keyword DOUBLE PRECISION is
 5    specified, a kind type parameter shall not be specified and the data entity is of type double precision
 6    real. The kind type parameter of such an entity has the value KIND (0.0D0). The decimal precision of
 7    the double precision real approximation method shall be greater than that of the default real method.

 8    R413     signed-real-literal-constant      is    [ sign ] real-literal-constant
 9    R414     real-literal-constant             is    significand [ exponent-letter exponent ] [       kind-param ]
10                                               or digit-string exponent-letter exponent [         kind-param ]
11    R415     significand                        is    digit-string . [ digit-string ]
12                                               or . digit-string
13    R416     exponent-letter                   is    E
14                                               or D
15    R417     exponent                          is    signed-digit-string

16    C409     (R414) If both kind-param and exponent-letter are present, exponent-letter shall be E.

17    C410     (R414) The value of kind-param shall specify an approximation method that exists on the
18             processor.

19    A real literal constant without a kind type parameter is a default real constant if it is without an
20    exponent part or has exponent letter E, and is a double precision real constant if it has exponent letter
21    D. A real literal constant written with a kind type parameter is a real constant with the specified kind
22    type parameter.

23    The exponent represents the power of ten scaling to be applied to the significand or digit string. The
24    meaning of these constants is as in decimal scientific notation.

25    The significand may be written with more digits than a processor will use to approximate the value of
26    the constant.





      36                                       WORKING DRAFT                                                   SEP 2002


      SEP 2002                               WORKING DRAFT                                      J3/02-007R3



           NOTE 4.10

           Examples of signed real literal constants are:


           -12.78
           +1.6E3
           2.1
           -16.E4_8
           0.45D-4
           10.93E7_QUAD
           .123
           3E4


           where QUAD is a scalar integer named constant.


 1    4.4.3        Complex type

 2    The complex type has values that approximate the mathematical complex numbers. The values of a
 3    complex type are ordered pairs of real values. The first real value is called the real part, and the second
 4    real value is called the imaginary part.

 5    Each approximation method used to represent data entities of type real shall be available for both the
 6    real and imaginary parts of a data entity of type complex. A kind type parameter may be specified for
 7    a complex entity and selects for both parts the real approximation method characterized by this kind
 8    type parameter value. The kind type parameter of an approximation method is returned by the intrinsic
 9    inquiry function KIND (13.7.57).

10    The type specifier for the complex type uses the keyword COMPLEX (R503). There is no keyword for
11    double precision complex. If the type keyword COMPLEX is specified and the kind type parameter is
12    not specified, the default kind value is the same as that for default real, the type of both parts is default
13    real, and the data entity is of type default complex.

14    R418     complex-literal-constant      is    ( real-part , imag-part )
15    R419     real-part                     is    signed-int-literal-constant
16                                           or signed-real-literal-constant
17                                           or named-constant
18    R420     imag-part                     is    signed-int-literal-constant
19                                           or signed-real-literal-constant
20                                           or named-constant

21    C411     (R418) Each named constant in a complex literal constant shall be of type integer or real.

22    If the real part and the imaginary part of a complex literal constant are both real, the kind type
23    parameter value of the complex literal constant is the kind type parameter value of the part with the
24    greater decimal precision; if the precisions are the same, it is the kind type parameter value of one of the
25    parts as determined by the processor. If a part has a kind type parameter value different from that of
26    the complex literal constant, the part is converted to the approximation method of the complex literal
27    constant.

28    If both the real and imaginary parts are integer, they are converted to the default real approximation
29    method and the constant is of type default complex. If only one of the parts is an integer, it is converted
30    to the approximation method selected for the part that is real and the kind type parameter value of the
31    complex literal constant is that of the part that is real.





      SEP 2002                                       WORKING DRAFT                                            37


      J3/02-007R3                                         WORKING DRAFT                                            SEP 2002



            NOTE 4.11

            Examples of complex literal constants are:


            (1.0, -1.0)
            (3, 3.1E6)
            (4.0_4, 3.6E7_8)
            ( 0., PI)


            where PI is a previously declared named real constant.


 1    4.4.4          Character type

 2    The character type has a set of values composed of character strings. A character string is a sequence
 3    of characters, numbered from left to right 1, 2, 3, ... up to the number of characters in the string. The
 4    number of characters in the string is called the length of the string. The length is a type parameter; its
 5    value is greater than or equal to zero. Strings of different lengths are all of type character.

 6    A processor shall provide one or more representation methods that define sets of values for data of
 7    type character. Each such method is characterized by a value for a type parameter called the kind type
 8    parameter. The kind type parameter of a representation method is returned by the intrinsic inquiry
 9    function KIND (13.7.57). The intrinsic function SELECTED CHAR KIND (13.7.100) returns a kind
10    value based on the name of a character type. Any character of a particular representation method
11    representable in the processor may occur in a character string of that representation method.

12    The character set defined by ISO/IEC 646:1991 is referred to as the ASCII character set or the
13    ASCII character type. The character set defined by ISO/IEC 10646-1:2000 UCS-4 is referred to as
14    the ISO 10646 character set or the ISO 10646 character type.

15    The type specifier for the character type uses the keyword CHARACTER (R503).

16    If the kind type parameter is not specified, the default kind value is KIND ('A') and the data entity is
17    of type default character.

18    A character literal constant is written as a sequence of characters, delimited by either apostrophes
19    or quotation marks.

20    R421      char-literal-constant               is    [ kind-param      ] ' [ rep-char ] ... '
21                                                  or [ kind-param         ] " [ rep-char ] ... "

22    C412      (R421) The value of kind-param shall specify a representation method that exists on the pro-
23              cessor.

24    The optional kind type parameter preceding the leading delimiter specifies the kind type parameter of
25    the character constant; if it is not present, the constant is of type default character.

26    For the type character with kind kind-param, if present, and for type default character otherwise, a
27    representable character, rep-char , is defined as follows:

28            (1)      In free source form, it is any graphic character in the processor-dependent character set.

29            (2)      In fixed source form, it is any character in the processor-dependent character set. A processor may restrict

30                     the occurrence of some or all of the control characters.


            NOTE 4.12

            Fortran 77 allowed any character to occur in a character context. This standard allows a source





      38                                         WORKING DRAFT                                                     SEP 2002


      SEP 2002                                  WORKING DRAFT                                     J3/02-007R3



           NOTE 4.12 (cont.)

           program to contain characters of more than one kind. Some processors may identify characters of
           nondefault kinds by control characters (called "escape" or "shift" characters). It is difficult, if not
           impossible, to process, edit, and print files where some instances of control characters have their
           intended meaning and some instances may not. Almost all control characters have uses or effects
           that effectively preclude their use in character contexts and this is why free source form allows only
           graphic characters as representable characters. Nevertheless, for compatibility with Fortran 77, control
           characters remain permitted in principle in fixed source form.


 1    The delimiting apostrophes or quotation marks are not part of the value of the character literal constant.

 2    An apostrophe character within a character constant delimited by apostrophes is represented by two
 3    consecutive apostrophes (without intervening blanks); in this case, the two apostrophes are counted as
 4    one character. Similarly, a quotation mark character within a character constant delimited by quotation
 5    marks is represented by two consecutive quotation marks (without intervening blanks) and the two
 6    quotation marks are counted as one character.

 7    A zero-length character literal constant is represented by two consecutive apostrophes (without inter-
 8    vening blanks) or two consecutive quotation marks (without intervening blanks) outside of a character
 9    context.

10    The intrinsic operation concatenation (//) is defined between two data entities of type character (7.2.2)
11    with the same kind type parameter.

           NOTE 4.13

           Examples of character literal constants are:


           "DON'T"
           'DON''T'


           both of which have the value DON'T and


           ''


           which has the zero-length character string as its value.


           NOTE 4.14

           Examples of nondefault character literal constants, where the processor supports the corresponding
           character sets, are:

           BOLD FACE 'This is in bold face'

           ITALICS 'This is in italics'

           where BOLD FACE and ITALICS are named constants whose values are the kind type parameters
           for bold face and italic characters, respectively.


12    4.4.4.1     Collating sequence

13    Each implementation defines a collating sequence for the character set of each kind of character. A
14    collating sequence is a one-to-one mapping of the characters into the nonnegative integers such that
15    each character corresponds to a different nonnegative integer. The intrinsic functions CHAR (13.7.19)
16    and ICHAR (13.7.50) provide conversions between the characters and the integers according to this
17    mapping.



      SEP 2002                                          WORKING DRAFT                                           39


      J3/02-007R3                                    WORKING DRAFT                                  SEP 2002



            NOTE 4.15

            For example:


                ICHAR ( 'X' )


            returns the integer value of the character 'X' according to the collating sequence of the processor.


 1    For the default character type, the only constraints on the collating sequence are the following:

 2            (1)      ICHAR ('A') < ICHAR ('B') < ... < ICHAR ('Z') for the twenty-six upper-case letters.

 3            (2)      ICHAR ('0') < ICHAR ('1') < ... < ICHAR ('9') for the ten digits.

 4            (3)      ICHAR (' ') < ICHAR ('0') < ICHAR ('9') < ICHAR ('A') or

 5                     ICHAR (' ') < ICHAR ('A') < ICHAR ('Z') < ICHAR ('0').

 6            (4)      ICHAR ('a') < ICHAR ('b') < ... < ICHAR ('z') for the twenty-six lower-case letters.

 7            (5)      ICHAR (' ') < ICHAR ('0') < ICHAR ('9') < ICHAR ('a') or

 8                     ICHAR (' ') < ICHAR ('a') < ICHAR ('z') < ICHAR ('0').

 9    Except for blank, there are no constraints on the location of the special characters and underscore in
10    the collating sequence, nor is there any specified collating sequence relationship between the upper-case
11    and lower-case letters.

12    The sequence of numerical codes defined by the ASCII standard is called the ASCII collating sequence
13    in this standard.

            NOTE 4.16

            The intrinsic functions ACHAR (13.7.2) and IACHAR (13.7.45) provide conversions between these
            characters and the integers according to the ASCII collating sequence.


14    The intrinsic functions LGT, LGE, LLE, and LLT (13.7.61-13.7.64) provide comparisons between strings
15    based on the ASCII collating sequence. International portability is guaranteed if the set of characters
16    used is limited to the letters, digits, underscore, and special characters.


17    4.4.5          Logical type

18    The logical type has two values, which represent true and false.

19    A processor shall provide one or more representation methods for data of type logical. Each such
20    method is characterized by a value for a type parameter called the kind type parameter. The kind type
21    parameter of a representation method is returned by the intrinsic inquiry function KIND (13.7.57).

22    The type specifier for the logical type uses the keyword LOGICAL (R503).

23    If the kind type parameter is not specified, the default kind value is KIND (.FALSE.) and the data entity
24    is of type default logical.

25    R422      logical-literal-constant       is    .TRUE. [    kind-param ]
26                                             or .FALSE. [      kind-param ]

27    C413      (R422) The value of kind-param shall specify a representation method that exists on the pro-
28              cessor.

29    The optional kind type parameter following the trailing delimiter specifies the kind type parameter of
30    the logical constant; if it is not present, the constant is of type default logical.

31    The intrinsic operations defined for data entities of logical type are: negation (.NOT.), conjunction



      40                                    WORKING DRAFT                                           SEP 2002


      SEP 2002                              WORKING DRAFT                                            J3/02-007R3



 1    (.AND.), inclusive disjunction (.OR.), logical equivalence (.EQV.), and logical nonequivalence (.NEQV.)
 2    as described in 7.2.4. There is also a set of intrinsically defined relational operators that compare the
 3    values of data entities of other types and yield a value of type default logical. These operations are
 4    described in 7.2.3.


 5    4.5       Derived types

 6    Additional types may be derived from the intrinsic types and other derived types. A type definition is
 7    required to define the name of the type and the names and attributes of its components.

 8    The type specifier for a derived type uses the keyword TYPE followed by the name of the type in
 9    parentheses (R503).

10    A derived type may be parameterized by multiple type parameters, each of which is defined to be either
11    a kind or nonkind type parameter. There is no concept of a default value for a type parameter of a
12    derived type; it is required to explicitly specify, assume, or defer the values of all type parameters of a
13    derived-type entity.

14    The ultimate components of an object of derived type are the components that are of intrinsic type
15    or have the POINTER or ALLOCATABLE attribute, plus the ultimate components of the components
16    of the object that are of derived type and have neither the ALLOCATABLE nor POINTER attribute.

             NOTE 4.17

             The ultimate components of objects of the derived type kids defined below are name, age, and
             other kids.


             type :: person
               character(len=20) :: name
               integer :: age
             end type person


             type :: kids
               type(person) :: oldest_child
               type(person), allocatable, dimension(:) :: other_kids
             end type kids



17    By default, no storage sequence is implied by the order of the component definitions. However, a storage
18    order is implied for a sequence type (4.5.1.9). If the derived type has the BIND attribute, the storage
19    sequence is that required by the companion processor (2.5.10, 15.2.3).

20    A derived type may have procedures bound to it. A type-bound procedure is accessible when an object
21    of the type is accessible.


22    4.5.1      Derived-type definition

23    R423      derived-type-def            is    derived-type-stmt
24                                                    [ type-param-def-stmt ] ...
25                                                    [ data-component-part ]
26                                                    [ type-bound-procedure-part ]
27                                                    end-type-stmt
28    R424      derived-type-stmt           is    TYPE [ [ , type-attr-spec-list ] :: ] type-name
29                                                   [ ( type-param-name-list ) ]
30    R425      type-attr-spec              is    access-spec
31                                          or EXTENSIBLE



      SEP 2002                                      WORKING DRAFT                                            41


      J3/02-007R3                                WORKING DRAFT                                        SEP 2002



 1                                         or EXTENDS ( [ access-spec :: ] parent-type-name
 2                                                 [ = initialization-expr ] )
 3                                         or BIND (C)

 4    C414    (R424) A derived type type-name shall not be the same as the name of any intrinsic type defined
 5            in this standard.

 6    C415    (R424) The same type-attr-spec shall not appear more than once in a given derived-type-stmt .

 7    C416    (R424) EXTENSIBLE and EXTENDS shall not both appear.

 8    C417    (R425) A parent-type-name shall be the name of an accessible extensible type (4.5.3).

 9    C418    (R423) If EXTENDS or EXTENSIBLE appears, neither BIND(C) nor SEQUENCE shall appear.

10    R426    type-param-def-stmt          is    INTEGER [ kind-selector ] , type-param-attr-spec ::
11                                                  type-param-name-list

12    C419    (R426) A type-param-name in a type-param-def-stmt in a derived-type-def shall be one of the
13            type-param-names in the derived-type-stmt of that derived-type-def .

14    C420    (R426) Each type-param-name in the derived-type-stmt in a derived-type-def shall appear as a
15            type-param-name in a type-param-def-stmt in that derived-type-def .

16    R427    type-param-attr-spec         is    KIND
17                                         or NONKIND
18    R428    data-component-part          is    [ private-sequence-stmt ] ...
19                                                   [ component-def-stmt ] ...
20    R429    private-sequence-stmt        is    PRIVATE
21                                         or SEQUENCE

22    C421    (R429) A PRIVATE statement is permitted only if the type definition is within the specification
23            part of a module.

24    C422    (R428) The same private-sequence-stmt shall not appear more than once in a given derived-type-
25            def .

26    C423    (R428) If SEQUENCE appears, all derived types specified in component definitions shall be
27            sequence types.

28    C424    (R423) If SEQUENCE appears, a type-bound-procedure-part shall not appear.

29    R430    component-def-stmt           is    data-component-def-stmt
30                                         or proc-component-def-stmt
31    R431    data-component-def-stmt      is    declaration-type-spec [ [ , component-attr-spec-list ] :: ]
32                                                  component-decl -list
33    R432    component-attr-spec          is    POINTER
34                                         or DIMENSION ( component-array-spec )
35                                         or ALLOCATABLE
36                                         or access-spec
37    R433    component-decl               is    component-name [ ( component-array-spec ) ]
38                                                  [ * char-length ] [ component-initialization ]
39    R434    component-array-spec         is    explicit-shape-spec-list
40                                         or deferred-shape-spec-list
41    R435    component-initialization     is    = initialization-expr
42                                         or => null-init

43    C425    (R431) No component-attr-spec shall appear more than once in a given component-def-stmt .



      42                                  WORKING DRAFT                                               SEP 2002


      SEP 2002                              WORKING DRAFT                                           J3/02-007R3



 1    C426    (R431) A component declared with the CLASS keyword (5.1.1.8) shall have the ALLOCATABLE
 2            or POINTER attribute.

 3    C427    (R431) If the POINTER attribute is not specified for a component, the declaration-type-spec in
 4            the component-def-stmt shall specify an intrinsic type or a previously defined derived type.

 5    C428    (R431) If the POINTER attribute is specified for a component, the declaration-type-spec in the
 6            component-def-stmt shall specify an intrinsic type or any accessible derived type including the
 7            type being defined.

 8    C429    (R431) If the POINTER or ALLOCATABLE attribute is specified, each component-array-spec
 9            shall be a deferred-shape-spec-list.

10    C430    (R431) If neither the POINTER attribute nor the ALLOCATABLE attribute is specified, each
11            component-array-spec shall be an explicit-shape-spec-list.

12    C431    (R434) Each bound in the explicit-shape-spec shall either be an initialization expression or be a
13            specification expression that does not contain references to specification functions or any object
14            designators other than named constants or subobjects thereof.

15    C432    (R431) A component shall not have both the ALLOCATABLE and the POINTER attribute.

16    C433    (R433) The * char-length option is permitted only if the type specified is character.

17    C434    (R430) Each type-param-value within a component-def-stmt shall either be a colon, be an ini-
18            tialization expression, or be a specification expression that contains neither references to speci-
19            fication functions nor any object designators other than named constants or subobjects thereof.

         NOTE 4.18

         Since a type parameter is not an object, a bound for an explicit-shape-spec or a type-param-value
         may contain a type-param-name.


20    C435    (R431) If component-initialization appears, a double-colon separator shall appear before the
21            component-decl -list.

22    C436    (R431) If => appears in component-initialization, POINTER shall appear in the component-
23            attr-spec-list. If = appears in component-initialization, POINTER or ALLOCATABLE shall
24            not appear in the component-attr-spec-list.

25    R436    proc-component-def-stmt       is    PROCEDURE ( [ proc-interface ] ) ,
26                                                    proc-component-attr-spec-list :: proc-decl -list

         NOTE 4.19

         See 12.3.2.3 for definitions of proc-interface and proc-decl .


27    R437    proc-component-attr-spec      is    POINTER
28                                          or PASS [ (arg-name) ]
29                                          or NOPASS
30                                          or access-spec

31    C437    (R436) The same proc-component-attr-spec shall not appear more than once in a given proc-
32            component-def-stmt .

33    C438    (R436) POINTER shall appear in each proc-component-attr-spec-list.

34    C439    (R436) If the procedure pointer component has an implicit interface or has no arguments,




      SEP 2002                                        WORKING DRAFT                                          43


      J3/02-007R3                                    WORKING DRAFT                                       SEP 2002



 1            NOPASS shall be specified.

 2    C440    (R436) If PASS (arg-name) appears, the interface shall have a dummy argument named arg-
 3            name.

 4    C441    (R436) PASS and NOPASS shall not both appear in the same proc-component-attr-spec-list.

 5    R438    type-bound-procedure-part        is    contains-stmt
 6                                                       [ binding-private-stmt ]
 7                                                       proc-binding-stmt
 8                                                       [ proc-binding-stmt ] ...
 9    R439    binding-private-stmt             is    PRIVATE

10    C442    (R438) A binding-private-stmt is permitted only if the type definition is within the specification
11            part of a module.

12    R440    proc-binding-stmt                is    specific-binding
13                                             or generic-binding
14                                             or final-binding

15    C443    (R440) No proc-binding-stmt shall specify a binding that overrides (4.5.3.2) one that is inherited
16            (4.5.3.1) from the parent type and has the NON OVERRIDABLE binding attribute.

17    R441    specific-binding                  is    PROCEDURE
18                                                     [ [ , binding-attr -list ] :: ] binding-name [ => binding ]

19    C444    (R441) If => binding appears, the double-colon separator shall appear.

20    If => binding does not appear, it is as though it had appeared with a procedure name the same as the
21    binding name.

22    R442    generic-binding                  is    GENERIC
23                                                     [, binding-attr -list ] :: generic-spec => binding-list

24    C445    (R442) If generic-spec is generic-name, generic-name shall not be the name of a nongeneric
25            binding of the type.

26    C446    (R442) If generic-spec is OPERATOR ( defined-operator ), the interface of each binding shall
27            be as specified in 12.3.2.1.1.

28    C447    (R442) If generic-spec is ASSIGNMENT ( = ), the interface of each binding shall be as specified
29            in 12.3.2.1.2.

30    C448    (R442) If generic-spec is dtio-generic-spec, the interface of each binding shall be as specified in
31            9.5.3.7. The type of the dtv argument shall be type-name.

32    R443    final-binding                     is    FINAL [ :: ] final-subroutine-name-list

33    C449    (R443) A final-subroutine-name shall be the name of a module procedure with exactly one
34            dummy argument. That argument shall be nonoptional and shall be a nonpointer, nonallocat-
35            able, nonpolymorphic variable of the derived type being defined. All nonkind type parameters
36            of the dummy argument shall be assumed. The dummy argument shall not be INTENT(OUT).

37    C450    (R443) A final-subroutine-name shall not be one previously specified as a final subroutine for
38            that type.

39    C451    (R443) A final subroutine shall not have a dummy argument with the same kind type parameters
40            and rank as the dummy argument of another final subroutine of that type.




      44                                   WORKING DRAFT                                                 SEP 2002


      SEP 2002                                 WORKING DRAFT                                       J3/02-007R3



 1    R444       binding-attr                  is    PASS [ (arg-name) ]
 2                                             or NOPASS
 3                                             or NON OVERRIDABLE
 4                                             or access-spec

 5    C452       (R444) The same binding-attr shall not appear more than once in a given binding-attr -list.

 6    C453       (R441, R442) If the interface of the binding has no dummy argument of the type being defined,
 7               NOPASS shall appear.

 8    C454       (R441, R442) If PASS (arg-name) appears, the interface of the binding shall have a dummy
 9               argument named arg-name.

10    C455       (R440) PASS and NOPASS shall not both appear in the same binding-attr -list.

11    C456       (R442) A generic-binding for which generic-spec is not generic-name shall have a passed-object
12               dummy argument (4.5.1.6).

13    C457       (R442) An overriding binding shall have a passed-object dummy argument if and only if the
14               binding that it overrides has a passed-object dummy argument.

15    C458       (R442) Within the specification-part of a module, each generic-binding shall specify, either
16               implicitly or explicitly, the same accessibility as every other generic-binding in the same derived-
17               type-def that has the same generic-spec.

18    R445       binding                       is    procedure-name

19    C459       (R445) The procedure-name shall be the name of an accessible module procedure or an external
20               procedure that has an explicit interface.

21    R446       end-type-stmt                 is    END TYPE [ type-name ]

22    C460       (R446) If END TYPE is followed by a type-name, the type-name shall be the same as that in
23               the corresponding derived-type-stmt .

24    Derived types with the BIND attribute are subject to additional constraints as specified in 15.2.3.

           NOTE 4.20

           An example of a derived-type definition is:


           TYPE PERSON
                 INTEGER AGE
                 CHARACTER (LEN = 50) NAME
           END TYPE PERSON


           An example of declaring a variable CHAIRMAN of type PERSON is:


           TYPE (PERSON) :: CHAIRMAN



25    4.5.1.1     Derived-type parameters

26    The derived type is parameterized if the derived-type-stmt has any type-param-names.

27    Each type parameter is itself of type integer.

28    A type parameter is either a kind type parameter or a nonkind type parameter (4.2). If it is a kind
29    parameter it is said to have the KIND attribute. Its type-param-attr-spec explicitly specifies whether a



      SEP 2002                                         WORKING DRAFT                                             45


      J3/02-007R3                                  WORKING DRAFT                                     SEP 2002



 1    type parameter is kind or nonkind.

 2    A type parameter may be used as a primary in a specification expression (7.1.6) in the derived-type-
 3    def . A kind type parameter may also be used as a primary in an initialization expression (7.1.7) in the
 4    derived-type-def .

            NOTE 4.21

            The following example uses derived-type parameters.


                  TYPE humongous_matrix(k, d)
                    INTEGER, KIND :: k
                    INTEGER(selected_int_kind(12)), NONKIND :: d
                       !-- Specify a nondefault kind for d.
                    REAL(k) :: element(d,d)
                  END TYPE


            In the following example, dim is declared to be a kind parameter, allowing generic overloading of
            procedures distinguished only by dim.


                  TYPE general_point(dim)
                    INTEGER, KIND :: dim
                    REAL :: coordinates(dim)
                  END TYPE



 5    4.5.1.2    Default initialization for components

 6    Default initialization provides a means of automatically initializing pointer components to be disas-
 7    sociated (4.5.1.4), and nonpointer nonallocatable components to have a particular value. Allocatable
 8    components are always initialized to not allocated.

 9    If initialization-expr appears for a nonpointer component, that component in any object of the type
10    is initially defined (16.5.3) or becomes defined as specified in 16.5.5 with the value determined from
11    initialization-expr . An initialization-expr in the EXTENDS type-attr-spec is for the parent component
12    (4.5.3.1). If necessary, the value is converted according to the rules of intrinsic assignment (7.4.1.3) to
13    a value that agrees in type, type parameters, and shape with the component. If the component is of a
14    type for which default initialization is specified for a component, the default initialization specified by
15    initialization-expr overrides the default initialization specified for that component. When one initializa-
16    tion overrides another it is as if only the overriding initialization were specified (see Note 4.23). Explicit
17    initialization in a type declaration statement (5.1) overrides default initialization (see Note 4.22). Unlike
18    explicit initialization, default initialization does not imply that the object has the SAVE attribute.

19    A subcomponent (6.1.2) is default-initialized if the type of the object of which it is a component
20    specifies default initialization for that component, and the subcomponent is not a subobject of an object
21    that is default-initialized or explicitly initialized.

            NOTE 4.22

            It is not required that initialization be specified for each component of a derived type. For example:



            TYPE DATE
                 INTEGER DAY
                 CHARACTER (LEN = 5) MONTH





      46                                    WORKING DRAFT                                            SEP 2002


     SEP 2002                              WORKING DRAFT                                       J3/02-007R3



          NOTE 4.22 (cont.)

                INTEGER :: YEAR = 1994             ! Partial default initialization
          END TYPE DATE


          In the following example, the default initial value for the YEAR component of TODAY is overridden
          by explicit initialization in the type declaration statement:


          TYPE (DATE), PARAMETER :: TODAY = DATE (21, "Feb.", 1995)



          NOTE 4.23

          The default initial value of a component of derived type may be overridden by default initialization
          specified in the definition of the type. Continuing the example of Note 4.22:


          TYPE SINGLE_SCORE
                TYPE(DATE) :: PLAY_DAY = TODAY
                INTEGER SCORE
                TYPE(SINGLE_SCORE), POINTER :: NEXT => NULL ( )
          END TYPE SINGLE_SCORE
          TYPE(SINGLE_SCORE) SETUP


          The PLAY DAY component of SETUP receives its initial value from TODAY, overriding the
          initialization for the YEAR component.


          NOTE 4.24

          Arrays of structures may be declared with elements that are partially or totally initialized by
          default. Continuing the example of Note 4.23 :


          TYPE MEMBER (NAME_LEN)
                INTEGER, NONKIND :: NAME_LEN
                CHARACTER (LEN = NAME_LEN) NAME = ''
                INTEGER :: TEAM_NO, HANDICAP = 0
                TYPE (SINGLE_SCORE), POINTER :: HISTORY => NULL ( )
          END TYPE MEMBER
          TYPE (MEMBER) LEAGUE (36)                ! Array of partially initialized elements
          TYPE (MEMBER) :: ORGANIZER = MEMBER ("I. Manage",1,5,NULL ( ))


          ORGANIZER is explicitly initialized, overriding the default initialization for an object of type
          MEMBER.

          Allocated objects may also be initialized partially or totally. For example:


          ALLOCATE (ORGANIZER % HISTORY)           ! A partially initialized object of type
                                                   ! SINGLE_SCORE is created.



1    4.5.1.3    Array components

2    A data component is an array if its component-decl contains a component-array-spec or its data-component-
3    def-stmt contains the DIMENSION attribute. If the component-decl contains a component-array-spec,
4    it specifies the array rank, and if the array is explicit shape (5.1.2.5.1), the array bounds; otherwise, the
5    component-array-spec in the DIMENSION attribute specifies the array rank, and if the array is explicit
6    shape, the array bounds.




     SEP 2002                                     WORKING DRAFT                                              47


     J3/02-007R3                                WORKING DRAFT                                        SEP 2002



           NOTE 4.25

           A type definition may have a component that is an array. For example:


           TYPE LINE
                REAL, DIMENSION (2, 2) :: COORD           !
                                                          ! COORD(:,1) has the value of (/X1, Y1/)
                                                          ! COORD(:,2) has the value of (/X2, Y2/)
                REAL                       :: WIDTH       ! Line width in centimeters
                INTEGER                    :: PATTERN     ! 1 for solid, 2 for dash, 3 for dot
           END TYPE LINE


           An example of declaring a variable LINE SEGMENT to be of the type LINE is:


           TYPE (LINE)             :: LINE_SEGMENT


           The scalar variable LINE SEGMENT has a component that is an array. In this case, the array
           is a subobject of a scalar. The double colon in the definition for COORD is required; the double
           colon in the definition for WIDTH and PATTERN is optional.


           NOTE 4.26

           A derived type may have a component that is allocatable. For example:


           TYPE STACK
                INTEGER                 :: INDEX
                INTEGER, ALLOCATABLE :: CONTENTS (:)
           END TYPE STACK


           For each scalar variable of type STACK, the shape of the component CONTENTS is determined
           by execution of an ALLOCATE statement or assignment statement, or by argument association.


           NOTE 4.27

           Default initialization of an explicit-shape array component may be specified by an initialization
           expression consisting of an array constructor (4.8), or of a single scalar that becomes the value of
           each array element.


1    4.5.1.4    Pointer components

2    A component is a pointer if its component-attr-spec-list contains the POINTER attribute. Pointers have
3    an association status of associated, disassociated, or undefined. If no default initialization is specified, the
4    initial association status is undefined. To specify that the default initial status of a pointer component is
5    to be disassociated, the pointer assignment symbol (=>) shall be followed by a reference to the intrinsic
6    function NULL ( ) with no argument. No mechanism is provided to specify a default initial status of
7    associated.

           NOTE 4.28

           A derived type may have a component that is a pointer. For example:


           TYPE REFERENCE
                INTEGER                                  :: VOLUME, YEAR, PAGE
                CHARACTER (LEN = 50)                     :: TITLE





     48                                  WORKING DRAFT                                               SEP 2002


     SEP 2002                             WORKING DRAFT                                    J3/02-007R3



         NOTE 4.28 (cont.)

                 CHARACTER, DIMENSION (:), POINTER :: ABSTRACT => NULL()
         END TYPE REFERENCE


         Any object of type REFERENCE will have the four nonpointer components VOLUME, YEAR,
         PAGE, and TITLE, plus a pointer to an array of characters holding ABSTRACT. The size of this
         target array will be determined by the length of the abstract. The space for the target may be
         allocated (6.3.1) or the pointer component may be associated with a target by a pointer assignment
         statement (7.4.2).


         NOTE 4.29

         A pointer component of a derived type may have as its target an object of that derived type. The
         type definition may specify that in objects declared to be of this type, such a pointer is default
         initialized to disassociated. For example:


         TYPE NODE
                 INTEGER              :: VALUE = 0
                 TYPE (NODE), POINTER :: NEXT_NODE => NULL ( )
         END TYPE


         A type such as this may be used to construct linked lists of objects of type NODE. See C.1.4 for
         an example.


1    4.5.1.5     Type-bound procedures

2    Each binding in a proc-binding-stmt specifies a type-bound procedure. A generic-binding specifies a
3    type-bound generic interface.

4    The interface of a binding is that of the procedure specified by procedure-name.

         NOTE 4.30

         An example of a type and a type-bound procedure is:


         TYPE, EXTENSIBLE :: POINT
                REAL :: X, Y
         CONTAINS
                PROCEDURE, PASS :: LENGTH => POINT_LENGTH
         END TYPE POINT
         ...


         and in the module-subprogram-part of the same module:


         REAL FUNCTION POINT_LENGTH (A, B)
                CLASS (POINT), INTENT (IN) :: A, B
                POINT_LENGTH = SQRT ( (A%X - B%X)**2 + (A%Y - B%Y)**2 )
         END FUNCTION POINT_LENGTH



5    The same generic-spec may be used in several generic-bindings within a single derived-type definition.





     SEP 2002                                    WORKING DRAFT                                          49


      J3/02-007R3                                 WORKING DRAFT                                        SEP 2002



 1    4.5.1.6     The passed-object dummy argument

 2    A passed-object dummy argument is a distinguished dummy argument of a procedure pointer
 3    component or type-bound procedure. It affects procedure overriding (4.5.3.2) and argument association
 4    (12.4.1.1).

 5    If NOPASS is specified, the procedure pointer component or type-bound procedure has no passed-object
 6    dummy argument.

 7    If neither PASS nor NOPASS is specified or PASS is specified without arg-name, the first dummy argu-
 8    ment of a procedure pointer component or type-bound procedure is its passed-object dummy argument.

 9    If PASS (arg-name) is specified, the dummy argument named arg-name is the passed-object dummy
10    argument of the procedure pointer component or named type-bound procedure.

11    C461       The passed-object dummy argument shall be a scalar, nonpointer, nonallocatable dummy data
12               object with the same declared type as the type being defined; all of its nonkind type parameters
13               shall be assumed; it shall be polymorphic if and only if the type being defined is extensible.

            NOTE 4.31

            If a procedure is bound to several types as a type-bound procedure, different dummy arguments
            might be the passed-object dummy argument in different contexts.


14    4.5.1.7     Final subroutines

15    The FINAL keyword specifies a list of final subroutines. A final subroutine might be executed when
16    a data entity of that type is finalized (4.5.10).

17    A derived type is finalizable if it has any final subroutines or if it has any nonpointer, nonallocatable
18    component whose type is finalizable. A nonpointer data entity is finalizable if its type is finalizable.

            NOTE 4.32

            Final subroutines are effectively always "accessible". They are called for entity finalization regard-
            less of the accessibility of the type, its other type-bound procedure bindings, or the subroutine
            name itself.


            NOTE 4.33

            Final subroutines are not inherited through type extension and cannot be overridden. The final
            subroutines of the parent type are called after calling any additional final subroutines of an extended
            type.


19    4.5.1.8     Accessibility

20    By default, the names of derived types defined in the specification part of a module are accessible
21    (5.1.2.1, 5.2.1) in any scoping unit that accesses the module. This default may be changed to restrict
22    the accessibility of such type names to the host module itself. The name of a particular derived type
23    may be declared to be public or private regardless of the default accessibility declared for the module.
24    In addition, a type name may be accessible while some or all of its components are private.

25    The accessibility of a derived type name may be declared explicitly by an access-spec in its derived-type-
26    stmt or in an access-stmt (5.2.1). The accessibility is the default if it is not declared explicitly. If a type
27    definition is private, then the type name, and thus the structure constructor (4.5.8) for the type, are
28    accessible only within the module containing the definition.

29    The default accessibility for the components of a type is private if the data-component-part contains a



      50                                   WORKING DRAFT                                               SEP 2002


     SEP 2002                                WORKING DRAFT                                         J3/02-007R3



1    PRIVATE statement, and public otherwise. The default accessibility for the procedure bindings of a
2    type is private if the type-bound-procedure-part contains a PRIVATE statement, and public otherwise.
3    The accessibility of a component or procedure binding may be explicitly declared by an access-spec;
4    otherwise its accessibility is the default for the type definition in which it is declared.

5    If a component is private, that component name is accessible only within the module containing the
6    definition.

          NOTE 4.34

          Type parameters are not components. They are effectively always public.


7    A public type-bound procedure is accessible via any accessible object of the type. A private type-bound
8    procedure is accessible only within the module containing the type definition.

          NOTE 4.35

          The accessibility of a type-bound procedure is not affected by a PRIVATE statement in the data-
          component-part ; the accessibility of a data component is not affected by a PRIVATE statement in
          the type-bound-procedure-part .


          NOTE 4.36

          The accessibility of the components of a type is independent of the accessibility of the type name.
          It is possible to have all four combinations: a public type name with a public component, a private
          type name with a private component, a public type name with a private component, and a private
          type name with a public component.


          NOTE 4.37

          An example of a type with private components is:


          MODULE DEFINITIONS
             TYPE POINT
                   PRIVATE
                   REAL :: X, Y
             END TYPE POINT
          END MODULE DEFINITIONS


          Such a type definition is accessible in any scoping unit accessing the module via a USE statement;
          however, the components X and Y are accessible only within the module.


          NOTE 4.38

          An example of a type with a private name is:


          TYPE, PRIVATE :: AUXILIARY
             LOGICAL :: DIAGNOSTIC
             CHARACTER (LEN = 20) :: MESSAGE
          END TYPE AUXILIARY


          Such a type would be accessible only within the module in which it is defined.





     SEP 2002                                      WORKING DRAFT                                           51


     J3/02-007R3                                WORKING DRAFT                                      SEP 2002



           NOTE 4.39

           The following example illustrates the use of an individual component access-spec to override the
           default accessibility:


                 TYPE MIXED
                    PRIVATE
                    INTEGER :: I
                    INTEGER, PUBLIC :: J
                 END TYPE MIXED


                 TYPE (MIXED) :: M


           The component M%J is accessible in any scoping unit where M is accessible; M%I is accessible
           only within the module containing the TYPE MIXED definition.


1    4.5.1.9    Sequence type

2    If the SEQUENCE statement is present, the type is a sequence type. The order of the component
3    definitions in a sequence type specifies a storage sequence for objects of that type. If there are no type
4    parameters and all of the ultimate components of objects of the type are of type default integer, default
5    real, double precision real, default complex, or default logical and are not pointers or allocatable, the
6    type is a numeric sequence type. If there are no type parameters and all of the ultimate components
7    of objects of the type are of type default character and are not pointers or allocatable, the type is a
8    character sequence type.

           NOTE 4.40

           An example of a numeric sequence type is:


           TYPE NUMERIC_SEQ
                SEQUENCE
                INTEGER :: INT_VAL
                REAL        :: REAL_VAL
                LOGICAL :: LOG_VAL
           END TYPE NUMERIC_SEQ



           NOTE 4.41

           A structure resolves into a sequence of components. Unless the structure includes a SEQUENCE
           statement, the use of this terminology in no way implies that these components are stored in
           this, or any other, order. Nor is there any requirement that contiguous storage be used. The
           sequence merely refers to the fact that in writing the definitions there will necessarily be an order
           in which the components appear, and this will define a sequence of components. This order is of
           limited significance since a component of an object of derived type will always be accessed by a
           component name except in the following contexts: the sequence of expressions in a derived-type
           value constructor, intrinsic assignment, the data values in namelist input data, and the inclusion
           of the structure in an input/output list of a formatted data transfer, where it is expanded to this
           sequence of components. Provided the processor adheres to the defined order in these cases, it is
           otherwise free to organize the storage of the components for any nonsequence structure in memory
           as best suited to the particular architecture.





     52                                    WORKING DRAFT                                           SEP 2002


      SEP 2002                              WORKING DRAFT                                      J3/02-007R3



 1    4.5.2    Determination of derived types

 2    Derived-type definitions with the same type name may appear in different scoping units, in which case
 3    they may be independent and describe different derived types or they may describe the same type.

 4    Two data entities have the same type if they are declared with reference to the same derived-type
 5    definition. The definition may be accessed from a module or from a host scoping unit. Data entities in
 6    different scoping units also have the same type if they are declared with reference to different derived-type
 7    definitions that specify the same type name, all have the SEQUENCE property or all have the BIND
 8    attribute, have no components with PRIVATE accessibility, and have type parameters and components
 9    that agree in order, name, and attributes. Otherwise, they are of different derived types. A data entity
10    declared using a type with the SEQUENCE property or with the BIND attribute is not of the same type
11    as an entity of a type declared to be PRIVATE or that has any components that are PRIVATE.

           NOTE 4.42

           An example of declaring two entities with reference to the same derived-type definition is:


           TYPE POINT
               REAL      X,    Y
           END TYPE POINT
           TYPE (POINT) :: X1
           CALL SUB (X1)
               ...
           CONTAINS
               SUBROUTINE SUB (A)
                  TYPE (POINT) :: A
                       ...
               END SUBROUTINE SUB


           The definition of derived type POINT is known in subroutine SUB by host association. Because
           the declarations of X1 and A both reference the same derived-type definition, X1 and A have the
           same type. X1 and A also would have the same type if the derived-type definition were in a module
           and both SUB and its containing program unit accessed the module.


           NOTE 4.43

           An example of data entities in different scoping units having the same type is:


           PROGRAM PGM
               TYPE EMPLOYEE
                  SEQUENCE
                  INTEGER            ID_NUMBER
                  CHARACTER (50) NAME
               END TYPE EMPLOYEE
               TYPE (EMPLOYEE) PROGRAMMER
               CALL SUB (PROGRAMMER)
                  ...
           END PROGRAM PGM
           SUBROUTINE SUB (POSITION)
               TYPE EMPLOYEE
                  SEQUENCE
                  INTEGER            ID_NUMBER
                  CHARACTER (50) NAME





      SEP 2002                                     WORKING DRAFT                                             53


      J3/02-007R3                                WORKING DRAFT                                       SEP 2002



            NOTE 4.43 (cont.)

                 END TYPE EMPLOYEE
                 TYPE (EMPLOYEE) POSITION
                 ...
            END SUBROUTINE SUB


            The actual argument PROGRAMMER and the dummy argument POSITION have the same type
            because they are declared with reference to a derived-type definition with the same name, the
            SEQUENCE property, and components that agree in order, name, and attributes.

            Suppose the component name ID NUMBER was ID NUM in the subroutine. Because all the
            component names are not identical to the component names in derived type EMPLOYEE in the
            main program, the actual argument PROGRAMMER would not be of the same type as the dummy
            argument POSITION. Thus, the program would not be standard conforming.


            NOTE 4.44

            The requirement that the two types have the same name applies to the type-names of the respective
            derived-type-stmt s, not to type-alias names or to local names introduced via renaming in USE
            statements.


 1    4.5.3      Extensible types

 2    A derived type that has the EXTENSIBLE or EXTENDS attribute is an extensible type.

 3    A type that has the EXTENSIBLE attribute is a base type. A type that has the EXTENDS attribute
 4    is an extended type. The parent type of an extended type is the type named in the EXTENDS
 5    attribute specification.

            NOTE 4.45

            The name of the parent type might be a type-alias name or a local name introduced via renaming
            in a USE statement.


 6    A base type is an extension type of itself only. An extended type is an extension of itself and of all
 7    types for which its parent type is an extension.


 8    4.5.3.1    Inheritance

 9    An extended type includes all of the type parameters, components, and nonfinal procedure bindings of
10    its parent type. These are said to be inherited by the extended type from the parent type. They retain
11    all of the attributes that they had in the parent type. Additional type parameters, components, and
12    procedure bindings may be declared in the derived-type definition of the extended type.

            NOTE 4.46

            Inaccessible components and bindings of the parent type are also inherited, but they remain inac-
            cessible in the extended type. Inaccessible entities occur if the type being extended is accessed via
            use association and has a private entity.


            NOTE 4.47

            A base type is not required to have any components, bindings, or parameters; an extended type is
            not required to have more components, bindings, or parameters than its parent type.


13    An object of extended type has a scalar, nonpointer, nonallocatable, parent component with the



      54                                  WORKING DRAFT                                              SEP 2002


      SEP 2002                                 WORKING DRAFT                                      J3/02-007R3



 1    type and type parameters of the parent type. The name of this component is the parent type name.
 2    Components of the parent component are inheritance associated (16.4.4) with the corresponding
 3    components inherited from the parent type.

           NOTE 4.48

          A component or type parameter declared in an extended type shall not have the same name as
          any accessible component or type parameter of its parent type.


           NOTE 4.49

          Examples:


          TYPE, EXTENSIBLE :: POINT                          ! A base type
                 REAL :: X, Y
          END TYPE POINT


          TYPE, EXTENDS(POINT) :: COLOR_POINT                ! An extension of TYPE(POINT)
                 ! Components X and Y, and component name POINT, inherited from parent
                 INTEGER :: COLOR
          END TYPE COLOR_POINT



 4    4.5.3.2      Type-bound procedure overriding

 5    If a specific binding specified in a type definition has the same binding name as a binding inherited from
 6    the parent type then the binding specified in the type definition overrides the one inherited from the
 7    parent type.

 8    The overriding binding and the inherited binding shall satisfy the following conditions:

 9          (1)       Either both shall have a passed-object dummy argument or neither shall.

10          (2)       If the inherited binding is pure then the overriding binding shall also be pure.

11          (3)       Either both shall be elemental or neither shall.

12          (4)       They shall have the same number of dummy arguments.

13          (5)       Passed-object dummy arguments, if any, shall correspond by name and position.

14          (6)       Dummy arguments that correspond by position shall have the same names and characteris-
15                    tics, except for the type of the passed-object dummy arguments.

16          (7)       Either both shall be subroutines or both shall be functions having the same result charac-
17                    teristics (12.2.2).

18          (8)       If the inherited binding is PUBLIC then the overriding binding shall not be PRIVATE.

           NOTE 4.50

          The following is an example of procedure overriding, expanding on the example in Note 4.30.


          TYPE, EXTENDS (POINT) :: POINT_3D
                 REAL :: Z
          CONTAINS
                 PROCEDURE, PASS :: LENGTH => POINT_3D_LENGTH
          END TYPE POINT_3D
          ...


          and in the module-subprogram-part of the same module:





      SEP 2002                                        WORKING DRAFT                                           55


      J3/02-007R3                               WORKING DRAFT                                       SEP 2002



            NOTE 4.50 (cont.)

            REAL FUNCTION POINT_3D_LENGTH ( A, B )
               CLASS (POINT_3D), INTENT (IN) :: A
               CLASS (POINT), INTENT (IN) :: B
               IF ( EXTENDS_TYPE_OF(B, A) ) THEN
                  POINT_3D_LENGTH = SQRT( (A%X-B%X)**2 + (A%Y-B%Y)**2 + (A%Z-B%Z)**2 )
                  RETURN
               END IF
               PRINT *, 'In POINT_3D_LENGTH, dynamic type of argument is incorrect.'
               STOP
            END FUNCTION POINT_3D



 1    A generic binding overrides an inherited binding if they both have the same generic-spec and satisfy the
 2    above conditions for overriding. A generic binding with the same generic-spec that does not satisfy the
 3    conditions extends the generic interface; it shall satisfy the requirements specified in 16.2.3.

 4    If a generic binding in a type definition has the same dtio-generic-spec as one inherited from the parent,
 5    and the dtv argument of the procedure it specifies has the same kind type parameters as the dtv argument
 6    of one inherited from the parent type, then the binding specified in the type overrides the one inherited
 7    from the parent type. Otherwise, it extends the type-bound generic interface for the dtio-generic-spec.

 8    A binding of a type and a binding of an extension of that type are said to correspond if the latter binding
 9    is the same binding as the former, overrides a corresponding binding, or is an inherited corresponding
10    binding.

11    A binding that has the NON OVERRIDABLE attribute in the parent type shall not be overridden.


12    4.5.4       Component order

13    Component order is an ordering of the nonparent components of a derived type; it is used for intrinsic
14    formatted input/output and structure constructors (where component keywords are not used). Parent
15    components are excluded from the component order of an extensible type.

16    The component order of a nonextended type is the order of the declarations of the components in the
17    derived-type definition. The component order of an extended type consists of the component order of
18    its parent type followed by any additional components in the order of their declarations in the extended
19    derived-type definition.


20    4.5.5       Type parameter order

21    Type parameter order is an ordering of the type parameters of a derived type; it is used for derived-
22    type specifiers.

23    The type parameter order of a nonextended type is the order of the type parameter list in the derived-
24    type definition. The type parameter order of an extended type consists of the type parameter order of
25    its parent type followed by any additional type parameters in the order of the type parameter list in the
26    derived-type definition.


27    4.5.6       Derived-type values

28    The set of values of a particular derived type consists of all possible sequences of component values
29    consistent with the definition of that derived type.





      56                                 WORKING DRAFT                                              SEP 2002


      SEP 2002                                WORKING DRAFT                                          J3/02-007R3


 1    4.5.7      Derived-type specifier

 2    A derived-type specifier is used in several contexts to specify a particular derived type and type param-
 3    eters.

 4    R447      derived-type-spec             is    type-name [ ( type-param-spec-list ) ]
 5                                            or type-alias-name
 6    R448      type-param-spec               is    [ keyword = ] type-param-value

 7    C462      (R447) type-name shall be the name of an accessible derived type.

 8    C463      (R447) type-alias-name shall be the name of an accessible type alias that is an alias for a derived
 9              type.

10    C464      (R447) type-param-spec-list shall appear if and only if the type is parameterized.

11    C465      (R447) There shall be exactly one type-param-spec corresponding to each parameter of the type.

12    C466      (R448) The keyword = may be omitted from a type-param-spec only if the keyword = has been
13              omitted from each preceding type-param-spec in the type-param-spec-list.

14    C467      (R448) Each keyword shall be the name of a parameter of the type.

15    C468      (R448) An asterisk may be used as a type-param-value in a type-param-spec only in the decla-
16              ration or allocation of a dummy argument.

17    Type parameter values that do not have type parameter keywords specified correspond to type param-
18    eters in type parameter order (4.5.5). If a type parameter keyword is present, the value is assigned to
19    the type parameter named by the keyword. If necessary, the value is converted according to the rules of
20    intrinsic assignment (7.4.1.3) to a value of the same kind as the type parameter.


21    4.5.8      Construction of derived-type values

22    A derived-type definition implicitly defines a corresponding structure constructor that allows con-
23    struction of values of that derived type. The type and type parameters of a constructed value are
24    specified by a derived type specifier.

25    R449      structure-constructor         is    derived-type-spec ( [ component-spec-list ] )
26    R450      component-spec                is    [ keyword = ] component-data-source
27    R451      component-data-source         is    expr
28                                            or data-target
29                                            or proc-target

30    C469      (R449) At most one component-spec shall be provided for a component.

31    C470      (R449) If a component-spec is be provided for a component, no component-spec shall be provided
32              for any component with which it is inheritance associated.

33    C471      (R449) A component-spec shall be provided for a component unless it has default initialization
34              or is inheritance associated with another component for which a component-spec is provided or
35              that has default initialization.

36    C472      (R450) The keyword = may be omitted from a component-spec only if the keyword = has been
37              omitted from each preceding component-spec in the constructor.

38    C473      (R450) Each keyword shall be the name of a component of the type.

39    C474      (R449) The type name and all components of the type for which a component-spec appears shall




      SEP 2002                                        WORKING DRAFT                                            57


      J3/02-007R3                                WORKING DRAFT                                       SEP 2002



 1             be accessible in the scoping unit containing the structure constructor.

 2    C475     (R449) If derived-type-spec is a type name that is the same as a generic name, the component-
 3             spec-list shall not be a valid actual-arg-spec-list for a function reference that is resolvable as a
 4             generic reference (12.4.4.1).

 5    C476     (R451) A data-target shall correspond to a nonprocedure pointer component; a proc-target shall
 6             correspond to a procedure pointer component.

 7    C477     (R451) A data-target shall have the same rank as its corresponding component.

            NOTE 4.51

            The form 'name(...)' is interpreted as a generic function-reference if possible; it is interpreted as
            a structure-constructor only if it cannot be interpreted as a generic function-reference.


 8    In the absence of a component keyword, each component-data-source is assigned to the corresponding
 9    component in component order (4.5.4). If a component keyword is present, the expr is assigned to
10    the component named by the keyword. If necessary, each value is converted according to the rules of
11    intrinsic assignment (7.4.1.3) to a value that agrees in type and type parameters with the corresponding
12    component of the derived type. For nonpointer nonallocatable components, the shape of the expression
13    shall conform with the shape of the component.

14    If a component with default initialization has no corresponding component-data-source, then the default
15    initialization is applied to that component.

            NOTE 4.52

            Because no parent components appear in the defined component ordering, a value for a parent
            component may be specified only with a component keyword. Examples of equivalent values using
            types defined in Note 4.49:


            ! Create values with components x = 1.0, y = 2.0, color = 3.
            TYPE(POINT) :: PV = POINT(1.0, 2.0)                  ! Assume components of TYPE(POINT)
                                                                 ! are accessible here.
            ...
            COLOR_POINT( point=point(1,2), color=3)              ! Value for parent component
            COLOR_POINT( point=PV, color=3)                      ! Available even if TYPE(point)
                                                                 ! has private components
            COLOR_POINT( 1, 2, 3)                                ! All components of TYPE(point)
                                                                 ! need to be accessible.



16    A structure constructor shall not appear before the referenced type is defined.

            NOTE 4.53

            This example illustrates a derived-type constant expression using a derived type defined in
            Note 4.20:


            PERSON (21, 'JOHN SMITH')


            This could also be written as


            PERSON (NAME = 'JOHN SMITH', AGE = 21)





      58                                     WORKING DRAFT                                           SEP 2002


      SEP 2002                                WORKING DRAFT                                    J3/02-007R3



           NOTE 4.54

           An example constructor using the derived type GENERAL POINT defined in Note 4.21 is


           general_point(dim=3) ( (/ 1., 2., 3. /) )



 1    A derived-type definition may have a component that is an array. Also, an object may be an array of
 2    derived type. Such arrays may be constructed using an array constructor (4.8).

 3    Where a component in the derived type is a pointer, the corresponding component-data-source shall be
 4    an allowable data-target or proc-target for such a pointer in a pointer assignment statement (7.4.2).

           NOTE 4.55

           For example, if the variable TEXT were declared (5.1) to be


           CHARACTER, DIMENSION (1:400), TARGET :: TEXT


           and BIBLIO were declared using the derived-type definition REFERENCE in Note 4.28


           TYPE (REFERENCE) :: BIBLIO


           the statement


           BIBLIO = REFERENCE (1, 1987, 1, "This is the title of the referenced &
                                                  &paper", TEXT)


           is valid and associates the pointer component ABSTRACT of the object BIBLIO with the target
           object TEXT.


 5    If a component of a derived type is allocatable, the corresponding constructor expression shall either be a
 6    reference to the intrinsic function NULL with no arguments, an allocatable entity, or shall evaluate to an
 7    entity of the same rank. If the expression is a reference to the intrinsic function NULL, the corresponding
 8    component of the constructor has a status of unallocated. If the expression is an allocatable entity, the
 9    corresponding component of the constructor has the same allocation status as that allocatable entity
10    and, if it is allocated, the same bounds (if any) and value. Otherwise the corresponding component of
11    the constructor has an allocation status of allocated and has the same bounds (if any) and value as the
12    expression.

           NOTE 4.56

           When the constructor is an actual argument, the allocation status of the allocatable component is
           available through the associated dummy argument.


13    4.5.9     Derived-type operations and assignment

14    Intrinsic assignment of derived-type entities is described in 7.4.1. This standard does not specify any
15    intrinsic operations on derived-type entities. Any operation on derived-type entities or defined assign-
16    ment (7.4.1.4) for derived-type entities shall be defined explicitly by a function or a subroutine, and a
17    generic interface (4.5.1, 12.3.2.1).


18    4.5.10     The finalization process

19    Only finalizable entities are finalized. When an entity is finalized, the following steps are carried out
20    in sequence:




      SEP 2002                                     WORKING DRAFT                                               59


      J3/02-007R3                                  WORKING DRAFT                                      SEP 2002



 1           (1)      If the dynamic type of the entity has a final subroutine whose dummy argument has the
 2                    same kind type parameters and rank as the entity being finalized, it is called with the entity
 3                    as an actual argument. Otherwise, if there is an elemental final subroutine whose dummy
 4                    argument has the same kind type parameters as the entity being finalized, it is called with
 5                    the entity as an actual argument. Otherwise, no subroutine is called at this point.

 6           (2)      Each finalizable component that appears in the type definition is finalized. If the entity
 7                    being finalized is an array, each finalizable component of each element of that entity is
 8                    finalized separately.

 9           (3)      If the entity is of extended type and the parent type is finalizable, the parent component is
10                    finalized.

11    If several entities are to be finalized as a consequence of an event specified in 4.5.10.1, the order in which
12    they are finalized is processor-dependent. A final subroutine shall not reference or define an object that
13    has already been finalized.


14    4.5.10.1       When finalization occurs

15    The target of a pointer is finalized when the pointer is deallocated. An allocatable entity is finalized
16    when it is deallocated.

17    A nonpointer, nonallocatable object that is not a dummy argument or function result is finalized im-
18    mediately before it would become undefined due to execution of a RETURN or END statement (16.5.6,
19    item (3)). If the object is defined in a module and there are no longer any active procedures referencing
20    the module, it is processor-dependent whether it is finalized. If the object is not finalized, it retains its
21    definition status and does not become undefined.

22    If an executable construct references a function, the result is finalized after execution of the innermost
23    executable construct containing the reference.

24    If an executable construct references a structure constructor, the entity created by the structure con-
25    structor is finalized after execution of the innermost executable construct containing the reference.

26    If a specification expression in a scoping unit references a function, the result is finalized before execution
27    of the first executable statement in the scoping unit.

28    When a procedure is invoked, a nonpointer, nonallocatable object that is an actual argument associated
29    with an INTENT(OUT) dummy argument is finalized.

30    When an intrinsic assignment statement is executed, variable is finalized after evaluation of expr and
31    before the definition of variable.

            NOTE 4.57

            If finalization is used for storage management, it often needs to be combined with defined assign-
            ment.


32    If an object is allocated via pointer allocation and later becomes unreachable due to all pointers to that
33    object having their pointer association status changed, it is processor dependent whether it is finalized.
34    If it is finalized, it is processor dependent as to when the final subroutines are called.


35    4.5.10.2       Entities that are not finalized

36    If program execution is terminated, either by an error (e.g. an allocation failure) or by execution of
37    a STOP or END PROGRAM statement, entities existing immediately prior to termination are not
38    finalized.





      60                                      WORKING DRAFT                                           SEP 2002


      SEP 2002                                WORKING DRAFT                                      J3/02-007R3



             NOTE 4.58

             A nonpointer, nonallocatable object that has the SAVE attribute or which occurs in the main pro-
             gram is never finalized as a direct consequence of the execution of a RETURN or END statement.

             A variable in a module is not finalized if it retains its definition status and value, even when there
             is no active procedure referencing the module.



 1    4.6       Type aliases

 2    Type aliasing provides a method of data abstraction. A type alias is an entity that may be used to
 3    declare entities of an existing type; it is not a new type. The name of a type alias for a derived type
 4    may also be used in the derived-type-spec of a structure-constructor .

 5    R452      type-alias-stmt               is    TYPEALIAS :: type-alias-list
 6    R453      type-alias                    is    type-alias-name => declaration-type-spec

 7    C478      (R453) A type-alias-name shall not be the same as the name of any intrinsic type defined in this
 8              standard.

 9    C479      (R453) A declaration-type-spec in a type-alias shall not use the CLASS keyword.

10    C480      (R453) A declaration-type-spec shall specify an intrinsic type or a previously defined derived
11              type. Each type-param-value shall be an initialization expression.

12    Explicit or implicit declaration of an entity or component using a type alias name has the same effect
13    as using the declaration-type-spec for which it is an alias.

             NOTE 4.59

             The declarations for X, Y, and S


             TYPEALIAS :: DOUBLECOMPLEX => COMPLEX(KIND(1.0D0)), &
                              NEWTYPE => TYPE(DERIVED), &
                              ANOTHERTYPE => TYPE(NEWTYPE)
             TYPE(DOUBLECOMPLEX) :: X, Y
             TYPE(NEWTYPE) :: S
             TYPE(ANOTHERTYPE) :: T


             are equivalent to the declarations


             COMPLEX(KIND(1.0D0)) :: X, Y
             TYPE(DERIVED) :: S, T



14    4.7       Enumerations and enumerators

15    An enumeration is a type alias for an integer type. An enumerator is a named integer constant. An
16    enumeration definition specifies the enumeration and a set of enumerators of the corresponding integer
17    kind.

18    R454      enum-alias-def                is    enum-def-stmt
19                                                      enumerator-def-stmt
20                                                      [ enumerator-def-stmt ] ...
21                                                      end-enum-stmt
22    R455      enum-def-stmt                 is    ENUM, BIND(C) :: type-alias-name



      SEP 2002                                        WORKING DRAFT                                           61


      J3/02-007R3                                        WORKING DRAFT                                     SEP 2002



 1                                              or ENUM [ kind-selector ] [ :: ] type-alias-name
 2    R456      enumerator-def-stmt             is       ENUMERATOR [ :: ] enumerator -list
 3    R457      enumerator                      is       named-constant [ = scalar-int-initialization-expr ]
 4    R458      end-enum-stmt                   is       END ENUM [ type-alias-name ]

 5    C481      (R456) If = appears in an enumerator , a double-colon separator shall appear before the enu-
 6              merator -list.

 7    C482      (R458) If END ENUM is followed by a type-alias-name, the type-alias-name shall be the same
 8              as that in the corresponding enum-def-stmt .

 9    The type-alias-name of an enumeration is treated as if it were explicitly declared in a type alias statement
10    as a type alias for an integer whose kind parameter is determined as follows:

11            (1)    If BIND(C) is specified, the kind is selected such that an integer type with that kind is
12                   interoperable (15.2.1) with the corresponding C enumeration type. The corresponding C
13                   enumeration type is the type that would be declared by a C enumeration specifier (6.7.2.2
14                   of the C standard) that specified C enumeration constants with the same values as those
15                   specified by the enum-alias-def , in the same order as specified by the enum-alias-def .

16                   The companion processor (2.5.10) shall be one that uses the same representation for the
17                   types declared by all C enumeration specifiers that specify the same values in the same
18                   order.

            NOTE 4.60

            If a companion processor uses an unsigned type to represent a given enumeration type, the Fortran
            processor will use the signed integer type of the same width for the enumeration, even though some
            of the values of the enumerators cannot be represented in this signed integer type. The values of
            any such enumerators will be interoperable with the values declared in the C enumeration.


            NOTE 4.61

            The C standard guarantees the enumeration constants fit in a C int (6.7.2.2 of the C standard).
            Therefore, the Fortran processor can evaluate all enumerator values using the integer type with kind
            parameter C INT, and then determine the kind parameter of the integer type that is interoperable
            with the corresponding C enumerated type.

19            (2)    If kind-selector is specified, the kind is that specified by the kind-selector .

20            (3)    If neither BIND(C) nor kind-selector is specified, the kind is that of default integer.

            NOTE 4.62

            The C standard specifies that two enumeration types are compatible only if they specify enumer-
            ation constants with the same names and same values in the same order. This standard further
            requires that a C processor that is to be a companion processor of a Fortran processor use the
            same representation for two enumeration types if they both specify enumeration constants with
            the same values in the same order, even if the names are different.


21    An enumerator is treated as if it were explicitly declared with type type-alias-name and with the PA-
22    RAMETER attribute. The enumerator is defined in accordance with the rules of intrinsic assignment
23    (7.4) with the value determined as follows:

24            (1)    If scalar-int-initialization-expr is specified, the value of the enumerator is the result of
25                   scalar-int-initialization-expr .

26            (2)    If scalar-int-initialization-expr is not specified and the enumerator is the first enumerator
27                   in enum-alias-def , the enumerator has the value 0.

28            (3)    If scalar-int-initialization-expr is not present and the enumerator is not the first enumerator
29                   in enum-alias-def , its value is the result of adding 1 to the value of the enumerator that



      62                                     WORKING DRAFT                                                 SEP 2002


      SEP 2002                                  WORKING DRAFT                                       J3/02-007R3



 1                      immediately precedes it in the enum-alias-def .

             NOTE 4.63

             The declarations


             ENUM (SELECTED_INT_KIND (1)) :: DIGITS
               ENUMERATOR :: ZERO, ONE, TWO
             END ENUM DIGITS


             ENUM, BIND(C) :: PRIMARY_COLORS
               ENUMERATOR :: RED = 4, BLUE = 9
               ENUMERATOR YELLOW
             END ENUM


             TYPE (DIGITS) :: X


             are equivalent to the declarations


             TYPEALIAS :: DIGITS => INTEGER (SELECTED_INT_KIND(1))
             TYPE (DIGITS), PARAMETER :: ZERO = 0, ONE = 1, TWO = 2
             TYPE (DIGITS) :: X


             ! The kind type parameter for PRIMARY_COLORS is processor dependent, but the
             ! processor is required to select a kind sufficient to represent the values
             ! 4, 9, and 10, which are the values of its enumerators.
             ! The following declaration is one possibility for PRIMARY_COLORS.
             TYPEALIAS :: PRIMARY_COLORS => INTEGER (SELECTED_INT_KIND (2))
             TYPE (PRIMARY_COLORS), PARAMETER :: RED = 4, BLUE = 9, YELLOW = 10



             NOTE 4.64

             There is no difference in the effect of declaring the enumerators in multiple ENUMERATOR
             statements or in a single ENUMERATOR statement. The order in which the enumerators in an
             enumeration definition are declared is significant, but the number of ENUMERATOR statements
             is not.



 2    4.8       Construction of array values

 3    An array constructor is defined as a sequence of scalar values and is interpreted as a rank-one array
 4    where the element values are those specified in the sequence.

 5    R459      array-constructor               is    (/ ac-spec /)
 6                                              or left-square-bracket ac-spec right-square-bracket
 7    R460      ac-spec                         is    type-spec ::
 8                                              or [type-spec ::] ac-value-list
 9    R461      left-square-bracket             is    [
10    R462      right-square-bracket            is    ]
11    R463      ac-value                        is    expr
12                                              or ac-implied-do
13    R464      ac-implied-do                   is    ( ac-value-list , ac-implied-do-control )
14    R465      ac-implied-do-control           is    ac-do-variable = scalar-int-expr , scalar-int-expr
15                                                         [ , scalar-int-expr ]
16    R466      ac-do-variable                  is    scalar-int-variable




      SEP 2002                                             WORKING DRAFT                                    63


      J3/02-007R3                                WORKING DRAFT                                       SEP 2002



 1    C483     (R466) ac-do-variable shall be a named variable.

 2    C484     (R460) If type-spec is omitted, each ac-value expression in the array-constructor shall have the
 3             same type and kind type parameters.

 4    C485     (R460) If type-spec specifies an intrinsic type, each ac-value expression in the array-constructor
 5             shall be of an intrinsic type that is in type conformance with a variable of type type-spec as
 6             specified in Table 7.8.

 7    C486     (R460) If type-spec specifies a derived type, all ac-value expressions in the array-constructor
 8             shall be of that derived type and shall have the same kind type parameter values as specified by
 9             type-spec.

10    C487     (R464) The ac-do-variable of an ac-implied-do that is in another ac-implied-do shall not appear
11             as the ac-do-variable of the containing ac-implied-do.

12    If type-spec is omitted, the type and type parameters of the array constructor are those of the ac-value
13    expressions.

14    If type-spec appears, it specifies the type and type parameters of the array constructor. Each ac-value
15    expression in the array-constructor shall be compatible with intrinsic assignment to a variable of this
16    type and type parameters. Each value is converted to the type parameters of the array-constructor in
17    accordance with the rules of intrinsic assignment (7.4.1.3).

18    The character length of an ac-value in an ac-implied-do whose iteration count is zero shall not depend
19    on the value of the implied DO variable and shall not depend on the value of an expression that is not
20    an initialization expression.

21    If an ac-value is a scalar expression, its value specifies an element of the array constructor. If an ac-
22    value is an array expression, the values of the elements of the expression, in array element order (6.2.2.2),
23    specify the corresponding sequence of elements of the array constructor. If an ac-value is an ac-implied-
24    do, it is expanded to form a sequence of elements under the control of the ac-do-variable, as in the DO
25    construct (8.1.6.4).

26    For an ac-implied-do, the loop initialization and execution is the same as for a DO construct.

27    An empty sequence forms a zero-sized rank-one array.

            NOTE 4.65

            A one-dimensional array may be reshaped into any allowable array shape using the RESHAPE
            intrinsic function (13.7.95). An example is:


            X = (/ 3.2, 4.01, 6.5 /)
            Y = RESHAPE (SOURCE = [ 2.0, [ 4.5, 4.5 ], X ], SHAPE = [ 3, 2 ])


            This results in Y having the 3 � 2 array of values:


            2.0       3.2
            4.5       4.01
            4.5       6.5



            NOTE 4.66

            Examples of array constructors containing an implied-DO are:





      64                                  WORKING DRAFT                                              SEP 2002


SEP 2002                            WORKING DRAFT                                    J3/02-007R3



   NOTE 4.66 (cont.)

   (/ (I, I = 1, 1075) /)


   and


   [ 3.6, (3.6 / I, I = 1, N) ]



   NOTE 4.67

   Using the type definition for PERSON in Note 4.20, an example of the construction of a derived-
   type array value is:


   (/ PERSON (40, 'SMITH'), PERSON (20, 'JONES') /)



   NOTE 4.68

   Using the type definition for LINE in Note 4.25, an example of the construction of a derived-type
   scalar value with a rank-2 array component is:


   LINE (RESHAPE ( (/ 0.0, 0.0, 1.0, 2.0 /), (/ 2, 2 /) ), 0.1, 1)


   The RESHAPE intrinsic function is used to construct a value that represents a solid line from (0,
   0) to (1, 2) of width 0.1 centimeters.


   NOTE 4.69

   Examples of zero-size array constructors are:


      (/ INTEGER :: /)
      (/ ( I, I = 1, 0) /)



   NOTE 4.70

   An example of an array constructor that specifies a nonkind type parameter:


      (/ CHARACTER(LEN=7) :: 'Takata', 'Tanaka', 'Hayashi' /)


   In this constructor, without the type specification, it would have been necessary to specify all of
   the constants with the same character length.





SEP 2002                                     WORKING DRAFT                                        65


J3/02-007R3       WORKING DRAFT    SEP 2002





66             WORKING DRAFT       SEP 2002


      SEP 2002                               WORKING DRAFT                                             J3/02-007R3





 1    Section 5: Data object declarations and specifications

 2    Every data object has a type and rank and may have type parameters and other attributes that determine
 3    the uses of the object. Collectively, these properties are the attributes of the object. The type of a
 4    named data object is either specified explicitly in a type declaration statement or determined implicitly
 5    by the first letter of its name (5.3). All of its attributes may be included in a type declaration statement
 6    or may be specified individually in separate specification statements.

             NOTE 5.1

             For example:


             INTEGER :: INCOME, EXPENDITURE


             declares the two data objects named INCOME and EXPENDITURE to have the type integer.


             REAL, DIMENSION (-5:+5) :: X, Y, Z


             declares three data objects with names X, Y, and Z. These all have default real type and are
             explicit-shape rank-one arrays with a lower bound of �5, an upper bound of +5, and therefore a
             size of 11.



 7    5.1       Type declaration statements

 8    R501      type-declaration-stmt        is    declaration-type-spec [ [ , attr-spec ] ... :: ] entity-decl -list
 9    R502      declaration-type-spec        is    type-spec
10                                           or CLASS ( derived-type-spec )
11                                           or CLASS ( * )

12    C501      (R502) In a declaration-type-spec, every type-param-value that is not a colon or an asterisk shall
13              be a specification-expr .

14    C502      (R502) In a declaration-type-spec that uses the CLASS keyword, derived-type-spec shall specify
15              an extensible type.

             NOTE 5.2

             A declaration-type-spec is used in a nonexecutable statement; a type-spec is used in an array
             constructor or an ALLOCATE statement.


16    R503      type-spec                    is    INTEGER [ kind-selector ]
17                                           or REAL [ kind-selector ]
18                                           or DOUBLE PRECISION
19                                           or COMPLEX [ kind-selector ]
20                                           or CHARACTER [ char-selector ]
21                                           or LOGICAL [ kind-selector ]
22                                           or TYPE ( derived-type-spec )
23                                           or TYPE ( type-alias-name )

24    C503      (R503) A type-alias-name shall be the name of a type alias.

25    R504      attr-spec                    is    access-spec



      SEP 2002                                       WORKING DRAFT                                                       67


      J3/02-007R3                                     WORKING DRAFT                                        SEP 2002



 1                                              or ALLOCATABLE
 2                                              or ASYNCHRONOUS
 3                                              or DIMENSION ( array-spec )
 4                                              or EXTERNAL
 5                                              or INTENT ( intent-spec )
 6                                              or INTRINSIC
 7                                              or language-binding-spec
 8                                              or OPTIONAL
 9                                              or PARAMETER
10                                              or POINTER
11                                              or PROTECTED
12                                              or SAVE
13                                              or TARGET
14                                              or VALUE
15                                              or VOLATILE
16    R505    entity-decl                       is    object-name [( array-spec )] [ * char-length ] [ initialization ]
17                                              or function-name [ * char-length ]

18    C504    (R505) If a type-param-value in a char-length in an entity-decl is not a colon or an asterisk, it
19            shall be a specification-expr .

20    R506    object-name                       is    name

21    C505    (R506) The object-name shall be the name of a data object.

22    R507    kind-selector                     is    ( [ KIND = ] scalar-int-initialization-expr )
23    R508    initialization                    is    = initialization-expr
24                                              or => null-init
25    R509    null-init                         is    function-reference

26    C506    (R509) The function-reference shall be a reference to the NULL intrinsic function with no
27            arguments.

28    C507    (R501) The same attr-spec shall not appear more than once in a given type-declaration-stmt .

29    C508    An entity shall not be explicitly given any attribute more than once in a scoping unit.

30    C509    (R501) An entity declared with the CLASS keyword shall be a dummy argument or have the
31            ALLOCATABLE or POINTER attribute.

32    C510    (R501) An array that has the POINTER or ALLOCATABLE attribute shall be specified with
33            an array-spec that is a deferred-shape-spec-list (5.1.2.5.3).

34    C511    (R501) An array-spec for an object-name that is a function result that does not have the AL-
35            LOCATABLE or POINTER attribute shall be an explicit-shape-spec-list.

36    C512    (R501) If the POINTER attribute is specified, the ALLOCATABLE, TARGET, EXTERNAL,
37            or INTRINSIC attribute shall not be specified.

38    C513    (R501) If the TARGET attribute is specified, the POINTER, EXTERNAL, INTRINSIC, or
39            PARAMETER attribute shall not be specified.

40    C514    (R501) The PARAMETER attribute shall not be specified for a dummy argument, a pointer,
41            an allocatable entity, a function, or an object in a common block.

42    C515    (R501) The INTENT, VALUE, and OPTIONAL attributes may be specified only for dummy
43            arguments.




      68                                 WORKING DRAFT                                                     SEP 2002


      SEP 2002                              WORKING DRAFT                                        J3/02-007R3



 1    C516    (R501) The INTENT attribute shall not be specified for a dummy argument that is a dummy
 2            procedure.

         NOTE 5.3

         A dummy procedure pointer is not a dummy procedure. Therefore, INTENT may be specified for
         a dummy procedure pointer.


 3    C517    (R501) The SAVE attribute shall not be specified for an object that is in a common block, a
 4            dummy argument, a procedure, a function result, an automatic data object, or an object with
 5            the PARAMETER attribute.

 6    C518    An entity shall not have both the EXTERNAL attribute and the INTRINSIC attribute.

 7    C519    (R501) An entity in an entity-decl -list shall not have the EXTERNAL or INTRINSIC attribute
 8            specified unless it is a function.

 9    C520    (R505) The * char-length option is permitted only if the type specified is character.

10    C521    (R505) The function-name shall be the name of an external function, an intrinsic function, a
11            function dummy procedure, or a statement function.

12    C522    (R501) The initialization shall appear if the statement contains a PARAMETER attribute
13            (5.1.2.10).

14    C523    (R501) If initialization appears, a double-colon separator shall appear before the entity-decl -list.

15    C524    (R505)initialization shall not appear if object-name is a dummy argument, a function result, an
16            object in a named common block unless the type declaration is in a block data program unit,
17            an object in blank common, an allocatable variable, an external name, an intrinsic name, or an
18            automatic object.

19    C525    (R505) If => appears in initialization, the object shall have the POINTER attribute. If =
20            appears in initialization, the object shall not have the POINTER attribute.

21    C526    (R503) The value of scalar-int-initialization-expr in kind-selector shall be nonnegative and shall
22            specify a representation method that exists on the processor.

23    C527    (R501) If the VOLATILE attribute is specified, the PARAMETER, INTRINSIC, EXTERNAL,
24            or INTENT(IN) attribute shall not be specified.

25    C528    (R501) If the VALUE attribute is specified, the PARAMETER, EXTERNAL, POINTER,
26            ALLOCATABLE, DIMENSION, VOLATILE, INTENT(INOUT), or INTENT(OUT) attribute
27            shall not be specified.

28    C529    (R501) If the VALUE attribute is specified for a dummy argument of type character, the length
29            parameter shall be omitted or shall be specified by an initialization expression with the value
30            one.

31    C530    (R501) The ALLOCATABLE, POINTER, or OPTIONAL attribute shall not be specified for a
32            dummy argument of a procedure that has a proc-language-binding-spec.

33    C531    (R504) A language-binding-spec shall appear only in the specification part of a module.

34    C532    (R501) If a language-binding-spec is specified, the entity declared shall be an interoperable
35            variable (15.2).

36    C533    (R501) If a language-binding-spec with a NAME= specifier appears, the entity-decl -list shall




      SEP 2002                                     WORKING DRAFT                                               69


      J3/02-007R3                                    WORKING DRAFT                                     SEP 2002



 1              consist of a single entity-decl .

 2    C534      (R504) The PROTECTED attribute is permitted only in the specification part of a module.

 3    C535      (R501) The PROTECTED attribute is permitted only for a procedure pointer or named variable
 4              that is not in a common block.

 5    C536      (R501) If the PROTECTED attribute is specified, the EXTERNAL, INTRINSIC, or PARAM-
 6              ETER attribute shall not be specified.

 7    C537      A nonpointer object that has the PROTECTED attribute and is accessed by use association
 8              shall not appear in a variable definition context (16.5.7) or as the data-target or proc-target in
 9              a pointer-assignment-stmt .

10    C538      A pointer object that has the PROTECTED attribute and is accessed by use association shall
11              not appear as

12            (1)    A pointer-object in a pointer-assignment-stmt or nullify-stmt ,

13            (2)    An allocate-object in an allocate-stmt or deallocate-stmt , or

14            (3)    An actual argument in a reference to a procedure if the associated dummy argument is a
15                   pointer with the INTENT(OUT) or INTENT(INOUT) attribute.

16    A name that identifies a specific intrinsic function in a scoping unit has a type as specified in 13.6. An
17    explicit type declaration statement is not required; however, it is permitted. Specifying a type for a
18    generic intrinsic function name in a type declaration statement is not sufficient, by itself, to remove the
19    generic properties from that function.

20    A function result may be declared to have the POINTER or ALLOCATABLE attribute.

21    A specification-expr in an array-spec, in a type-param-value in a declaration-type-spec corresponding to a
22    nonkind type parameter, or in a char-length in an entity-decl shall be an initialization expression unless
23    it is in an interface body (12.3.2.1), the specification part of a subprogram, or the declaration-type-spec
24    of a FUNCTION statement (12.5.2.1). If the data object being declared depends on the value of a
25    specification-expr that is not an initialization expression, and it is not a dummy argument, such an
26    object is called an automatic data object.

            NOTE 5.4

            An automatic object shall neither appear in a SAVE or DATA statement nor be declared with a
            SAVE attribute nor be initially defined by an initialization.


27    If a type parameter in a declaration-type-spec or in a char-length in an entity-decl is defined by an
28    expression that is not an initialization expression, the type parameter value is established on entry to
29    the procedure and is not affected by any redefinition or undefinition of the variables in the specification
30    expression during execution of the procedure.

31    If an entity-decl contains initialization and the object-name does not have the PARAMETER attribute,
32    the entity is a variable with explicit initialization. Explicit initialization alternatively may be specified
33    in a DATA statement unless the variable is of a derived type for which default initialization is specified.
34    If initialization is =initialization-expr , the object-name is initially defined with the value specified by
35    the initialization-expr ; if necessary, the value is converted according to the rules of intrinsic assignment
36    (7.4.1.3) to a value that agrees in type, type parameters, and shape with the object-name. A variable,
37    or part of a variable, shall not be explicitly initialized more than once in a program. If the variable is an
38    array, it shall have its shape specified in either the type declaration statement or a previous attribute
39    specification statement in the same scoping unit.

40    If initialization is =>null-init , object-name shall be a pointer, and its initial association status is disas-



      70                                     WORKING DRAFT                                             SEP 2002


      SEP 2002                              WORKING DRAFT                                      J3/02-007R3



 1    sociated.

 2    The presence of initialization implies that object-name is saved, except for an object-name in a named
 3    common block or an object-name with the PARAMETER attribute. The implied SAVE attribute may
 4    be reaffirmed by explicit use of the SAVE attribute in the type declaration statement, by inclusion of
 5    the object-name in a SAVE statement (5.2.12), or by the appearance of a SAVE statement without a
 6    saved-entity-list in the same scoping unit.

           NOTE 5.5

           Examples of type declaration statements are:


           REAL A (10)
           LOGICAL, DIMENSION (5, 5) :: MASK1, MASK2
           COMPLEX :: CUBE_ROOT = (-0.5, 0.866)
           INTEGER, PARAMETER :: SHORT = SELECTED_INT_KIND (4)
           INTEGER (SHORT) K          !    Range at least -9999 to 9999.
           REAL (KIND (0.0D0)) A
           REAL (KIND = 2) B
           COMPLEX (KIND = KIND (0.0D0)) :: C
           TYPE (PERSON) :: CHAIRMAN
           TYPE(NODE), POINTER :: HEAD => NULL ( )
           TYPE (matrix (k=8, d=1000)) :: mat


           (The last line above uses a type definition from Note 4.21.)


 7    5.1.1        Type specifiers

 8    The type specifier in a type declaration statement specifies the type of the entities in the entity
 9    declaration list. This explicit type declaration may override or confirm the implicit type that could
10    otherwise be indicated by the first letter of an entity name (5.3).


11    5.1.1.1      INTEGER

12    The INTEGER type specifier is used to declare entities of intrinsic type integer (4.4.1). The kind
13    selector, if present, specifies the integer representation method. If the kind selector is absent, the kind
14    type parameter is KIND (0) and the entities declared are of type default integer.


15    5.1.1.2      REAL

16    The REAL type specifier is used to declare entities of intrinsic type real (4.4.2). The kind selector, if
17    present, specifies the real approximation method. If the kind selector is absent, the kind type parameter
18    is KIND (0.0) and the entities declared are of type default real.


19    5.1.1.3      DOUBLE PRECISION

20    The DOUBLE PRECISION type specifier is used to declare entities of intrinsic type double precision
21    real (4.4.2). The kind parameter value is KIND (0.0D0). An entity declared with a type specifier
22    REAL (KIND (0.0D0)) is of the same kind as one declared with the type specifier DOUBLE PRECISION.


23    5.1.1.4      COMPLEX

24    The COMPLEX type specifier is used to declare entities of intrinsic type complex (4.4.3). The kind
25    selector, if present, specifies the real approximation method of the two real values making up the real





      SEP 2002                                       WORKING DRAFT                                          71


      J3/02-007R3                                         WORKING DRAFT                                             SEP 2002



 1    and imaginary parts of the complex value. If the kind selector is absent, the kind type parameter is
 2    KIND (0.0) and the entities declared are of type default complex.


 3    5.1.1.5        CHARACTER

 4    The CHARACTER type specifier is used to declare entities of intrinsic type character (4.4.4).

 5    R510       char-selector                      is    length-selector
 6                                                  or ( LEN = type-param-value ,
 7                                                           KIND = scalar-int-initialization-expr )
 8                                                  or ( type-param-value ,
 9                                                           [ KIND = ] scalar-int-initialization-expr )
10                                                  or ( KIND = scalar-int-initialization-expr
11                                                           [ , LEN =type-param-value ] )
12    R511       length-selector                    is    ( [ LEN = ] type-param-value )
13                                                  or * char-length [ , ]
14    R512       char-length                        is    ( type-param-value )
15                                                  or scalar-int-literal-constant

16    C539       (R510) The value of scalar-int-initialization-expr shall be nonnegative and shall specify a rep-
17               resentation method that exists on the processor.

18    C540       (R512) The scalar-int-literal-constant shall not include a kind-param.

19    C541       (R510 R511 R512) A type-param-value of * may be used only in the following ways:

20            (1)     to declare a dummy argument,

21            (2)     to declare a named constant,

22            (3)     in the type-spec of an ALLOCATE statement wherein each allocate-object is a dummy
23                    argument of type CHARACTER with an assumed character length, or

24            (4)     in an external function, to declare the character length parameter of the function result.


25    C542       A function name shall not be declared with an asterisk type-param-value unless it is of type CHAR-

26               ACTER and is the name of the result of an external function or the name of a dummy function.


27    C543       A function name declared with an asterisk type-param-value shall not be an array, a pointer, recursive, or pure.


28    C544       (R511) The optional comma in a length-selector is permitted only in a declaration-type-spec in a type-declaration-

29               stmt .


30    C545       (R511) The optional comma in a length-selector is permitted only if no double-colon separator appears in the

31               type-declaration-stmt .


32    C546       (R510) The length specified for a character statement function or for a statement function dummy argument of

33               type character shall be an initialization expression.


34    The char-selector in a CHARACTER type-spec and the * char-length in an entity-decl or in a component-
35    decl of a type definition specify character length. The * char-length in an entity-decl or a component-decl
36    specifies an individual length and overrides the length specified in the char-selector , if any. If a * char-
37    length is not specified in an entity-decl or a component-decl , the length-selector or type-param-value
38    specified in the char-selector is the character length. If the length is not specified in a char-selector or
39    a * char-length, the length is 1.

40    If the character length parameter value evaluates to a negative value, the length of character entities
41    declared is zero. A character length parameter value of : indicates a deferred type parameter (4.2). A
42    char-length type parameter value of * has the following meaning:




      72                                         WORKING DRAFT                                                      SEP 2002


      SEP 2002                                     WORKING DRAFT                                               J3/02-007R3



 1          (1)      If used to declare a dummy argument of a procedure, the dummy argument assumes the
 2                   length of the associated actual argument.

 3          (2)      If used to declare a named constant, the length is that of the constant value.

 4          (3)      If used in the type-spec of an ALLOCATE statement, each allocate-object assumes its length
 5                   from the associated actual argument.

 6          (4)      If used to specify the character length parameter of a function result, any scoping unit invoking the function

 7                   shall declare the function name with a character length parameter value other than * or access such a

 8                   definition by host or use association. When the function is invoked, the length of the result variable in the

 9                   function is assumed from the value of this type parameter.


10    The kind selector, if present, specifies the character representation method. If the kind selector is absent,
11    the kind type parameter is KIND ('A') and the entities declared are of type default character.

           NOTE 5.6

           Examples of character type declaration statements are:


           CHARACTER (LEN = 10, KIND = 2)                 A
           CHARACTER B, C *20



12    5.1.1.6      LOGICAL

13    The LOGICAL type specifier is used to declare entities of intrinsic type logical (4.4.5).

14    The kind selector, if present, specifies the representation method. If the kind selector is absent, the kind
15    type parameter is KIND (.FALSE.) and the entities declared are of type default logical.


16    5.1.1.7      Derived type

17    A TYPE type specifier is used to declare entities of the derived type specified by the type-name of
18    the derived-type-spec. The components of each such entity are declared to be of the types specified by
19    the corresponding component-def-stmt s of the derived-type-def (4.5.1). When a data entity is declared
20    explicitly to be of a derived type, the derived type shall have been defined previously in the scoping unit
21    or be accessible there by use or host association. If the data entity is a function result, the derived type
22    may be specified in the FUNCTION statement provided the derived type is defined within the body of
23    the function or is accessible there by use or host association.

24    A scalar entity of derived type is a structure. If a derived type has the SEQUENCE property, a scalar
25    entity of the type is a sequence structure.


26    5.1.1.8      Polymorphic entities

27    A polymorphic entity is a data entity that is able to be of differing types during program execution.
28    The type of a data entity at a particular point during execution of a program is its dynamic type. The
29    declared type of a data entity is the type that it is declared to have, either explicitly or implicitly.

30    A CLASS type specifier is used to declare polymorphic objects. The declared type of a polymorphic
31    object is the specified type if the CLASS type specifier contains a type name.

32    An object declared with the CLASS(*) specifier is an unlimited polymorphic object. An unlimited
33    polymorphic entity is not declared to have a type. It is not considered to have the same declared type
34    as any other entity, including another unlimited polymorphic entity.

35    A nonpolymorphic entity is type compatible only with entities of the same type. For a polymorphic
36    entity, type compatibility is based on its declared type. A polymorphic entity that is not an unlimited
37    polymorphic entity is type compatible with entities of the same type or any of its extensions. Even



      SEP 2002                                             WORKING DRAFT                                                       73


      J3/02-007R3                                   WORKING DRAFT                                     SEP 2002



 1    though an unlimited polymorphic entity is not considered to have a declared type, it is type compatible
 2    with all entities of extensible type. An entity is said to be type compatible with a type if it is type
 3    compatible with entities of that type.

 4    Two entities are type incompatible if neither is type compatible with the other.

 5    An entity is type, kind, and rank compatible, or TKR compatible, with another entity if the first
 6    entity is type compatible with the second, the kind type parameters of the first entity have the same
 7    values as corresponding kind type parameters of the second, and both entities have the same rank.

 8    Two entities are TKR incompatible if neither is TKR compatible with the other.

 9    A polymorphic allocatable object may be allocated to be of any type with which it is type compatible.
10    A polymorphic pointer or dummy argument may, during program execution, be associated with objects
11    with which it is type compatible.

12    The dynamic type of an allocated allocatable polymorphic object is the type with which it was allocated.
13    The dynamic type of an associated polymorphic pointer is the dynamic type of its target. The dynamic
14    type of a nonallocatable nonpointer polymorphic dummy argument is the dynamic type of its associated
15    actual argument. The dynamic type of an unallocated allocatable or a disassociated pointer is the same
16    as its declared type. The dynamic type of an entity identified by an associate name (8.1.4) is the dynamic
17    type of the selector with which it is associated. The dynamic type of an object that is not polymorphic
18    is its declared type.

            NOTE 5.7

            Only components of the declared type of a polymorphic object may be designated by component
            selection (6.1.2).


19    5.1.2      Attributes

20    The additional attributes that may appear in the attribute specification of a type declaration statement
21    further specify the nature of the entities being declared or specify restrictions on their use in the program.


22    5.1.2.1     Accessibility attribute

23    The accessibility attribute specifies the accessibility of an entity via a particular identifier.

24    R513       access-spec                  is    PUBLIC
25                                            or PRIVATE

26    C547       (R513) An access-spec shall appear only in the specification-part of a module.

27    Identifiers that are specified in a module or accessible in that module by use association have either
28    the PUBLIC or PRIVATE attribute. Identifiers for which an access-spec is not explicitly specified in
29    that module have the default accessibility attribute for that module. The default accessibility attribute
30    for a module is PUBLIC unless it has been changed by a PRIVATE statement (5.2.1). Only identifiers
31    that have the PUBLIC attribute in that module are available to be accessed from that module by USE
32    association.

            NOTE 5.8

            In order for an identifier to be accessed by use association, it must have the PUBLIC attribute in
            the module from which it is accessed. It can nonetheless have the PRIVATE attribute in a module
            in which it is accessed by use association, and therefore not be available for use association from
            a module where it is PRIVATE.





      74                                     WORKING DRAFT                                            SEP 2002


      SEP 2002                                 WORKING DRAFT                                       J3/02-007R3



           NOTE 5.9

           An example of an accessibility specification is:


           REAL, PRIVATE :: X, Y, Z



 1    5.1.2.2        ALLOCATABLE attribute

 2    An object with the ALLOCATABLE attribute is one for which space is allocated by an ALLOCATE
 3    statement (6.3.1) or by a derived-type intrinsic assignment statement (7.4.1.3).


 4    5.1.2.3        ASYNCHRONOUS attribute

 5    The base object of a variable shall have the ASYNCHRONOUS attribute in a scoping unit if:

 6            (1)      the variable appears in an executable statement or specification expression in that scoping
 7                     unit and

 8            (2)      any statement of the scoping unit is executed while the variable is a pending I/O storage
 9                     sequence affector (9.5.1.4)

10    The ASYNCHRONOUS attribute may be conferred implicitly by the use of a variable in an asynchronous
11    input/output statement (9.5.1.4).

12    An object may have the ASYNCHRONOUS attribute in a particular scoping unit without necessarily
13    having it in other scoping units.       If an object has the ASYNCHRONOUS attribute then all of its
14    subobjects also have the ASYNCHRONOUS attribute.

           NOTE 5.10

           The ASYNCHRONOUS attribute specifies the variables that might be associated with a pending
           input/output storage sequence (the actual memory locations on which asynchronous input/output
           is being performed) while the scoping unit is in execution. This information could be used by the
           compiler to disable certain code motion optimizations.

           The ASYNCHRONOUS attribute is similar to the VOLATILE attribute. It is intended to facilitate
           traditional code motion optimizations in the presence of asynchronous input/output.


15    5.1.2.4        BIND attribute for data entities

16    The BIND attribute for a variable or common block specifies that it is capable of interoperating with a
17    C variable that has external linkage (15.3).

18    R514       language-binding-spec         is    BIND (C [, NAME = scalar-char-initialization-expr ])

19    C548       (R514) The scalar-char-initialization-expr shall be of default character kind.

           NOTE 5.11

           The C standard provides a facility for creating C identifiers whose characters are not restricted to
           the C basic character set. Such a C identifier is referred to as a universal character name (6.4.3 of
           the C standard). The name of such a C identifier may include characters that are not part of the
           representation method used by the processor for type default character. If so, the C entity cannot
           be linked (12.5.3, 15.3.1) with a Fortran entity.

           This standard does not require a processor to provide a means of linking Fortran entities with C
           entities whose names are specified using the universal character name facility.


20    The BIND attribute implies the SAVE attribute, which may be confirmed by explicit specification.



      SEP 2002                                           WORKING DRAFT                                        75


      J3/02-007R3                                    WORKING DRAFT                                 SEP 2002



            NOTE 5.12

            Specifying the BIND attribute for an entity might have no discernable effect for a processor that
            is its own companion processor.


 1    5.1.2.5      DIMENSION attribute

 2    The DIMENSION attribute specifies entities that are arrays. The rank or shape is specified by
 3    the array-spec, if there is one, in the entity-decl , or by the array-spec in the DIMENSION attr-spec
 4    otherwise. An array-spec in an entity-decl specifies either the rank or the rank and shape for a single
 5    array and overrides the array-spec in the DIMENSION attr-spec. To declare an array in a type declaration
 6    statement, either the DIMENSION attr-spec shall appear, or an array-spec shall appear in the entity-decl .
 7    The appearance of an array-spec in an entity-decl specifies the DIMENSION attribute for the entity.
 8    The DIMENSION attribute alternatively may be specified in the specification statements DIMENSION,
 9    ALLOCATABLE, POINTER, TARGET, or COMMON.

10    R515       array-spec                    is    explicit-shape-spec-list
11                                             or assumed-shape-spec-list
12                                             or deferred-shape-spec-list
13                                             or assumed-size-spec

14    C549       (R515)The maximum rank is seven.

            NOTE 5.13

            Examples of DIMENSION attribute specifications are:


            SUBROUTINE EX (N, A, B)
                 REAL, DIMENSION (N, 10) :: W                     ! Automatic explicit-shape array
                 REAL A (:), B (0:)                               ! Assumed-shape arrays
                 REAL, POINTER :: D (:, :)                        ! Array pointer
                 REAL, DIMENSION (:), POINTER :: P                ! Array pointer
                 REAL, ALLOCATABLE, DIMENSION (:) :: E ! Allocatable array



15    5.1.2.5.1     Explicit-shape array

16    An explicit-shape array is a named array that is declared with an explicit-shape-spec-list. This specifies
17    explicit values for the bounds in each dimension of the array.

18    R516       explicit-shape-spec           is    [ lower-bound : ] upper-bound
19    R517       lower-bound                   is    specification-expr
20    R518       upper-bound                   is    specification-expr

21    C550       (R516) An explicit-shape array whose bounds are not initialization expressions shall be a dummy
22               argument, a function result, or an automatic array of a procedure.

23    An automatic array is an explicit-shape array that is declared in a subprogram, is not a dummy
24    argument, and has bounds that are not initialization expressions.

25    If an explicit-shape array has bounds that are not initialization expressions, the bounds, and hence
26    shape, are determined at entry to the procedure by evaluating the bounds expressions. The bounds of
27    such an array are unaffected by the redefinition or undefinition of any variable during execution of the
28    procedure.

29    The values of each lower-bound and upper-bound determine the bounds of the array along a particular
30    dimension and hence the extent of the array in that dimension. The value of a lower bound or an upper




      76                                    WORKING DRAFT                                          SEP 2002


      SEP 2002                                WORKING DRAFT                                    J3/02-007R3



 1    bound may be positive, negative, or zero. The subscript range of the array in that dimension is the set
 2    of integer values between and including the lower and upper bounds, provided the upper bound is not
 3    less than the lower bound. If the upper bound is less than the lower bound, the range is empty, the
 4    extent in that dimension is zero, and the array is of zero size. If the lower-bound is omitted, the default
 5    value is 1. The number of sets of bounds specified is the rank.


 6    5.1.2.5.2       Assumed-shape array

 7    An assumed-shape array is a nonpointer dummy argument array that takes its shape from the asso-
 8    ciated actual argument array.

 9    R519       assumed-shape-spec           is    [ lower-bound ] :

10    The rank is equal to the number of colons in the assumed-shape-spec-list.

11    The extent of a dimension of an assumed-shape array dummy argument is the extent of the corresponding
12    dimension of the associated actual argument array. If the lower bound value is d and the extent of the
13    corresponding dimension of the associated actual argument array is s, then the value of the upper bound
14    is s + d - 1. The lower bound is lower-bound , if present, and 1 otherwise.


15    5.1.2.5.3       Deferred-shape array

16    A deferred-shape array is an allocatable array or an array pointer.

17    An allocatable array is an array that has the ALLOCATABLE attribute and a specified rank, but its
18    bounds, and hence shape, are determined by allocation or argument association.

19    An array with the ALLOCATABLE attribute shall be declared with a deferred-shape-spec-list. Nonkind
20    type parameters may be deferred.

21    An array pointer is an array with the POINTER attribute and a specified rank. Its bounds, and hence
22    shape, are determined when it is associated with a target. An array with the POINTER attribute shall
23    be declared with a deferred-shape-spec-list. Nonkind type parameters may be deferred.

24    R520       deferred-shape-spec          is    :

25    The rank is equal to the number of colons in the deferred-shape-spec-list.

26    The size, bounds, and shape of an unallocated allocatable array or a disassociated array pointer are
27    undefined. No part of such an array shall be referenced or defined; however, the array may appear as an
28    argument to an intrinsic inquiry function as specified in 13.1.

29    The bounds of each dimension of an allocatable array are those specified when the array is allocated.

30    The bounds of each dimension of an array pointer may be specified in two ways:

31             (1)    in an ALLOCATE statement (6.3.1) when the target is allocated, or

32             (2)    by pointer assignment (7.4.2).

33    The bounds of the array target or allocatable array are unaffected by any subsequent redefinition or
34    undefinition of variables involved in the bounds' specification expressions.


35    5.1.2.5.4       Assumed-size array

36    An assumed-size array is a dummy argument array whose size is assumed from that of an associated
37    actual argument. The rank and extents may differ for the actual and dummy arrays; only the size of the
38    actual array is assumed by the dummy array. An assumed-size array is declared with an assumed-size-
39    spec.



      SEP 2002                                           WORKING DRAFT                                       77


      J3/02-007R3                                      WORKING DRAFT                                         SEP 2002



 1    R521       assumed-size-spec               is    [ explicit-shape-spec-list , ] [ lower-bound : ] *

 2    C551       An assumed-size-spec shall not appear except as the declaration of the array bounds of a dummy
 3               data argument.

 4    C552       An assumed-size array with INTENT (OUT) shall not be of a type for which default initialization
 5               is specified.

 6    The size of an assumed-size array is determined as follows:

 7            (1)      If the actual argument associated with the assumed-size dummy array is an array of any
 8                     type other than default character, the size is that of the actual array.

 9            (2)      If the actual argument associated with the assumed-size dummy array is an array element
10                     of any type other than default character with a subscript order value of r (6.2.2.2) in an
11                     array of size x, the size of the dummy array is x - r + 1.

12            (3)      If the actual argument is a default character array, default character array element, or a
13                     default character array element substring (6.1.1), and if it begins at character storage unit t
14                     of an array with c character storage units, the size of the dummy array is MAX (INT ((c -
15                     t + 1)/e), 0), where e is the length of an element in the dummy character array.

16            (4)      If the actual argument is of type default character and is a scalar that is not an array element
17                     or array element substring designator, the size of the dummy array is MAX (INT (l/e), 0),
18                     where e is the length of an element in the dummy character array and l is the length of the
19                     actual argument.

20    The rank equals one plus the number of explicit-shape-specs.

21    An assumed-size array has no upper bound in its last dimension and therefore has no extent in its last
22    dimension and no shape. An assumed-size array name shall not be written as a whole array reference
23    except as an actual argument in a procedure reference for which the shape is not required.

24    The bounds of the first n - 1 dimensions are those specified by the explicit-shape-spec-list, if present, in
25    the assumed-size-spec. The lower bound of the last dimension is lower-bound , if present, and 1 otherwise.
26    An assumed-size array may be subscripted or sectioned (6.2.2.3). The upper bound shall not be omitted
27    from a subscript triplet in the last dimension.

28    If an assumed-size array has bounds that are not initialization expressions, the bounds are determined
29    at entry to the procedure. The bounds of such an array are unaffected by the redefinition or undefinition
30    of any variable during execution of the procedure.


31    5.1.2.6        EXTERNAL attribute

32    The EXTERNAL attribute specifies that an entity is an external procedure, dummy procedure,
33    procedure pointer, or block data subprogram. This attribute may also be specified by an EXTER-
34    NAL statement (12.3.2.2), a procedure-declaration-stmt (12.3.2.3) or an interface body that is not in an
35    interface block (12.3.2.1).

36    If an external procedure or dummy procedure is used as an actual argument or is the target of a procedure
37    pointer assignment, it shall be declared to have the EXTERNAL attribute.

38    A procedure that has both the EXTERNAL and POINTER attributes is a procedure pointer.


39    5.1.2.7        INTENT attribute

40    The INTENT attribute specifies the intended use of a dummy argument.

41    R522       intent-spec                     is    IN
42                                               or OUT



      78                                      WORKING DRAFT                                                  SEP 2002


      SEP 2002                                 WORKING DRAFT                                    J3/02-007R3



 1                                             or INOUT

 2    C553      (R522) A nonpointer object with the INTENT (IN) attribute shall not appear in a variable
 3              definition context (16.5.7).

 4    C554      (R522) A pointer object with the INTENT (IN) attribute shall not appear as

 5            (1)     A pointer-object in a pointer-assignment-stmt or nullify-stmt ,

 6            (2)     An allocate-object in an allocate-stmt or deallocate-stmt , or

 7            (3)     An actual argument in a reference to a procedure if the associated dummy argument is a
 8                    pointer with the INTENT (OUT) or INTENT (INOUT) attribute.

 9    The INTENT (IN) attribute for a nonpointer dummy argument specifies that it shall neither be de-
10    fined nor become undefined during the execution of the procedure. The INTENT (IN) attribute for a
11    pointer dummy argument specifies that during the execution of the procedure its association shall not
12    be changed except that it may become undefined if the target is deallocated other than through the
13    pointer (16.4.2.1.3).

14    The INTENT (OUT) attribute for a nonpointer dummy argument specifies that it shall be defined
15    before a reference to the dummy argument is made within the procedure and any actual argument that
16    becomes associated with such a dummy argument shall be definable. On invocation of the procedure,
17    such a dummy argument becomes undefined except for components of an object of derived type for
18    which default initialization has been specified. The INTENT (OUT) attribute for a pointer dummy
19    argument specifies that on invocation of the procedure the pointer association status of the dummy
20    argument becomes undefined. Any actual argument associated with such a pointer dummy shall be a
21    pointer variable.

22    The INTENT (INOUT) attribute for a nonpointer dummy argument specifies that it is intended for use
23    both to receive data from and to return data to the invoking scoping unit. Such a dummy argument may
24    be referenced or defined. Any actual argument that becomes associated with such a dummy argument
25    shall be definable. The INTENT (INOUT) attribute for a pointer dummy argument specifies that it is
26    intended for use both to receive a pointer association from and to return a pointer association to the
27    invoking scoping unit. Any actual argument associated with such a pointer dummy shall be a pointer
28    variable.

29    If no INTENT attribute is specified for a dummy argument, its use is subject to the limitations of the
30    associated actual argument (12.4.1.2, 12.4.1.3, 12.4.1.4).

           NOTE 5.14

           An example of INTENT specification is:


           SUBROUTINE MOVE (FROM, TO)
                   USE PERSON_MODULE
                   TYPE (PERSON), INTENT (IN) :: FROM
                   TYPE (PERSON), INTENT (OUT) :: TO



31    If an object has an INTENT attribute, then all of its subobjects have the same INTENT attribute.

           NOTE 5.15

           If a dummy argument is a derived-type object with a pointer component, then the pointer as a
           pointer is a subobject of the dummy argument, but the target of the pointer is not. Therefore, the
           restrictions on subobjects of the dummy object apply to the pointer in contexts where it is used as
           a pointer, but not in contexts where it is dereferenced to indicate its target. For example, if X is a





      SEP 2002                                         WORKING DRAFT                                          79


      J3/02-007R3                                 WORKING DRAFT                                      SEP 2002



            NOTE 5.15 (cont.)

            dummy argument of derived type with an integer pointer component P, and X has INTENT(IN),
            then the statement


            X%P => NEW_TARGET


            is prohibited, but


            X%P = 0


            is allowed (provided that X%P is associated with a definable target).

            Similarly, the INTENT restrictions on pointer dummy arguments apply only to the association of
            the dummy argument; they do not restrict the operations allowed on its target.


            NOTE 5.16

            Argument intent specifications serve several purposes in addition to documenting the intended use
            of dummy arguments. A processor can check whether an INTENT (IN) dummy argument is used
            in a way that could redefine it. A slightly more sophisticated processor could check to see whether
            an INTENT (OUT) dummy argument could possibly be referenced before it is defined. If the
            procedure's interface is explicit, the processor can also verify that actual arguments corresponding
            to INTENT (OUT) or INTENT (INOUT) dummy arguments are definable. A more sophisticated
            processor could use this information to optimize the translation of the referencing scoping unit
            by taking advantage of the fact that actual arguments corresponding to INTENT (IN) dummy
            arguments will not be changed and that any prior value of an actual argument corresponding to
            an INTENT (OUT) dummy argument will not be referenced and could thus be discarded.

            INTENT (OUT) means that the value of the argument after invoking the procedure is entirely
            the result of executing that procedure. If there is any possibility that an argument should retain
            its current value rather than being redefined, INTENT (INOUT) should be used rather than
            INTENT (OUT), even if there is no explicit reference to the value of the dummy argument.
            Because an INTENT(OUT) variable is considered undefined on entry to the procedure, any default
            initialization specified for its type will be applied.

            INTENT (INOUT) is not equivalent to omitting the INTENT attribute. The argument corre-
            sponding to an INTENT (INOUT) dummy argument always shall be definable, while an argument
            corresponding to a dummy argument without an INTENT attribute need be definable only if the
            dummy argument is actually redefined.


 1    5.1.2.8     INTRINSIC attribute

 2    The INTRINSIC attribute confirms that a name is the specific name (13.6) or generic name (13.5)
 3    of an intrinsic procedure. The INTRINSIC attribute allows the specific name of an intrinsic procedure
 4    that is listed in 13.6 and not marked with a bullet (�) to be used as an actual argument (12.4).

 5    Declaring explicitly that a generic intrinsic procedure name has the INTRINSIC attribute does not cause
 6    that name to lose its generic property.

 7    If the specific name of an intrinsic procedure (13.6) is used as an actual argument, the name shall be
 8    explicitly specified to have the INTRINSIC attribute.

 9    C555       (R504) (R1216) If the name of a generic intrinsic procedure is explicitly declared to have the
10               INTRINSIC attribute, and it is also the generic name in one or more generic interfaces (12.3.2.1)
11               accessible in the same scoping unit, the procedures in the interfaces and the specific intrinsic



      80                                   WORKING DRAFT                                             SEP 2002


      SEP 2002                                WORKING DRAFT                                      J3/02-007R3



 1               procedures shall all be functions or all be subroutines, and the characteristics of the specific
 2               intrinsic procedures and the procedures in the interfaces shall differ as specified in 16.2.3.


 3    5.1.2.9     OPTIONAL attribute

 4    The OPTIONAL attribute specifies that the dummy argument need not be associated with an actual
 5    argument in a reference to the procedure (12.4.1.6). The PRESENT intrinsic function may be used
 6    to determine whether an actual argument has been associated with a dummy argument having the
 7    OPTIONAL attribute.


 8    5.1.2.10     PARAMETER attribute

 9    The PARAMETER attribute specifies entities that are named constants. The object-name has the
10    value specified by the initialization-expr that appears on the right of the equals; if necessary, the value
11    is converted according to the rules of intrinsic assignment (7.4.1.3) to a value that agrees in type, type
12    parameters, and shape with the object-name.

13    A named constant shall not be referenced unless it has been defined previously in the same statement,
14    defined in a prior statement, or made accessible by use or host association.

           NOTE 5.17

           Examples of declarations with a PARAMETER attribute are:


           REAL, PARAMETER :: ONE = 1.0, Y = 4.1 / 3.0
           INTEGER, DIMENSION (3), PARAMETER :: ORDER = (/ 1, 2, 3 /)
           TYPE(NODE), PARAMETER :: DEFAULT = NODE(0, NULL ( ))



15    5.1.2.11     POINTER attribute

16    Entities with the POINTER attribute can be associated with different data objects or procedures
17    during execution of a program. A pointer is either a data pointer or a procedure pointer. Procedure
18    pointers are described in 12.3.2.3.

19    A data pointer shall neither be referenced nor defined unless it is pointer associated with a target object
20    that may be referenced or defined.

21    If a data pointer is associated, the values of its deferred type parameters are the same as the values of
22    the corresponding type parameters of its target.

23    A procedure pointer shall not be referenced unless it is pointer associated with a target procedure.

           NOTE 5.18

           Examples of POINTER attribute specifications are:


           TYPE (NODE), POINTER :: CURRENT, TAIL
           REAL, DIMENSION (:, :), POINTER :: IN, OUT, SWAP


           For a more elaborate example see C.2.1.


24    5.1.2.12     PROTECTED attribute

25    The PROTECTED attribute imposes limitations on the usage of module entities.

26    Other than within the module in which an entity is given the PROTECTED attribute,




      SEP 2002                                       WORKING DRAFT                                               81


      J3/02-007R3                                   WORKING DRAFT                                        SEP 2002



 1           (1)     if it is a nonpointer object, it is not definable, and

 2           (2)     if it is a pointer, it shall not appear in a context that causes its association status to change.

 3    If an object has the PROTECTED attribute, all of its subobjects have the PROTECTED attribute.

            NOTE 5.19

            An example of the PROTECTED attribute:


                    MODULE temperature
                      REAL, PROTECTED :: temp_c, temp_f
                    CONTAINS
                      SUBROUTINE set_temperature_c(c)
                        REAL, INTENT(IN) :: c
                        temp_c = c
                        temp_f = temp_c*(9.0/5.0) + 32
                      END SUBROUTINE
                    END MODULE


            The PROTECTED attribute ensures that the variables temp c and temp f cannot be modified
            other than via the set temperature c procedure, thus keeping them consistent with each other.


 4    5.1.2.13      SAVE attribute

 5    An entity with the SAVE attribute, in the scoping unit of a subprogram, retains its association status,
 6    allocation status, definition status, and value after execution of a RETURN or END statement unless it
 7    is a pointer and its target becomes undefined (16.4.2.1.3(3)). It is shared by all instances (12.5.2.3) of
 8    the subprogram.

 9    An entity with the SAVE attribute, declared in the scoping unit of a module, retains its association
10    status, allocation status, definition status, and value after a RETURN or END statement is executed in
11    a procedure that accesses the module unless it is a pointer and its target becomes undefined.

12    A saved entity is an entity that has the SAVE attribute. An unsaved entity is an entity that does not
13    have the SAVE attribute.

14    The SAVE attribute may appear in declarations in a main program and has no effect.


15    5.1.2.14      TARGET attribute

16    An object with the TARGET attribute may have a pointer associated with it (7.4.2). An object
17    without the TARGET attribute shall not have an accessible pointer associated with it.

            NOTE 5.20

            In addition to variables explicitly declared to have the TARGET attribute, the objects created by
            allocation of pointers (6.3.1.2) have the TARGET attribute.


18    If an object has the TARGET attribute, then all of its nonpointer subobjects also have the TARGET
19    attribute.

            NOTE 5.21

            Examples of TARGET attribute specifications are:





      82                                    WORKING DRAFT                                                SEP 2002


      SEP 2002                              WORKING DRAFT                                      J3/02-007R3



           NOTE 5.21 (cont.)

           TYPE (NODE), TARGET :: HEAD
           REAL, DIMENSION (1000, 1000), TARGET :: A, B


           For a more elaborate example see C.2.2.


           NOTE 5.22

           Every object designator that starts from a target object will have either the TARGET or POINTER
           attribute. If pointers are involved, the designator might not necessarily be a subobject of the
           original target object, but because pointers may point only to targets, there is no way to end up
           at a nonpointer that is not a target.


 1    5.1.2.15    VALUE attribute

 2    The VALUE attribute specifies a type of argument association (12.4.1.2) for a dummy argument.


 3    5.1.2.16    VOLATILE attribute

 4    An object shall have the VOLATILE attribute if there is a reference to or definition of the object, or
 5    the object becomes undefined, by means not specified in this standard.

 6    An object may have the VOLATILE attribute in a particular scoping unit without necessarily having
 7    it in other scoping units. If an object has the VOLATILE attribute then all of its subobjects also have
 8    the VOLATILE attribute.

           NOTE 5.23

           The Fortran processor should use the most recent definition of a volatile object when a value
           is required.    Likewise, it should make the most recent Fortran definition available.      It is the
           programmer's responsibility to manage the interactions with the non-Fortran processes.


 9    If the POINTER and VOLATILE attributes are both specified, then the volatility applies to the pointer
10    association.

           NOTE 5.24

           If the value of the target of a pointer can change by means outside of Fortran, while a pointer is
           associated with a target, then the pointer shall have the VOLATILE attribute. Usually a pointer
           should have the VOLATILE attribute if its target has the VOLATILE attribute. Similarly, all
           members of an EQUIVALENCE group should have the VOLATILE attribute if one member has
           the VOLATILE attribute.


           NOTE 5.25

           If a pointer has the VOLATILE attribute, its target does not necessarily need the VOLATILE
           attribute. In such a case, if the target is accessed through the pointer, the most recent association
           status of the pointer needs to be loaded from memory and used in order to get the correct object.
           This has the effect of treating the object as volatile when it is accessed through the pointer, while
           access to the object that does not occur through the pointer is nonvolatile and can be optimized.


11    If the ALLOCATABLE and VOLATILE attributes are both specified, then the volatility applies to the
12    allocation status, bounds, and definition status.





      SEP 2002                                      WORKING DRAFT                                            83


      J3/02-007R3                                     WORKING DRAFT                                         SEP 2002


 1    5.2       Attribute specification statements

 2    All attributes (other than type) may be specified for entities, independently of type, by separate at-
 3    tribute specification statements. The combination of attributes that may be specified for a particular
 4    entity is subject to the same restrictions as for type declaration statements regardless of the method of
 5    specification. This also applies to PROCEDURE, EXTERNAL, and INTRINSIC statements.


 6    5.2.1      Accessibility statements

 7    R523      access-stmt                     is    access-spec [ [ :: ] access-id -list ]
 8    R524      access-id                       is    use-name
 9                                              or generic-spec

10    C556      (R523) An access-stmt shall appear only in the specification-part of a module. Only one ac-
11              cessibility statement with an omitted access-id -list is permitted in the specification-part of a
12              module.

13    C557      (R524) Each use-name shall be the name of a named variable, procedure, derived type, named
14              constant, or namelist group.

15    An access-stmt with an access-id -list specifies the accessibility attribute (5.1.2.1), PUBLIC or PRIVATE,
16    of each access-id in the list. An access-stmt without an access-id list specifies the default accessibility
17    that applies to all potentially accessible identifiers in the specification-part of the module.                The
18    statement

19    PUBLIC

20    specifies a default of public accessibility. The statement

21    PRIVATE

22    specifies a default of private accessibility. If no such statement appears in a module, the default is public
23    accessibility.

             NOTE 5.26

             Examples of accessibility statements are:


             MODULE EX
                 PRIVATE
                 PUBLIC :: A, B, C, ASSIGNMENT (=), OPERATOR (+)



24    5.2.2      ALLOCATABLE statement

25    R525      allocatable-stmt                is    ALLOCATABLE [ :: ]
26                                                      object-name [ ( deferred-shape-spec-list ) ]
27                                                       [ , object-name [ ( deferred-shape-spec-list ) ] ] ...

28    This statement specifies the ALLOCATABLE attribute (5.1.2.2) for a list of objects.

             NOTE 5.27

             An example of an ALLOCATABLE statement is:


             REAL A, B (:), SCALAR
             ALLOCATABLE :: A (:, :), B, SCALAR





      84                                  WORKING DRAFT                                                     SEP 2002


      SEP 2002                                WORKING DRAFT                                            J3/02-007R3


 1    5.2.3      ASYNCHRONOUS statement

 2    R526      asynchronous-stmt             is    ASYNCHRONOUS [ :: ] object-name-list

 3    The ASYNCHRONOUS statement specifies the ASYNCHRONOUS attribute (5.1.2.3) for a list of ob-
 4    jects.


 5    5.2.4      BIND statement

 6    R527      bind-stmt                     is    language-binding-spec [ :: ] bind-entity-list
 7    R528      bind-entity                   is    entity-name
 8                                            or / common-block-name /

 9    C558      (R527) If any bind-entity in a bind-stmt is an entity-name, the bind-stmt shall appear in the
10              specification part of a module and the entity shall be an interoperable variable (15.2.4, 15.2.5).

11    C559      (R527) If the language-binding-spec has a NAME= specifier, the bind-entity-list shall consist of
12              a single bind-entity.

13    C560      (R527) If a bind-entity is a common block, each variable of the common block shall be interop-
14              erable (15.2.4, 15.2.5).

15    The BIND statement specifies the BIND attribute (5.1.2.4) for a list of variables and common blocks.


16    5.2.5      DATA statement

17    R529      data-stmt                     is    DATA data-stmt-set [ [ , ] data-stmt-set ] ...

18    This statement is used to specify explicit initialization (5.1).

19    A variable, or part of a variable, shall not be explicitly initialized more than once in a program. If a
20    nonpointer object has been specified with default initialization in a type definition, it shall not appear
21    in a data-stmt-object -list.

22    A variable that appears in a DATA statement and has not been typed previously may appear in a
23    subsequent type declaration only if that declaration confirms the implicit typing.                An array name,
24    array section, or array element that appears in a DATA statement shall have had its array properties
25    established by a previous specification statement.

26    Except for variables in named common blocks, a named variable has the SAVE attribute if any part
27    of it is initialized in a DATA statement, and this may be confirmed by a SAVE statement or a type
28    declaration statement containing the SAVE attribute.

29    R530      data-stmt-set                 is    data-stmt-object -list / data-stmt-value-list /
30    R531      data-stmt-object              is    variable
31                                            or data-implied-do
32    R532      data-implied-do               is    ( data-i-do-object -list , data-i-do-variable =
33                                                     scalar-int-expr , scalar-int-expr [ , scalar-int-expr ] )
34    R533      data-i-do-object              is    array-element
35                                            or scalar-structure-component
36                                            or data-implied-do
37    R534      data-i-do-variable            is    scalar-int-variable

38    C561      (R531) In a variable that is a data-stmt-object , any subscript, section subscript, substring start-
39              ing point, and substring ending point shall be an initialization expression.

40    C562      (R531) A variable whose designator is included in a data-stmt-object -list or a data-i-do-object -




      SEP 2002                                        WORKING DRAFT                                                 85


      J3/02-007R3                                 WORKING DRAFT                                      SEP 2002



 1            list shall not be: a dummy argument, made accessible by use association or host association, in
 2            a named common block unless the DATA statement is in a block data program unit, in a blank
 3            common block, a function name, a function result name, an automatic object, or an allocatable
 4            variable.

 5    C563    (R531) A data-i-do-object or a variable that appears as a data-stmt-object shall not be an object
 6            designator in which a pointer appears other than as the entire rightmost part-ref .

 7    C564    (R534)data-i-do-variable shall be a named variable.

 8    C565    (R532) A scalar-int-expr of a data-implied-do shall involve as primaries only constants, subob-
 9            jects of constants, or DO variables of the containing data-implied-dos, and each operation shall
10            be intrinsic.

11    C566    (R533) The array-element shall be a variable.

12    C567    (R533) The scalar-structure-component shall be a variable.

13    C568    (R533) The scalar-structure-component shall contain at least one part-ref that contains a sub-
14            script -list.

15    C569    (R533) In an array-element or a scalar-structure-component that is a data-i-do-object , any sub-
16            script shall be an expression whose primaries are either constants, subobjects of constants, or
17            DO variables of this data-implied-do or the containing data-implied-dos, and each operation shall
18            be intrinsic.

19    R535    data-stmt-value               is    [ data-stmt-repeat * ] data-stmt-constant
20    R536    data-stmt-repeat              is    scalar-int-constant
21                                          or scalar-int-constant-subobject

22    C570    (R536) The data-stmt-repeat shall be positive or zero. If the data-stmt-repeat is a named con-
23            stant, it shall have been declared previously in the scoping unit or made accessible by use
24            association or host association.

25    R537    data-stmt-constant            is    scalar-constant
26                                          or scalar-constant-subobject
27                                          or signed-int-literal-constant
28                                          or signed-real-literal-constant
29                                          or null-init
30                                          or structure-constructor

31    C571    (R537) If a DATA statement constant value is a named constant or a structure constructor, the
32            named constant or derived type shall have been declared previously in the scoping unit or made
33            accessible by use or host association.

34    C572    (R537) If a data-stmt-constant is a structure-constructor , it shall be an initialization expression.

35    R538    int-constant-subobject        is    constant-subobject

36    C573    (R538) int-constant-subobject shall be of type integer.

37    R539    constant-subobject            is    designator

38    C574    (R539) constant-subobject shall be a subobject of a constant.

39    C575    (R539) Any subscript, substring starting point, or substring ending point shall be an initializa-
40            tion expression.





      86                                 WORKING DRAFT                                               SEP 2002


      SEP 2002                                WORKING DRAFT                                      J3/02-007R3



 1    The data-stmt-object -list is expanded to form a sequence of pointers and scalar variables, referred to as
 2    "sequence of variables" in subsequent text. A nonpointer array whose unqualified name appears in a
 3    data-stmt-object -list is equivalent to a complete sequence of its array elements in array element order
 4    (6.2.2.2). An array section is equivalent to the sequence of its array elements in array element order. A
 5    data-implied-do is expanded to form a sequence of array elements and structure components, under the
 6    control of the implied-DO variable, as in the DO construct (8.1.6.4).

 7    The data-stmt-value-list is expanded to form a sequence of data-stmt-constant s. A data-stmt-repeat
 8    indicates the number of times the following data-stmt-constant is to be included in the sequence; omission
 9    of a data-stmt-repeat has the effect of a repeat factor of 1.

10    A zero-sized array or an implied-DO list with an iteration count of zero contributes no variables to the
11    expanded sequence of variables, but a zero-length scalar character variable does contribute a variable
12    to the expanded sequence. A data-stmt-constant with a repeat factor of zero contributes no data-stmt-
13    constant s to the expanded sequence of scalar data-stmt-constant s.

14    The expanded sequences of variables and data-stmt-constant s are in one-to-one correspondence. Each
15    data-stmt-constant specifies the initial value or null-init for the corresponding variable. The lengths of
16    the two expanded sequences shall be the same.

17    A data-stmt-constant shall be null-init if and only if the corresponding data-stmt-object has the POINT-
18    ER attribute. The initial association status of a pointer data-stmt-object is disassociated.

19    A data-stmt-constant other than null-init shall be compatible with its corresponding variable according
20    to the rules of intrinsic assignment (7.4.1.2). The variable is initially defined with the value specified by
21    the data-stmt-constant ; if necessary, the value is converted according to the rules of intrinsic assignment
22    (7.4.1.3) to a value that agrees in type, type parameters, and shape with the variable.

23    If a data-stmt-constant is a boz-literal-constant , the corresponding variable shall be of type integer. The
24    boz-literal-constant is treated as if it were an int-literal-constant with a kind-param that specifies the
25    representation method with the largest decimal exponent range supported by the processor.

           NOTE 5.28

           Examples of DATA statements are:


           CHARACTER (LEN = 10)       NAME
           INTEGER, DIMENSION (0:9) :: MILES
           REAL, DIMENSION (100, 100) :: SKEW
           TYPE (NODE), POINTER :: HEAD_OF_LIST
           TYPE (PERSON) MYNAME, YOURNAME
           DATA NAME / 'JOHN DOE' /, MILES / 10 * 0 /
           DATA ((SKEW (K, J), J = 1, K), K = 1, 100) / 5050 * 0.0 /
           DATA ((SKEW (K, J), J = K + 1, 100), K = 1, 99) / 4950 * 1.0 /
           DATA HEAD_OF_LIST / NULL() /
           DATA MYNAME / PERSON (21, 'JOHN SMITH') /
           DATA YOURNAME % AGE, YOURNAME % NAME / 35, 'FRED BROWN' /


           The character variable NAME is initialized with the value JOHN DOE with padding on the right
           because the length of the constant is less than the length of the variable. All ten elements of
           the integer array MILES are initialized to zero. The two-dimensional array SKEW is initialized
           so that the lower triangle of SKEW is zero and the strict upper triangle is one. The structures
           MYNAME and YOURNAME are declared using the derived type PERSON from Note 4.20. The
           pointer HEAD OF LIST is declared using the derived type NODE from Note 4.29; it is initially
           disassociated. MYNAME is initialized by a structure constructor. YOURNAME is initialized by
           supplying a separate value for each component.




      SEP 2002                                     WORKING DRAFT                                              87


      J3/02-007R3                                 WORKING DRAFT                                    SEP 2002


 1    5.2.6     DIMENSION statement

 2    R540      dimension-stmt              is    DIMENSION [ :: ] array-name ( array-spec )
 3                                                  [ , array-name ( array-spec ) ] ...

 4    This statement specifies the DIMENSION attribute (5.1.2.5) and the array properties for each object
 5    named.

            NOTE 5.29

            An example of a DIMENSION statement is:


            DIMENSION A (10), B (10, 70), C (:)



 6    5.2.7     INTENT statement

 7    R541      intent-stmt                 is    INTENT ( intent-spec ) [ :: ] dummy-arg-name-list

 8    This statement specifies the INTENT attribute (5.1.2.7) for the dummy arguments in the list.

            NOTE 5.30

            An example of an INTENT statement is:


            SUBROUTINE EX (A, B)
                INTENT (INOUT) :: A, B



 9    5.2.8     OPTIONAL statement

10    R542      optional-stmt               is    OPTIONAL [ :: ] dummy-arg-name-list

11    This statement specifies the OPTIONAL attribute (5.1.2.9) for the dummy arguments in the list.

            NOTE 5.31

            An example of an OPTIONAL statement is:


            SUBROUTINE EX (A, B)
                OPTIONAL :: B



12    5.2.9     PARAMETER statement

13    The PARAMETER statement specifies the PARAMETER attribute (5.1.2.10) and the values for
14    the named constants in the list.

15    R543      parameter-stmt              is    PARAMETER ( named-constant-def -list )
16    R544      named-constant-def          is    named-constant = initialization-expr

17    The named constant shall have its type, type parameters, and shape specified in a prior specification of
18    the specification-part or declared implicitly (5.3). If the named constant is typed by the implicit typing
19    rules, its appearance in any subsequent specification of the specification-part shall confirm this implied
20    type and the values of any implied type parameters.

21    The value of each named constant is that specified by the corresponding initialization expression; if
22    necessary, the value is converted according to the rules of intrinsic assignment (7.4.1.3) to a value that
23    agrees in type, type parameters, and shape with the named constant.




      88                                  WORKING DRAFT                                            SEP 2002


      SEP 2002                               WORKING DRAFT                                         J3/02-007R3



           NOTE 5.32

           An example of a PARAMETER statement is:


           PARAMETER (MODULUS = MOD (28, 3), NUMBER_OF_SENATORS = 100)



 1    5.2.10      POINTER statement

 2    R545      pointer-stmt                 is    POINTER [ :: ] pointer-decl -list
 3    R546      pointer-decl                 is    object-name [ ( deferred-shape-spec-list ) ]
 4                                           or proc-entity-name

 5    C576      (R546) A proc-entity-name shall also be declared in a procedure-declaration-stmt .

 6    This statement specifies the POINTER attribute (5.1.2.11) for a list of objects and procedure entities.

           NOTE 5.33

           An example of a POINTER statement is:


           TYPE (NODE) :: CURRENT
           POINTER :: CURRENT, A (:, :)



 7    5.2.11      PROTECTED statement

 8    R547      protected-stmt               is    PROTECTED [ :: ] entity-name-list

 9    The PROTECTED statement specifies the PROTECTED attribute (5.1.2.12) for a list of entities.


10    5.2.12      SAVE statement

11    R548      save-stmt                    is    SAVE [ [ :: ] saved-entity-list ]
12    R549      saved-entity                 is    object-name
13                                           or proc-pointer-name
14                                           or / common-block-name /
15    R550      proc-pointer-name            is    name

16    C577      (R550) A proc-pointer-name shall be the name of a procedure pointer.

17    C578      (R548) If a SAVE statement with an omitted saved entity list occurs in a scoping unit, no other
18              explicit occurrence of the SAVE attribute or SAVE statement is permitted in the same scoping
19              unit.

20    A SAVE statement with a saved entity list specifies the SAVE attribute (5.1.2.13) for all entities named
21    in the list or included within a common block named in the list. A SAVE statement without a saved
22    entity list is treated as though it contained the names of all allowed items in the same scoping unit.

23    If a particular common block name is specified in a SAVE statement in any scoping unit of a program
24    other than the main program, it shall be specified in a SAVE statement in every scoping unit in which
25    that common block appears except in the scoping unit of the main program. For a common block
26    declared in a SAVE statement, the values in the common block storage sequence (5.5.2.1) at the time a
27    RETURN or END statement is executed are made available to the next scoping unit in the execution
28    sequence of the program that specifies the common block name or accesses the common block. If a
29    named common block is specified in the scoping unit of the main program, the current values of the
30    common block storage sequence are made available to each scoping unit that specifies the named common
31    block. The definition status of each object in the named common block storage sequence depends on




      SEP 2002                                       WORKING DRAFT                                              89


      J3/02-007R3                                 WORKING DRAFT                                     SEP 2002



 1    the association that has been established for the common block storage sequence.

 2    A SAVE statement may appear in the specification part of a main program and has no effect.

             NOTE 5.34

             An example of a SAVE statement is:


             SAVE A, B, C, / BLOCKA /, D



 3    5.2.13      TARGET statement

 4    R551      target-stmt                 is    TARGET [ :: ] object-name [ ( array-spec ) ]
 5                                                   [ , object-name [ ( array-spec ) ] ] ...

 6    This statement specifies the TARGET attribute (5.1.2.14) for a list of objects.

             NOTE 5.35

             An example of a TARGET statement is:


             TARGET :: A (1000, 1000), B



 7    5.2.14      VALUE statement

 8    R552      value-stmt                  is    VALUE [ :: ] dummy-arg-name-list

 9    The VALUE statement specifies the VALUE attribute (5.1.2.15) for a list of dummy arguments.


10    5.2.15      VOLATILE statement

11    R553      volatile-stmt               is    VOLATILE [ :: ] object-name-list

12    The VOLATILE statement specifies the VOLATILE attribute (5.1.2.16) for a list of objects.


13    5.3       IMPLICIT statement

14    In a scoping unit, an IMPLICIT statement specifies a type, and possibly type parameters, for all
15    implicitly typed data entities whose names begin with one of the letters specified in the statement.
16    Alternatively, it may indicate that no implicit typing rules are to apply in a particular scoping unit.

17    R554      implicit-stmt               is    IMPLICIT implicit-spec-list
18                                          or IMPLICIT NONE
19    R555      implicit-spec               is    declaration-type-spec ( letter-spec-list )
20    R556      letter-spec                 is    letter [ � letter ]

21    C579      (R554) If IMPLICIT NONE is specified in a scoping unit, it shall precede any PARAMETER
22              statements that appear in the scoping unit and there shall be no other IMPLICIT statements
23              in the scoping unit.

24    C580      (R556) If the minus and second letter appear, the second letter shall follow the first letter
25              alphabetically.

26    A letter-spec consisting of two letters separated by a minus is equivalent to writing a list containing all
27    of the letters in alphabetical order in the alphabetic sequence from the first letter through the second
28    letter. For example, A�C is equivalent to A, B, C. The same letter shall not appear as a single letter, or



      90                                 WORKING DRAFT                                              SEP 2002


      SEP 2002                              WORKING DRAFT                                       J3/02-007R3



 1    be included in a range of letters, more than once in all of the IMPLICIT statements in a scoping unit.

 2    In each scoping unit, there is a mapping, which may be null, between each of the letters A, B, ..., Z
 3    and a type (and type parameters). An IMPLICIT statement specifies the mapping for the letters in
 4    its letter-spec-list. IMPLICIT NONE specifies the null mapping for all the letters. If a mapping is not
 5    specified for a letter, the default for a program unit or an interface body is default integer if the letter
 6    is I, J, ..., or N and default real otherwise, and the default for an internal or module procedure is the
 7    mapping in the host scoping unit.

 8    Any data entity that is not explicitly declared by a type declaration statement, is not an intrinsic
 9    function, and is not made accessible by use association or host association is declared implicitly to be of
10    the type (and type parameters) mapped from the first letter of its name, provided the mapping is not
11    null. The mapping for the first letter of the data entity shall either have been established by a prior
12    IMPLICIT statement or be the default mapping for the letter. The mapping may be to a derived type
13    that is inaccessible in the local scope if the derived type is accessible to the host scope. The data entity
14    is treated as if it were declared in an explicit type declaration in the outermost scoping unit in which it
15    appears. An explicit type specification in a FUNCTION statement overrides an IMPLICIT statement
16    for the name of the result variable of that function subprogram.

           NOTE 5.36

           The following are examples of the use of IMPLICIT statements:


           MODULE EXAMPLE_MODULE
              IMPLICIT NONE
              ...
              INTERFACE
                  FUNCTION FUN (I)         ! Not all data entities need
                       INTEGER FUN         ! be declared explicitly
                  END FUNCTION FUN
              END INTERFACE
           CONTAINS
              FUNCTION JFUN (J)            ! All data entities need to
                  INTEGER JFUN, J          ! be declared explicitly.
                  ...
              END FUNCTION JFUN
           END MODULE EXAMPLE_MODULE
           SUBROUTINE SUB
              IMPLICIT COMPLEX (C)
              C = (3.0, 2.0)          ! C is implicitly declared COMPLEX
              ...
           CONTAINS
              SUBROUTINE SUB1
                  IMPLICIT INTEGER (A, C)
                  C = (0.0, 0.0)      ! C is host associated and of
                                      ! type complex
                  Z = 1.0             ! Z is implicitly declared REAL
                  A = 2               ! A is implicitly declared INTEGER
                  CC = 1              ! CC is implicitly declared INTEGER
                  ...
              END SUBROUTINE SUB1
              SUBROUTINE SUB2
                  Z = 2.0             ! Z is implicitly declared REAL and
                                      ! is different from the variable of





      SEP 2002                                     WORKING DRAFT                                              91


J3/02-007R3                               WORKING DRAFT                                      SEP 2002



      NOTE 5.36 (cont.)

                                ! the same name in SUB1
             ...
         END SUBROUTINE SUB2
         SUBROUTINE SUB3
             USE EXAMPLE_MODULE      ! Accesses integer function FUN
                                     ! by use association
             Q = FUN (K)             ! Q is implicitly declared REAL and
             ...                     ! K is implicitly declared INTEGER
         END SUBROUTINE SUB3
      END SUBROUTINE SUB



      NOTE 5.37

      An IMPLICIT statement may specify a declaration-type-spec of derived type.

      For example, given an IMPLICIT statement and a type defined as follows:


      IMPLICIT TYPE (POSN) (A-B, W-Z), INTEGER (C-V)
      TYPE POSN
         REAL X, Y
         INTEGER Z
      END TYPE POSN


      variables beginning with the letters A, B, W, X, Y, and Z are implicitly typed with the type POSN
      and the remaining variables are implicitly typed with type INTEGER.


      NOTE 5.38

      The following is an example of a mapping to a derived type that is inaccessible in the local scope:


            PROGRAM MAIN
              IMPLICIT TYPE(BLOB) (A)
              TYPE BLOB
                INTEGER :: I
              END TYPE BLOB
              TYPE(BLOB) :: B
              CALL STEVE
            CONTAINS
              SUBROUTINE STEVE
                INTEGER :: BLOB
                ..
                AA = B
                ..
              END SUBROUTINE STEVE
            END PROGRAM MAIN


      In the subroutine STEVE, it is not possible to explicitly declare a variable to be of type BLOB
      because BLOB has been given a different meaning, but implicit mapping for the letter A still maps
      to type BLOB, so AA is of type BLOB.





92                                  WORKING DRAFT                                            SEP 2002


      SEP 2002                              WORKING DRAFT                                      J3/02-007R3


 1    5.4      NAMELIST statement

 2    A NAMELIST statement specifies a group of named data objects, which may be referred to by a
 3    single name for the purpose of data transfer (9.5, 10.10).

 4    R557     namelist-stmt                is    NAMELIST
 5                                                  / namelist-group-name / namelist-group-object -list
 6                                                  [ [ , ] / namelist-group-name /
 7                                                  namelist-group-object -list ] . . .

 8    C581     (R557) The namelist-group-name shall not be a name made accessible by use association.

 9    R558     namelist-group-object        is    variable-name

10    C582     (R558) A namelist-group-object shall not be an assumed-size array.

11    C583     (R557) A namelist-group-object shall not have the PRIVATE attribute if the namelist-group-
12             name has the PUBLIC attribute.

13    The order in which the variables are specified in the NAMELIST statement determines the order in
14    which the values appear on output.

15    Any namelist-group-name may occur more than once in the NAMELIST statements in a scoping unit.
16    The namelist-group-object -list following each successive appearance of the same namelist-group-name in
17    a scoping unit is treated as a continuation of the list for that namelist-group-name.

18    A namelist group object may be a member of more than one namelist group.

19    A namelist group object shall either be accessed by use or host association or shall have its type, type
20    parameters, and shape specified by previous specification statements or the procedure heading in the
21    same scoping unit or by the implicit typing rules in effect for the scoping unit. If a namelist group object
22    is typed by the implicit typing rules, its appearance in any subsequent type declaration statement shall
23    confirm the implied type and type parameters.

             NOTE 5.39

             An example of a NAMELIST statement is:


             NAMELIST /NLIST/ A, B, C



24    5.5      Storage association of data objects

25    In general, the physical storage units or storage order for data objects is not specifiable. However,
26    the EQUIVALENCE, COMMON, and SEQUENCE statements and the BIND(C) type-attr-spec provide
27    for control of the order and layout of storage units. The general mechanism of storage association is
28    described in 16.4.3.


29    5.5.1     EQUIVALENCE statement

30    An EQUIVALENCE statement is used to specify the sharing of storage units by two or more objects
31    in a scoping unit. This causes storage association of the objects that share the storage units.

32    If the equivalenced objects have differing type or type parameters, the EQUIVALENCE statement does
33    not cause type conversion or imply mathematical equivalence. If a scalar and an array are equivalenced,
34    the scalar does not have array properties and the array does not have the properties of a scalar.





      SEP 2002                                      WORKING DRAFT                                            93


      J3/02-007R3                                    WORKING DRAFT                                        SEP 2002



 1    R559     equivalence-stmt                is    EQUIVALENCE equivalence-set -list
 2    R560     equivalence-set                 is    ( equivalence-object , equivalence-object -list )
 3    R561     equivalence-object              is    variable-name
 4                                             or array-element
 5                                             or substring

 6    C584     (R561) An equivalence-object shall not be a designator with a base object that is a dummy
 7             argument, a pointer, an allocatable variable, a derived-type object that has an allocatable ulti-
 8             mate component, an object of a nonsequence derived type, an object of a derived type that has
 9             a pointer at any level of component selection, an automatic object, a function name, an entry
10             name, a result name, a variable with the BIND attribute, a variable in a common block that
11             has the BIND attribute, or a named constant.

12    C585     (R561) An equivalence-object shall not be a designator that has more than one part-ref .

13    C586     (R561) An equivalence-object shall not have the TARGET attribute.

14    C587     (R561) Each subscript or substring range expression in an equivalence-object shall be an integer
15             initialization expression (7.1.7).

16    C588     (R560) If an equivalence-object is of type default integer, default real, double precision real,
17             default complex, default logical, or numeric sequence type, all of the objects in the equivalence
18             set shall be of these types.

19    C589     (R560) If an equivalence-object is of type default character or character sequence type, all of the
20             objects in the equivalence set shall be of these types.

21    C590     (R560) If an equivalence-object is of a sequence derived type that is not a numeric sequence or
22             character sequence type, all of the objects in the equivalence set shall be of the same type with
23             the same type parameter values.

24    C591     (R560) If an equivalence-object is of an intrinsic type other than default integer, default real,
25             double precision real, default complex, default logical, or default character, all of the objects in
26             the equivalence set shall be of the same type with the same kind type parameter value.

27    C592     (R561) If an equivalence-object has the PROTECTED attribute, all of the objects in the equiv-
28             alence set shall have the PROTECTED attribute.

29    C593     (R561) The name of an equivalence-object shall not be a name made accessible by use association.

30    C594     (R561) A substring shall not have length zero.

            NOTE 5.40

            The EQUIVALENCE statement allows the equivalencing of sequence structures and the equiv-
            alencing of objects of intrinsic type with nondefault type parameters, but there are strict rules
            regarding the appearance of these objects in an EQUIVALENCE statement.

            A structure that appears in an EQUIVALENCE statement shall be a sequence structure. If a
            sequence structure is not of numeric sequence type or of character sequence type, it shall be
            equivalenced only to objects of the same type with the same type parameter values.

            A structure of a numeric sequence type may be equivalenced to another structure of a numeric
            sequence type, an object of default integer type, default real type, double precision real type,
            default complex type, or default logical type such that components of the structure ultimately
            become associated only with objects of these types.





      94                                   WORKING DRAFT                                                  SEP 2002


      SEP 2002                                    WORKING DRAFT                                 J3/02-007R3



           NOTE 5.40 (cont.)

           A structure of a character sequence type may be equivalenced to an object of default character
           type or another structure of a character sequence type.

           An object of intrinsic type with nondefault kind type parameters may be equivalenced only to
           objects of the same type and kind type parameters.

           Further rules on the interaction of EQUIVALENCE statements and default initialization are given
           in 16.4.3.3.


 1    5.5.1.1       Equivalence association

 2    An EQUIVALENCE statement specifies that the storage sequences (16.4.3.1) of the data objects specified
 3    in an equivalence-set are storage associated. All of the nonzero-sized sequences in the equivalence-set , if
 4    any, have the same first storage unit, and all of the zero-sized sequences in the equivalence-set , if any,
 5    are storage associated with one another and with the first storage unit of any nonzero-sized sequences.
 6    This causes the storage association of the data objects in the equivalence-set and may cause storage
 7    association of other data objects.


 8    5.5.1.2       Equivalence of default character objects

 9    A data object of type default character may be equivalenced only with other objects of type default
10    character. The lengths of the equivalenced objects need not be the same.

11    An EQUIVALENCE statement specifies that the storage sequences of all the default character data
12    objects specified in an equivalence-set are storage associated. All of the nonzero-sized sequences in the
13    equivalence-set , if any, have the same first character storage unit, and all of the zero-sized sequences in
14    the equivalence-set , if any, are storage associated with one another and with the first character storage
15    unit of any nonzero-sized sequences. This causes the storage association of the data objects in the
16    equivalence-set and may cause storage association of other data objects.

           NOTE 5.41

           For example, using the declarations:


           CHARACTER (LEN = 4) :: A, B
           CHARACTER (LEN = 3) :: C (2)
           EQUIVALENCE (A, C (1)), (B, C (2))


           the association of A, B, and C can be illustrated graphically as:


                 1         2      3         4       5       6       7
            |---         --- A    ---     ---|
                                          |---     --- B    ---     ---|
            |---         C(1)     ---|    |---     C(2)     ---|



17    5.5.1.3       Array names and array element designators

18    For a nonzero-sized array, the use of the array name unqualified by a subscript list in an EQUIVALENCE
19    statement has the same effect as using an array element designator that identifies the first element of
20    the array.





      SEP 2002                                           WORKING DRAFT                                        95


      J3/02-007R3                                    WORKING DRAFT                                     SEP 2002



 1    5.5.1.4     Restrictions on EQUIVALENCE statements

 2    An EQUIVALENCE statement shall not specify that the same storage unit is to occur more than once
 3    in a storage sequence.

            NOTE 5.42

            For example:


            REAL, DIMENSION (2) :: A
            REAL :: B
            EQUIVALENCE (A (1), B), (A (2), B) ! Not standard conforming


            is prohibited, because it would specify the same storage unit for A (1) and A (2).


 4    An EQUIVALENCE statement shall not specify that consecutive storage units are to be nonconsecutive.

 5


            NOTE 5.43

            For example, the following is prohibited:


            REAL A (2)
            DOUBLE PRECISION D (2)
            EQUIVALENCE (A (1), D (1)), (A (2), D (2)) ! Not standard conforming



 6    5.5.2       COMMON statement

 7    The COMMON statement specifies blocks of physical storage, called common blocks, that may be
 8    accessed by any of the scoping units in a program. Thus, the COMMON statement provides a global
 9    data facility based on storage association (16.4.3).

10    The common blocks specified by the COMMON statement may be named and are called named com-
11    mon blocks, or may be unnamed and are called blank common.

12    R562       common-stmt                   is    COMMON
13                                                      [ / [ common-block-name ] / ] common-block-object -list
14                                                      [ [ , ] / [ common-block-name ] /
15                                                      common-block-object -list ] ...
16    R563       common-block-object           is    variable-name [ ( explicit-shape-spec-list ) ]
17                                             or proc-pointer-name

18    C595       (R563) Only one appearance of a given variable-name or proc-pointer-name is permitted in all
19               common-block-object -list s within a scoping unit.

20    C596       (R563) A common-block-object shall not be a dummy argument, an allocatable variable, a
21               derived-type object with an ultimate component that is allocatable, an automatic object, a
22               function name, an entry name, a variable with the BIND attribute, or a result name.

23    C597       (R563) If a common-block-object is of a derived type, it shall be a sequence type (4.5.1) with no
24               default initialization.

25    C598       (R563) A variable-name or proc-pointer-name shall not be a name made accessible by use
26               association.

27    In each COMMON statement, the data objects whose names appear in a common block object list
28    following a common block name are declared to be in that common block. If the first common block



      96                                    WORKING DRAFT                                              SEP 2002


      SEP 2002                                WORKING DRAFT                                     J3/02-007R3



 1    name is omitted, all data objects whose names appear in the first common block object list are specified to
 2    be in blank common. Alternatively, the appearance of two slashes with no common block name between
 3    them declares the data objects whose names appear in the common block object list that follows to be
 4    in blank common.

 5    Any common block name or an omitted common block name for blank common may occur more than
 6    once in one or more COMMON statements in a scoping unit. The common block list following each
 7    successive appearance of the same common block name in a scoping unit is treated as a continuation of
 8    the list for that common block name. Similarly, each blank common block object list in a scoping unit
 9    is treated as a continuation of blank common.

10    The form variable-name (explicit-shape-spec-list ) declares variable-name to have the DIMENSION at-
11    tribute and specifies the array properties that apply. If derived-type objects of numeric sequence type
12    (4.5.1) or character sequence type (4.5.1) appear in common, it is as if the individual components were
13    enumerated directly in the common list.

           NOTE 5.44

           Examples of COMMON statements are:


           COMMON /BLOCKA/ A, B, D (10, 30)
           COMMON I, J, K



14    5.5.2.1      Common block storage sequence

15    For each common block in a scoping unit, a common block storage sequence is formed as follows:

16          (1)      A storage sequence is formed consisting of the sequence of storage units in the storage
17                   sequences (16.4.3.1) of all data objects in the common block object lists for the common
18                   block. The order of the storage sequences is the same as the order of the appearance of the
19                   common block object lists in the scoping unit.

20          (2)      The storage sequence formed in (1) is extended to include all storage units of any storage
21                   sequence associated with it by equivalence association. The sequence may be extended only
22                   by adding storage units beyond the last storage unit. Data objects associated with an entity
23                   in a common block are considered to be in that common block.

24    Only COMMON statements and EQUIVALENCE statements appearing in the scoping unit contribute
25    to common block storage sequences formed in that unit.


26    5.5.2.2      Size of a common block

27    The size of a common block is the size of its common block storage sequence, including any extensions
28    of the sequence resulting from equivalence association.


29    5.5.2.3      Common association

30    Within a program, the common block storage sequences of all nonzero-sized common blocks with the
31    same name have the same first storage unit, and the common block storage sequences of all zero-sized
32    common blocks with the same name are storage associated with one another. Within a program, the
33    common block storage sequences of all nonzero-sized blank common blocks have the same first storage
34    unit and the storage sequences of all zero-sized blank common blocks are associated with one another and
35    with the first storage unit of any nonzero-sized blank common blocks. This results in the association of
36    objects in different scoping units. Use association or host association may cause these associated objects
37    to be accessible in the same scoping unit.

38    A nonpointer object of default integer type, default real type, double precision real type, default complex



      SEP 2002                                      WORKING DRAFT                                            97


      J3/02-007R3                                   WORKING DRAFT                                     SEP 2002



 1    type, default logical type, or numeric sequence type shall become associated only with nonpointer objects
 2    of these types.

 3    A nonpointer object of type default character or character sequence type shall become associated only
 4    with nonpointer objects of these types.

 5    A nonpointer object of a derived type that is not a numeric sequence or character sequence type shall
 6    become associated only with nonpointer objects of the same type with the same type parameter values.

 7    A nonpointer object of intrinsic type other than default integer, default real, double precision real, default
 8    complex, default logical, or default character shall become associated only with nonpointer objects of
 9    the same type and type parameters.

10    A data pointer shall become storage associated only with data pointers of the same type and rank.
11    Data pointers that are storage associated shall have deferred the same type parameters; corresponding
12    nondeferred type parameters shall have the same value. A procedure pointer shall become storage
13    associated only with another procedure pointer; either both interfaces shall be explicit or both interfaces
14    shall be implicit. If the interfaces are explicit, the characteristics shall be the same. If the interfaces
15    are implicit, either both shall be subroutines or both shall be functions with the same type and type
16    parameters.

17    An object with the TARGET attribute may become storage associated only with another object that
18    has the TARGET attribute and the same type and type parameters.

            NOTE 5.45

            A common block is permitted to contain sequences of different storage units, provided each scoping
            unit that accesses the common block specifies an identical sequence of storage units for the common
            block. For example, this allows a single common block to contain both numeric and character
            storage units.

            Association in different scoping units between objects of default type, objects of double precision
            real type, and sequence structures is permitted according to the rules for equivalence objects
            (5.5.1).


19    5.5.2.4       Differences between named common and blank common

20    A blank common block has the same properties as a named common block, except for the following:

21           (1)        Execution of a RETURN or END statement may cause data objects in a named common
22                      block to become undefined unless the common block name has been declared in a SAVE
23                      statement, but never causes data objects in blank common to become undefined (16.5.6).

24           (2)        Named common blocks of the same name shall be of the same size in all scoping units of a
25                      program in which they appear, but blank common blocks may be of different sizes.

26           (3)        A data object in a named common block may be initially defined by means of a DATA
27                      statement or type declaration statement in a block data program unit (11.3), but objects in
28                      blank common shall not be initially defined.


29    5.5.2.5       Restrictions on common and equivalence

30    An EQUIVALENCE statement shall not cause the storage sequences of two different common blocks to
31    be associated.

32    Equivalence association shall not cause a common block storage sequence to be extended by adding
33    storage units preceding the first storage unit of the first object specified in a COMMON statement for
34    the common block.




      98                                      WORKING DRAFT                                           SEP 2002


     SEP 2002                              WORKING DRAFT                                      J3/02-007R3



          NOTE 5.46

          For example, the following is not permitted:


          COMMON /X/ A
          REAL B (2)
          EQUIVALENCE (A, B (2))          ! Not standard conforming



1    Equivalence association shall not cause a derived-type object with default initialization to be associated
2    with an object in a common block.





     SEP 2002                                     WORKING DRAFT                                            99


J3/02-007R3       WORKING DRAFT    SEP 2002





100            WORKING DRAFT       SEP 2002


      SEP 2002                                      WORKING DRAFT                              J3/02-007R3





 1    Section 6: Use of data objects

 2    The appearance of a data object designator in a context that requires its value is termed a reference. A
 3    reference is permitted only if the data object is defined. A reference to a pointer is permitted only if the
 4    pointer is associated with a target object that is defined. A data object becomes defined with a value
 5    when events described in 16.5.5 occur.

 6    R601    variable                              is    designator

 7    C601    (R601) designator shall not be a constant or a subobject of a constant.

 8    R602    variable-name                         is    name

 9    C602    (R602) A variable-name shall be the name of a variable.

10    R603    designator                            is    object-name
11                                                  or array-element
12                                                  or array-section
13                                                  or structure-component
14                                                  or substring
15    R604    logical-variable                      is    variable

16    C603    (R604) logical-variable shall be of type logical.

17    R605    default-logical-variable              is    variable

18    C604    (R605) default-logical-variable shall be of type default logical.

19    R606    char-variable                         is    variable

20    C605    (R606) char-variable shall be of type character.

21    R607    default-char-variable                 is    variable

22    C606    (R607) default-char-variable shall be of type default character.

23    R608    int-variable                          is    variable

24    C607    (R608) int-variable shall be of type integer.

           NOTE 6.1

           For example, given the declarations:

           CHARACTER (10)              A, B (10)
           TYPE (PERSON)          P       ! See Note 4.20

           then A, B, B (1), B (1:5), P % AGE, and A (1:1) are all variables.


25    A constant (3.2.2) is a literal constant or a named constant. A literal constant is a scalar denoted by a
26    syntactic form, which indicates its type, type parameters, and value. A named constant is a constant
27    that has a name; the name has the PARAMETER attribute (5.1.2.10, 5.2.9). A reference to a constant
28    is always permitted; redefinition of a constant is never permitted.





      SEP 2002                                             WORKING DRAFT                                    101


      J3/02-007R3                                  WORKING DRAFT                                     SEP 2002


 1    6.1       Scalars

 2    A scalar (2.4.4) is a data entity that can be represented by a single value of the type and that is not an
 3    array (6.2). Its value, if defined, is a single element from the set of values that characterize its type.

             NOTE 6.2

             A scalar object of derived type has a single value that consists of the values of its components
             (4.5.6).


 4    A scalar has rank zero.


 5    6.1.1      Substrings

 6    A substring is a contiguous portion of a character string (4.4.4). The following rules define the forms
 7    of a substring:

 8    R609      substring                    is    parent-string ( substring-range )
 9    R610      parent-string                is    scalar-variable-name
10                                           or array-element
11                                           or scalar-structure-component
12                                           or scalar-constant
13    R611      substring-range              is    [ scalar-int-expr ] : [ scalar-int-expr ]

14    C608      (R610) parent-string shall be of type character.

15    The first scalar-int-expr in substring-range is called the starting point and the second one is called
16    the ending point. The length of a substring is the number of characters in the substring and is
17    MAX (l-f +1, 0), where f and l are the values of the starting and ending point expressions, respectively.

18    Let the characters in the parent string be numbered 1, 2, 3, ..., n, where n is the length of the parent
19    string. Then the characters in the substring are those from the parent string from the starting point and
20    proceeding in sequence up to and including the ending point. Both the starting point and the ending
21    point shall be within the range 1, 2, ..., n unless the starting point exceeds the ending point, in which
22    case the substring has length zero. If the starting point is not specified, the default value is 1. If the
23    ending point is not specified, the default value is n.

24    If the parent is a variable, the substring is also a variable.

             NOTE 6.3

             Examples of character substrings are:


                   B(1)(1:5)                array element as parent string
                   P%NAME(1:1)              structure component as parent string
                   ID(4:9)                  scalar variable name as parent string
                   '0123456789'(N:N)        character constant as parent string



25    6.1.2      Structure components

26    A structure component is part of an object of derived type; it may be referenced by an object
27    designator. A structure component may be a scalar or an array.

28    R612      data-ref                     is    part-ref [ % part-ref ] ...
29    R613      part-ref                     is    part-name [ ( section-subscript -list ) ]





      102                                  WORKING DRAFT                                             SEP 2002


      SEP 2002                                WORKING DRAFT                                      J3/02-007R3



 1    C609    (R612) In a data-ref , each part-name except the rightmost shall be of derived type.

 2    C610    (R612) In a data-ref , each part-name except the leftmost shall be the name of a component of
 3            the derived-type definition of the declared type of the preceding part-name.

 4    C611    (R612) The leftmost part-name shall be the name of a data object.

 5    C612    (R613) In a part-ref containing a section-subscript -list, the number of section-subscript s shall
 6            equal the rank of part-name.

 7    The rank of a part-ref of the form part-name is the rank of part-name. The rank of a part-ref that has
 8    a section subscript list is the number of subscript triplets and vector subscripts in the list.

 9    C613    (R612) In a data-ref , there shall not be more than one part-ref with nonzero rank. A part-name
10            to the right of a part-ref with nonzero rank shall not have the ALLOCATABLE or POINTER
11            attribute.

12    The rank of a data-ref is the rank of the part-ref with nonzero rank, if any; otherwise, the rank is zero.
13    The base object of a data-ref is the data object whose name is the leftmost part name.

14    The type and type parameters, if any, of a data-ref are those of the rightmost part name.

15    A data-ref with more than one part-ref is a subobject of its base object if none of the part-names,
16    except for possibly the rightmost, are pointers. If the rightmost part-name is the only pointer, then the
17    data-ref is a subobject of its base object in contexts that pertain to its pointer association status but
18    not in any other contexts.

           NOTE 6.4

           If X is an object of derived type with a pointer component P, then the pointer X%P is a subobject
           of X when considered as a pointer � that is in contexts where it is not dereferenced.

           However the target of X%P is not a subobject of X. Thus, in contexts where X%P is dereferenced
           to refer to the target, it is not a subobject of X.


19    R614    structure-component             is    data-ref

20    C614    (R614) In a structure-component , there shall be more than one part-ref and the rightmost
21            part-ref shall be of the form part-name.

22    A structure component shall be neither referenced nor defined before the declaration of the base object.
23    A structure component is a pointer only if the rightmost part name is defined to have the POINTER
24    attribute.

           NOTE 6.5

           Examples of structure components are:


                    SCALAR_PARENT%SCALAR_FIELD                  scalar component of scalar parent
                    ARRAY_PARENT(J)%SCALAR_FIELD                component of array element parent
                    ARRAY_PARENT(1:N)%SCALAR_FIELD              component of array section parent


           For a more elaborate example see C.3.1.


           NOTE 6.6

           The syntax rules are structured such that a data-ref that ends in a component name without a





      SEP 2002                                       WORKING DRAFT                                         103


      J3/02-007R3                                   WORKING DRAFT                                    SEP 2002



             NOTE 6.6 (cont.)

             following subscript list is a structure component, even when other component names in the data-
             ref are followed by a subscript list. A data-ref that ends in a component name with a following
             subscript list is either an array element or an array section. A data-ref of nonzero rank that ends
             with a substring-range is an array section. A data-ref of zero rank that ends with a substring-range
             is a substring.


 1    A subcomponent of an object of derived type is a component of that object or of a subobject of that
 2    object.


 3    6.1.3      Type parameter inquiry

 4    A type parameter inquiry is used to inquire about a type parameter of a data object. It applies to
 5    both intrinsic and derived types.

 6    R615       type-param-inquiry           is    designator % type-param-name

 7    C615       (R615) The type-param-name shall be the name of a type parameter of the declared type of the
 8               object designated by the designator .

 9    A deferred type parameter of a pointer that is not associated or of an unallocated allocatable variable
10    shall not be inquired about.

             NOTE 6.7

             A type-param-inquiry has a syntax like that of a structure component reference, but it does not
             have the same semantics. It is not a variable and thus can never be assigned to. It may be used
             only as a primary in an expression. It is scalar even if designator is an array.

             The intrinsic type parameters can also be inquired about by using the intrinsic functions KIND
             and LEN.


             NOTE 6.8

             The following are examples of type parameter inquiries:


                   a%kind         !-- A is real.      Same value as KIND(a).
                   s%len          !-- S is character.       Same value as LEN(s).
                   b(10)%kind     !-- Inquiry about an array element.
                   p%dim          !-- P is of the derived type general_point.


             See Note 4.21 for the definition of the general point type used in the last example above.



11    6.2        Arrays

12    An array is a set of scalar data, all of the same type and type parameters, whose individual elements
13    are arranged in a rectangular pattern. The scalar data that make up an array are the array elements.

14    No order of reference to the elements of an array is indicated by the appearance of the array designator,
15    except where array element ordering (6.2.2.2) is specified.


16    6.2.1      Whole arrays

17    A whole array is a named array, which may be either a named constant (5.1.2.10, 5.2.9) or a variable;
18    no subscript list is appended to the name.



      104                                   WORKING DRAFT                                            SEP 2002


      SEP 2002                                WORKING DRAFT                                       J3/02-007R3



 1    The appearance of a whole array variable in an executable construct specifies all the elements of the
 2    array (2.4.5). An assumed-size array is permitted to appear as a whole array in an executable construct
 3    only as an actual argument in a procedure reference that does not require the shape.

 4    The appearance of a whole array name in a nonexecutable statement specifies the entire array except
 5    for the appearance of a whole array name in an equivalence set (5.5.1.3).


 6    6.2.2      Array elements and array sections

 7    R616      array-element                 is    data-ref

 8    C616      (R616) In an array-element , every part-ref shall have rank zero and the last part-ref shall
 9              contain a subscript -list.

10    R617      array-section                 is    data-ref [ ( substring-range ) ]

11    C617      (R617) In an array-section, exactly one part-ref shall have nonzero rank, and either the final
12              part-ref shall have a section-subscript -list with nonzero rank or another part-ref shall have
13              nonzero rank.

14    C618      (R617) In an array-section with a substring-range, the rightmost part-name shall be of type
15              character.

16    R618      subscript                     is    scalar-int-expr
17    R619      section-subscript             is    subscript
18                                            or subscript-triplet
19                                            or vector-subscript
20    R620      subscript-triplet             is    [ subscript ] : [ subscript ] [ : stride ]
21    R621      stride                        is    scalar-int-expr
22    R622      vector-subscript              is    int-expr

23    C619      (R622) A vector-subscript shall be an integer array expression of rank one.

24    C620      (R620) The second subscript shall not be omitted from a subscript-triplet in the last dimension
25              of an assumed-size array.

26    An array element is a scalar. An array section is an array. If a substring-range is present in an array-
27    section, each element is the designated substring of the corresponding element of the array section.

          NOTE 6.9

          For example, with the declarations:


          REAL A (10, 10)
          CHARACTER (LEN = 10) B (5, 5, 5)


          A (1, 2) is an array element, A (1:N:2, M) is a rank-one array section, and B (:, :, :) (2:3) is an
          array of shape (5, 5, 5) whose elements are substrings of length 2 of the corresponding elements of
          B.


28    An array element or an array section never has the POINTER attribute.

          NOTE 6.10

          Examples of array elements and array sections are:





      SEP 2002                                        WORKING DRAFT                                       105


      J3/02-007R3                                     WORKING DRAFT                                      SEP 2002



             NOTE 6.10 (cont.)

                  ARRAY_A(1:N:2)%ARRAY_B(I, J)%STRING(K)(:)                array section
                  SCALAR_PARENT%ARRAY_FIELD(J)                             array element
                  SCALAR_PARENT%ARRAY_FIELD(1:N)                           array section
                  SCALAR_PARENT%ARRAY_FIELD(1:N)%SCALAR_FIELD              array section



 1    6.2.2.1    Array elements

 2    The value of a subscript in an array element shall be within the bounds for that dimension.


 3    6.2.2.2    Array element order

 4    The elements of an array form a sequence known as the array element order. The position of an array
 5    element in this sequence is determined by the subscript order value of the subscript list designating the
 6    element. The subscript order value is computed from the formulas in Table 6.1.


                                           Table 6.1: Subscript order value
                     Rank     Subscript bounds          Subscript list     Subscript order value

                     1        j1:k1                     s1                 1 + (s1 - j1)
                                                                           1 + (s
                     2        j                                                        1 - j1)
                               1:k1,j2:k2               s1, s2              + (s2 - j2) � d1
                                                                           1 + (s1 - j1)
                     3        j1:k1, j2:k2, j3:k3       s1, s2, s3          + (s2 - j2) � d1
                                                                           + (s3 - j3) � d2 � d1
                     �             �                      �                    �
                     �             �                      �                    �
                     �             �                      �                    �
                                                                           1 + (s1 - j1)
                                                                            + (s2 - j2) � d1
                                                                           + (s
                     7        j                                                     3 - j3) � d2 � d1
                               1:k1, . . . , j7:k7      s1, . . . , s7      + . . .
                                                                            + (s7 - j7) � d6
                                                                             � d5 � . . . � d1
                     Notes for Table 6.1:
                             1) di = max (ki - ji + 1, 0) is the size of the ith dimension.
                             2) If the size of the array is nonzero, ji  si  ki for all
                             i = 1, 2, ..., 7.



 7    6.2.2.3    Array sections

 8    An array section is an array subobject optionally followed by a substring range.

 9    In an array-section having a section-subscript -list, each subscript-triplet and vector-subscript in the
10    section subscript list indicates a sequence of subscripts, which may be empty. Each subscript in such a
11    sequence shall be within the bounds for its dimension unless the sequence is empty. The array section is
12    the set of elements from the array determined by all possible subscript lists obtainable from the single
13    subscripts or sequences of subscripts specified by each section subscript.

14    In an array-section with no section-subscript -list, the rank and shape of the array is the rank and shape
15    of the part-ref with nonzero rank; otherwise, the rank of the array section is the number of subscript
16    triplets and vector subscripts in the section subscript list. The shape is the rank-one array whose ith
17    element is the number of integer values in the sequence indicated by the ith subscript triplet or vector
18    subscript. If any of these sequences is empty, the array section has size zero. The subscript order of the



      106                                     WORKING DRAFT                                              SEP 2002


      SEP 2002                              WORKING DRAFT                                       J3/02-007R3



 1    elements of an array section is that of the array data object that the array section represents.


 2    6.2.2.3.1      Subscript triplet

 3    A subscript triplet designates a regular sequence of subscripts consisting of zero or more subscript values.
 4    The third expression in the subscript triplet is the increment between the subscript values and is called
 5    the stride. The subscripts and stride of a subscript triplet are optional. An omitted first subscript in a
 6    subscript triplet is equivalent to a subscript whose value is the lower bound for the array and an omitted
 7    second subscript is equivalent to the upper bound. An omitted stride is equivalent to a stride of 1.

 8    The stride shall not be zero.

 9    When the stride is positive, the subscripts specified by a triplet form a regularly spaced sequence of
10    integers beginning with the first subscript and proceeding in increments of the stride to the largest such
11    integer not greater than the second subscript; the sequence is empty if the first subscript is greater than
12    the second.

           NOTE 6.11

           For example, suppose an array is declared as A (5, 4, 3). The section A (3 : 5, 2, 1 : 2) is the array
           of shape (3, 2):


           A (3, 2, 1)           A (3, 2, 2)
           A (4, 2, 1)           A (4, 2, 2)
           A (5, 2, 1)           A (5, 2, 2)



13    When the stride is negative, the sequence begins with the first subscript and proceeds in increments of
14    the stride down to the smallest such integer equal to or greater than the second subscript; the sequence
15    is empty if the second subscript is greater than the first.

           NOTE 6.12

           For example, if an array is declared B (10), the section B (9 : 1 : �2) is the array of shape (5)
           whose elements are B (9), B (7), B (5), B (3), and B (1), in that order.


           NOTE 6.13

           A subscript in a subscript triplet need not be within the declared bounds for that dimension if all
           values used in selecting the array elements are within the declared bounds.

           For example, if an array is declared as B (10), the array section B (3 : 11 : 7) is the array of shape
           (2) consisting of the elements B (3) and B (10), in that order.


16    6.2.2.3.2      Vector subscript

17    A vector subscript designates a sequence of subscripts corresponding to the values of the elements
18    of the expression. Each element of the expression shall be defined. A many-one array section is an
19    array section with a vector subscript having two or more elements with the same value. A many-one
20    array section shall appear neither on the left of the equals in an assignment statement nor as an input
21    item in a READ statement.

22    An array section with a vector subscript shall not be argument associated with a dummy array that
23    is defined or redefined. An array section with a vector subscript shall not be the target in a pointer
24    assignment statement. An array section with a vector subscript shall not be an internal file.





      SEP 2002                                     WORKING DRAFT                                             107


      J3/02-007R3                                     WORKING DRAFT                                       SEP 2002



             NOTE 6.14

             For example, suppose Z is a two-dimensional array of shape (5, 7) and U and V are one-dimensional
             arrays of shape (3) and (4), respectively. Assume the values of U and V are:


             U = (/ 1, 3, 2 /)
             V = (/ 2, 1, 1, 3 /)


             Then Z (3, V) consists of elements from the third row of Z in the order:


             Z (3, 2)         Z (3, 1)    Z (3, 1)       Z (3, 3)


             and Z (U, 2) consists of the column elements:


             Z (1, 2)         Z (3, 2)    Z (2, 2)


             and Z (U, V) consists of the elements:


             Z (1, 2)         Z (1, 1)    Z (1, 1)       Z (1, 3)
             Z (3, 2)         Z (3, 1)    Z (3, 1)       Z (3, 3)
             Z (2, 2)         Z (2, 1)    Z (2, 1)       Z (2, 3)


             Because Z (3, V) and Z (U, V) contain duplicate elements from Z, the sections Z (3, V) and
             Z (U, V) shall not be redefined as sections.



 1    6.3       Dynamic association

 2    Dynamic control over the allocation, association, and deallocation of pointer targets is provided by
 3    the ALLOCATE, NULLIFY, and DEALLOCATE statements and pointer assignment. ALLOCATE
 4    (6.3.1) creates targets for pointers; pointer assignment (7.4.2) associates pointers with existing targets;
 5    NULLIFY (6.3.2) disassociates pointers from targets, and DEALLOCATE (6.3.3) deallocates targets.
 6    Dynamic association applies to scalars and arrays of any type.

 7    The ALLOCATE and DEALLOCATE statements also are used to create and deallocate variables with
 8    the ALLOCATABLE attribute.

             NOTE 6.15

             Detailed remarks regarding pointers and dynamic association are in C.3.3.


 9    6.3.1      ALLOCATE statement

10    The ALLOCATE statement dynamically creates pointer targets and allocatable variables.

11    R623      allocate-stmt                 is      ALLOCATE ( [ type-spec :: ] allocation-list
12                                                       [, alloc-opt -list ] )
13    R624      alloc-opt                     is      STAT = stat-variable
14                                            or ERRMSG = errmsg-variable
15                                            or SOURCE = source-variable
16    R625      stat-variable                 is      scalar-int-variable
17    R626      errmsg-variable               is      scalar-default-char-variable
18    R627      allocation                    is      allocate-object [ ( allocate-shape-spec-list ) ]
19    R628      allocate-object               is      variable-name
20                                            or structure-component




      108                                    WORKING DRAFT                                                SEP 2002


      SEP 2002                               WORKING DRAFT                                       J3/02-007R3



 1    R629    allocate-shape-spec            is    [ allocate-lower-bound : ] allocate-upper-bound
 2    R630    allocate-lower-bound           is    scalar-int-expr
 3    R631    allocate-upper-bound           is    scalar-int-expr
 4    R632    source-variable                is    variable

 5    C621    (R628) Each allocate-object shall be a nonprocedure pointer or an allocatable variable.

 6    C622    (R623) If any allocate-object in the statement has a deferred type parameter, either type-spec or
 7            SOURCE= shall appear.

 8    C623    (R623) If a type-spec appears, it shall specify a type with which each allocate-object is type
 9            compatible.

10    C624    (R623) If any allocate-object is unlimited polymorphic, either type-spec or SOURCE= shall
11            appear.

12    C625    (R623) A type-param-value in a type-spec shall be an asterisk if and only if each allocate-object
13            is a dummy argument for which the corresponding type parameter is assumed.

14    C626    (R623) If a type-spec appears, the kind type parameter values of each allocate-object shall be
15            the same as the corresponding type parameter values of the type-spec.

16    C627    (R627) An allocate-shape-spec-list shall appear if and only if the allocate-object is an array.

17    C628    (R627) The number of allocate-shape-specs in an allocate-shape-spec-list shall be the same as
18            the rank of the allocate-object .

19    C629    (R624) No alloc-opt shall appear more than once in a given alloc-opt -list.

20    C630    (R623) If SOURCE= appears, type-spec shall not appear and allocation-list shall contain only
21            one allocate-object , which shall be type compatible (5.1.1.8) with source-variable.

22    C631    (R623) The source-variable shall be a scalar or have the same rank as allocate-object .

23    C632    (R623) Corresponding kind type parameters of allocate-object and source-variable shall have the
24            same values.

25    An allocate-object or a bound or type parameter of an allocate-object shall not depend on stat-variable,
26    errmsg-variable, or on the value, bounds, allocation status, or association status of any allocate-object
27    in the same ALLOCATE statement.

28    Neither stat-variable, source-variable, nor errmsg-variable shall be allocated within the ALLOCATE
29    statement in which it appears; nor shall they depend on the value, bounds, allocation status, or associ-
30    ation status of any allocate-object in the same ALLOCATE statement.

31    The optional type-spec specifies the dynamic type and type parameters of the objects to be allocated. If
32    a type-spec is specified, allocation of a polymorphic object allocates an object with the specified dynamic
33    type; if a source-variable is specified, the allocation allocates an object whose dynamic type and type
34    parameters are the same as those of the source-variable; otherwise it allocates an object with a dynamic
35    type the same as its declared type.

36    When an ALLOCATE statement having a type-spec is executed, any type-param-values in the type-spec
37    specify the type parameters. If the value specified for a type parameter differs from a corresponding
38    nondeferred value specified in the declaration of any of the allocate-object s then an error condition occurs.

39    If a type-param-value in a type-spec in an ALLOCATE statement is an asterisk, it denotes the current
40    value of that assumed type parameter. If it is an expression, subsequent redefinition or undefinition of
41    any entity in the expression does not affect the type parameter value.




      SEP 2002                                      WORKING DRAFT                                             109


      J3/02-007R3                                   WORKING DRAFT                                       SEP 2002



             NOTE 6.16

             An example of an ALLOCATE statement is:


             ALLOCATE (X (N), B (-3 : M, 0:9), STAT = IERR_ALLOC)



 1    When an ALLOCATE statement is executed for an array, the values of the lower bound and upper
 2    bound expressions determine the bounds of the array. Subsequent redefinition or undefinition of any
 3    entities in the bound expressions do not affect the array bounds. If the lower bound is omitted, the
 4    default value is 1. If the upper bound is less than the lower bound, the extent in that dimension is zero
 5    and the array has zero size.

             NOTE 6.17

             An allocate-object may be of type character with zero character length.


 6    If SOURCE= appears, source-variable shall be conformable (2.4.5) with allocation. If the value of a
 7    nondeferred nonkind type parameter of allocate-object is different from the value of the corresponding
 8    type parameter of source-variable, an error condition occurs. If the allocation is successful, source-
 9    variable is then assigned to allocate-object by intrinsic assignment for objects whose declared type is the
10    dynamic type of source-variable.

             NOTE 6.18

             An example of an ALLOCATE statement in which the value and dynamic type are determined by
             reference to another object is:


             CLASS(*), ALLOCATABLE :: NEW
             CLASS(*), POINTER :: OLD
             ! ...
             ALLOCATE (NEW, SOURCE=OLD)           ! Allocate NEW with the value and dynamic type of OLD


             A more extensive example is given in C.3.2.


11    If the STAT= specifier appears, successful execution of the ALLOCATE statement causes the stat-
12    variable to become defined with a value of zero. If an error condition occurs during the execution
13    of the ALLOCATE statement, the stat-variable becomes defined with a processor-dependent positive
14    integer value and each allocate-object will have a processor-dependent status; each allocate-object that
15    was successfully allocated shall have an allocation status of allocated or a pointer association status of
16    associated; each allocate-object that was not successfully allocated shall retain its previous allocation
17    status or pointer association status.

18    If an error condition occurs during execution of an ALLOCATE statement that does not contain the
19    STAT= specifier, execution of the program is terminated.

20    The ERRMSG= specifier is described in 6.3.1.3.


21    6.3.1.1        Allocation of allocatable variables

22    The allocation status of an allocatable entity is one of the following at any time during the execution of
23    a program:

24            (1)      An allocatable variable has a status of allocated if it has been allocated by an ALLOCATE
25                     statement and has not been subsequently deallocated (6.3.3). An allocatable variable with
26                     this status may be referenced, defined, or deallocated; allocating it causes an error condition
27                     in the ALLOCATE statement. The intrinsic function ALLOCATED (13.7.9) returns true




      110                                       WORKING DRAFT                                           SEP 2002


      SEP 2002                                 WORKING DRAFT                                     J3/02-007R3



 1                     for such a variable.

 2            (2)      An allocatable variable has a status of unallocated if it is not allocated. An allocatable
 3                     variable with this status shall not be referenced or defined. It shall not be supplied as an
 4                     actual argument except to certain intrinsic inquiry functions. It may be allocated with the
 5                     ALLOCATE statement. Deallocating it causes an error condition in the DEALLOCATE
 6                     statement. The intrinsic function ALLOCATED (13.7.9) returns false for such a variable.

 7    At the beginning of execution of a program, allocatable variables are unallocated.

 8    A saved allocatable object has an initial status of unallocated. If the object is allocated, its status
 9    changes to allocated. The status remains allocated until the object is deallocated.

10    When the allocation status of an allocatable variable changes, the allocation status of any associated
11    allocatable variable changes accordingly. Allocation of an allocatable variable establishes values for the
12    deferred type parameters of all associated allocatable variables.

13    An unsaved allocatable object that is a local variable of a procedure has a status of unallocated at the
14    beginning of each invocation of the procedure. The status may change during execution of the procedure.
15    An unsaved allocatable object that is a local variable of a module or a subobject thereof has an initial
16    status of unallocated. The status may change during execution of the program.

17    When an object of derived type is created by an ALLOCATE statement, any allocatable ultimate
18    components have an allocation status of unallocated.


19    6.3.1.2        Allocation of pointer targets

20    Allocation of a pointer creates an object that implicitly has the TARGET attribute. Following successful
21    execution of an ALLOCATE statement for a pointer, the pointer is associated with the target and may
22    be used to reference or define the target. Additional pointers may become associated with the pointer
23    target or a part of the pointer target by pointer assignment. It is not an error to allocate a pointer
24    that is already associated with a target. In this case, a new pointer target is created as required by the
25    attributes of the pointer and any array bounds, type, and type parameters specified by the ALLOCATE
26    statement. The pointer is then associated with this new target. Any previous association of the pointer
27    with a target is broken. If the previous target had been created by allocation, it becomes inaccessible
28    unless other pointers are associated with it. The ASSOCIATED intrinsic function (13.7.13) may be used
29    to determine whether a pointer that does not have undefined association status is associated.

30    At the beginning of execution of a function whose result is a pointer, the association status of the result
31    pointer is undefined. Before such a function returns, it shall either associate a target with this pointer
32    or cause the association status of this pointer to become defined as disassociated.


33    6.3.1.3        ERRMSG= specifier

34    If an error condition occurs during execution of an ALLOCATE or DEALLOCATE statement, the
35    processor shall assign an explanatory message to errmsg-variable. If no such condition occurs, the
36    processor shall not change the value of errmsg-variable.


37    6.3.2          NULLIFY statement

38    The NULLIFY statement causes pointers to be disassociated.

39    R633       nullify-stmt                  is     NULLIFY ( pointer-object -list )
40    R634       pointer-object                is     variable-name
41                                             or structure-component
42                                             or proc-pointer-name





      SEP 2002                                         WORKING DRAFT                                         111


      J3/02-007R3                                  WORKING DRAFT                                      SEP 2002



 1    C633      (R634) Each pointer-object shall have the POINTER attribute.

 2    A pointer-object shall not depend on the value, bounds, or association status of another pointer-object
 3    in the same NULLIFY statement.

             NOTE 6.19

             When a NULLIFY statement is applied to a polymorphic pointer (5.1.1.8), its dynamic type
             becomes the declared type.


 4    6.3.3      DEALLOCATE statement

 5    The DEALLOCATE statement causes allocatable variables to be deallocated; it causes pointer tar-
 6    gets to be deallocated and the pointers to be disassociated.

 7    R635      deallocate-stmt              is    DEALLOCATE ( allocate-object -list [ , dealloc-opt -list ] )

 8    C634      (R635) Each allocate-object shall be a nonprocedure pointer or an allocatable variable.

 9    R636      dealloc-opt                  is    STAT = stat-variable
10                                           or ERRMSG = errmsg-variable

11    C635      (R636) No dealloc-opt shall appear more than once in a given dealloc-opt -list.

12    An allocate-object shall not depend on the value, bounds, allocation status, or association status of
13    another allocate-object in the same DEALLOCATE statement; it also shall not depend on the value of
14    the stat-variable or errmsg-variable in the same DEALLOCATE statement.

15    Neither stat-variable nor errmsg-variable shall be deallocated within the same DEALLOCATE state-
16    ment; they also shall not depend on the value, bounds, allocation status, or association status of any
17    allocate-object in the same DEALLOCATE statement.

18    If the STAT= specifier appears, successful execution of the DEALLOCATE statement causes the stat-
19    variable to become defined with a value of zero. If an error condition occurs during the execution of
20    the DEALLOCATE statement, the stat-variable becomes defined with a processor-dependent positive
21    integer value and each allocate-object that was successfully deallocated shall have an allocation status of
22    unallocated or a pointer association status of disassociated. Each allocate-object that was not successfully
23    deallocated shall retain its previous allocation status or pointer association status.

             NOTE 6.20

             The status of objects that were not successfully deallocated can be individually checked with the
             ALLOCATED or ASSOCIATED intrinsic functions.


24    If an error condition occurs during execution of a DEALLOCATE statement that does not contain the
25    STAT= specifier, execution of the program is terminated.

26    The ERRMSG= specifier is described in 6.3.1.3.

             NOTE 6.21

             An example of a DEALLOCATE statement is:


             DEALLOCATE (X, B)





      112                                  WORKING DRAFT                                              SEP 2002


      SEP 2002                              WORKING DRAFT                                        J3/02-007R3



 1    6.3.3.1    Deallocation of allocatable variables

 2    Deallocating an unallocated allocatable variable causes an error condition in the DEALLOCATE state-
 3    ment. Deallocating an allocatable variable with the TARGET attribute causes the pointer association
 4    status of any pointer associated with it to become undefined.

 5    When the execution of a procedure is terminated by execution of a RETURN or END statement, an
 6    allocatable variable that is a named local variable of the procedure retains its allocation and definition
 7    status if it has the SAVE attribute or is a function result variable or a subobject thereof; otherwise, it
 8    is deallocated.

           NOTE 6.22

           The ALLOCATED intrinsic function may be used to determine whether a variable is allocated or
           unallocated.


 9    If an unsaved allocatable object is a local variable of a module, and it is allocated when execution
10    of a RETURN or END statement results in no active scoping unit having access to the module, it is
11    processor-dependent whether the object retains its allocation status or is deallocated.

           NOTE 6.23

           The following example illustrates the effects of SAVE on allocation status.


           MODULE MOD1
           TYPE INITIALIZED_TYPE
                 INTEGER :: I = 1     ! Default initialization
           END TYPE INITIALIZED_TYPE
           SAVE :: SAVED1, SAVED2
           INTEGER :: SAVED1, UNSAVED1
           TYPE(INITIALIZED_TYPE) :: SAVED2, UNSAVED2
           ALLOCATABLE :: SAVED1(:), SAVED2(:), UNSAVED1(:), UNSAVED2(:)
           END MODULE MOD1
           PROGRAM MAIN
           CALL SUB1         ! The values returned by the ALLOCATED intrinsic calls
                             ! in the PRINT statement are:
                             ! .FALSE., .FALSE., .FALSE., and .FALSE.
                             ! Module MOD1 is used, and its variables are allocated.
                             ! After return from the subroutine, whether the variables
                             ! which were not specified with the SAVE attribute
                             ! retain their allocation status is processor dependent.
           CALL SUB1         ! The values returned by the first two ALLOCATED intrinsic
                             ! calls in the PRINT statement are:
                             ! .TRUE., .TRUE.
                             ! The values returned by the second two ALLOCATED
                             ! intrinsic calls in the PRINT statement are
                             ! processor dependent and each could be either
                             ! .TRUE. or .FALSE.
           CONTAINS
                 SUBROUTINE SUB1
                 USE MOD1       ! Brings in saved and unsaved variables.
                 PRINT *, ALLOCATED(SAVED1), ALLOCATED(SAVED2), &
                             ALLOCATED(UNSAVED1), ALLOCATED(UNSAVED2)
                 IF (.NOT. ALLOCATED(SAVED1)) ALLOCATE(SAVED1(10))





      SEP 2002                                      WORKING DRAFT                                          113


      J3/02-007R3                                WORKING DRAFT                                     SEP 2002



             NOTE 6.23 (cont.)

                  IF (.NOT. ALLOCATED(SAVED2)) ALLOCATE(SAVED2(10))
                  IF (.NOT. ALLOCATED(UNSAVED1)) ALLOCATE(UNSAVED1(10))
                  IF (.NOT. ALLOCATED(UNSAVED2)) ALLOCATE(UNSAVED2(10))
                  END SUBROUTINE SUB1
             END PROGRAM MAIN



 1    If an executable construct references a function whose result is either allocatable or a structure with
 2    a subobject that is allocatable, and the function reference is executed, an allocatable result and any
 3    subobject that is an allocated allocatable entity in the result returned by the function is deallocated
 4    after execution of the innermost executable construct containing the reference.

 5    If a specification expression in a scoping unit references a function whose result is either allocatable or
 6    a structure with a subobject that is allocatable, and the function reference is executed, an allocatable
 7    result and any subobject that is an allocated allocatable entity in the result returned by the function is
 8    deallocated before execution of the first executable statement in the scoping unit.

 9    When a procedure is invoked, an allocated allocatable object that is an actual argument associated with
10    an INTENT(OUT) allocatable dummy argument is deallocated; an allocated allocatable object that is
11    a subobject of an actual argument associated with an INTENT(OUT) dummy argument is deallocated.

12    When an intrinsic assignment statement (7.4.1.3) is executed, any allocated allocatable subobject of the
13    variable is deallocated before the assignment takes place.

14    When a variable of derived type is deallocated, any allocated allocatable subobject is deallocated.

15    If an allocatable component is a subobject of a finalizable object, that object is finalized before the
16    component is automatically deallocated.

17    The effect of automatic deallocation is the same as that of a DEALLOCATE statement without a
18    dealloc-opt -list.

             NOTE 6.24

             In the following example:


             SUBROUTINE PROCESS
                 REAL, ALLOCATABLE :: TEMP(:)
                 REAL, ALLOCATABLE, SAVE :: X(:)
                 ...
             END SUBROUTINE PROCESS


             on return from subroutine PROCESS, the allocation status of X is preserved because X has the
             SAVE attribute. TEMP does not have the SAVE attribute, so it will be deallocated. On the next
             invocation of PROCESS, TEMP will have an allocation status of unallocated.


19    6.3.3.2     Deallocation of pointer targets

20    If a pointer appears in a DEALLOCATE statement, its association status shall be defined. Deallocating
21    a pointer that is disassociated or whose target was not created by an ALLOCATE statement causes an
22    error condition in the DEALLOCATE statement. If a pointer is associated with an allocatable entity,
23    the pointer shall not be deallocated.

24    If a pointer appears in a DEALLOCATE statement, it shall be associated with the whole of an object
25    or subobject that was created by allocation. Deallocating a pointer target causes the pointer association




      114                                 WORKING DRAFT                                            SEP 2002


      SEP 2002                              WORKING DRAFT                                     J3/02-007R3



 1    status of any other pointer that is associated with the target or a portion of the target to become
 2    undefined.

 3    When the execution of a procedure is terminated by execution of a RETURN or END statement, the
 4    pointer association status of a pointer declared or accessed in the subprogram that defines the procedure
 5    becomes undefined unless it is one of the following:

 6          (1)    A pointer with the SAVE attribute,

 7          (2)    A pointer in blank common,

 8          (3)    A pointer in a named common block that appears in at least one other scoping unit that is
 9                 in execution,

10          (4)    A pointer declared in the scoping unit of a module if the module also is accessed by another
11                 scoping unit that is in execution,

12          (5)    A pointer accessed by host association, or

13          (6)    A pointer that is the return value of a function declared to have the POINTER attribute.

14    When a pointer target becomes undefined by execution of a RETURN or END statement, the pointer
15    association status (16.4.2.1) becomes undefined.





      SEP 2002                                    WORKING DRAFT                                           115


J3/02-007R3       WORKING DRAFT    SEP 2002





116            WORKING DRAFT       SEP 2002


      SEP 2002                               WORKING DRAFT                                       J3/02-007R3





 1    Section 7: Expressions and assignment

 2    This section describes the formation, interpretation, and evaluation rules for expressions, intrinsic and
 3    defined assignment, pointer assignment, masked array assignment (WHERE), and FORALL.


 4    7.1        Expressions

 5    An expression represents either a data reference or a computation, and its value is either a scalar or
 6    an array. An expression is formed from operands, operators, and parentheses.

 7    An operand is either a scalar or an array. An operation is either intrinsic or defined (7.2). More
 8    complicated expressions can be formed using operands which are themselves expressions.

 9    Evaluation of an expression produces a value, which has a type, type parameters (if appropriate), and a
10    shape (7.1.4).


11    7.1.1      Form of an expression

12    An expression is defined in terms of several categories: primary, level-1 expression, level-2 expression,
13    level-3 expression, level-4 expression, and level-5 expression.

14    These categories are related to the different operator precedence levels and, in general, are defined in
15    terms of other categories. The simplest form of each expression category is a primary. The rules given
16    below specify the syntax of an expression. The semantics are specified in 7.2.


17    7.1.1.1     Primary

18    R701       primary                     is    constant
19                                           or designator
20                                           or array-constructor
21                                           or structure-constructor
22                                           or function-reference
23                                           or type-param-inquiry
24                                           or type-param-name
25                                           or ( expr )

26    C701       (R701) The type-param-name shall be the name of a type parameter.

27    C702       (R701) The designator shall not be a whole assumed-size array.

             NOTE 7.1

             Examples of a primary are:

                   Example                                                    Syntactic class

                   1.0                                                        constant
                   'ABCDEFGHIJKLMNOPQRSTUVWXYZ' (I:I)                         constant-subobject
                   A                                                          variable
                   (/ 1.0, 2.0 /)                                             array-constructor
                   PERSON (12, 'Jones')                                       structure-constructor
                   F (X, Y)                                                   function-reference





      SEP 2002                                      WORKING DRAFT                                         117


      J3/02-007R3                                     WORKING DRAFT                                             SEP 2002



             NOTE 7.1 (cont.)

                   (S + T)                                                                 (expr )


 1    7.1.1.2     Level-1 expressions

 2    Defined unary operators have the highest operator precedence (Table 7.7).                        Level-1 expressions are
 3    primaries optionally operated on by defined unary operators:

 4    R702       level-1-expr                   is    [ defined-unary-op ] primary
 5    R703       defined-unary-op                is    . letter [ letter ] ... .

 6    C703       (R703) A defined-unary-op shall not contain more than 63 letters and shall not be the same as
 7               any intrinsic-operator or logical-literal-constant .

             NOTE 7.2

             Simple examples of a level-1 expression are:

                      Example                                                         Syntactic class

                      A                                                               primary (R701)
                      .INVERSE. B                                                     level-1-expr (R702)

             A more complicated example of a level-1 expression is:

                      .INVERSE. (A + B)



 8    7.1.1.3     Level-2 expressions

 9    Level-2 expressions are level-1 expressions optionally involving the numeric operators power-op, mult-op,
10    and add-op.

11    R704       mult-operand                   is    level-1-expr [ power-op mult-operand ]
12    R705       add-operand                    is    [ add-operand mult-op ] mult-operand
13    R706       level-2-expr                   is    [ [ level-2-expr ] add-op ] add-operand
14    R707       power-op                       is    **
15    R708       mult-op                        is    *
16                                              or /
17    R709       add-op                         is    +
18                                              or �

             NOTE 7.3

             Simple examples of a level-2 expression are:

                      Example                  Syntactic class              Remarks

                      A                        level-1-expr                 A is a primary. (R702)
                      B ** C                   mult-operand                 B is a level-1-expr , ** is a power-op,
                                                                                   and C is a mult-operand . (R704)
                      D * E                    add-operand                  D is an add-operand , * is a mult-op,
                                                                                   and E is a mult-operand . (R705)
                      +1                       level-2-expr                 + is an add-op
                                                                                   and 1 is an add-operand . (R706)
                      F - I                    level-2-expr                 F is a level-2-expr , � is an add-op,
                                                                                   and I is an add-operand . (R706)





      118                                     WORKING DRAFT                                                     SEP 2002


      SEP 2002                              WORKING DRAFT                                          J3/02-007R3



           NOTE 7.3 (cont.)

           A more complicated example of a level-2 expression is:


                   - A + D * E + B ** C



 1    7.1.1.4     Level-3 expressions

 2    Level-3 expressions are level-2 expressions optionally involving the character operator concat-op.

 3    R710       level-3-expr               is    [ level-3-expr concat-op ] level-2-expr
 4    R711       concat-op                  is    //

           NOTE 7.4

           Simple examples of a level-3 expression are:

                      Example                                               Syntactic class

                      A                                                     level-2-expr (R706)
                      B // C                                                level-3-expr (R710)

           A more complicated example of a level-3 expression is:

                 X // Y // 'ABCD'


 5    7.1.1.5     Level-4 expressions

 6    Level-4 expressions are level-3 expressions optionally involving the relational operators rel-op.

 7    R712       level-4-expr               is    [ level-3-expr rel-op ] level-3-expr
 8    R713       rel-op                     is    .EQ.
 9                                          or .NE.
10                                          or .LT.
11                                          or .LE.
12                                          or .GT.
13                                          or .GE.
14                                          or ==
15                                          or /=
16                                          or <
17                                          or <=
18                                          or >
19                                          or >=

           NOTE 7.5

           Simple examples of a level-4 expression are:

                      Example                                               Syntactic class

                      A                                                     level-3-expr (R710)
                      B == C                                                level-4-expr (R712)
                      D < E                                                 level-4-expr (R712)

           A more complicated example of a level-4 expression is:


                   (A + B) /= C





      SEP 2002                                      WORKING DRAFT                                           119


      J3/02-007R3                                     WORKING DRAFT                                        SEP 2002



 1    7.1.1.6     Level-5 expressions

 2    Level-5 expressions are level-4 expressions optionally involving the logical operators not-op, and-op,
 3    or-op, and equiv-op.

 4    R714       and-operand                    is    [ not-op ] level-4-expr
 5    R715       or-operand                     is    [ or-operand and-op ] and-operand
 6    R716       equiv-operand                  is    [ equiv-operand or-op ] or-operand
 7    R717       level-5-expr                   is    [ level-5-expr equiv-op ] equiv-operand
 8    R718       not-op                         is    .NOT.
 9    R719       and-op                         is    .AND.
10    R720       or-op                          is    .OR.
11    R721       equiv-op                       is    .EQV.
12                                              or .NEQV.

             NOTE 7.6

             Simple examples of a level-5 expression are:

                         Example                                                   Syntactic class

                         A                                                         level-4-expr (R712)
                         .NOT. B                                                   and-operand (R714)
                         C .AND. D                                                 or-operand (R715)
                         E .OR. F                                                  equiv-operand (R716)
                         G .EQV. H                                                 level-5-expr (R717)
                         S .NEQV. T                                                level-5-expr (R717)

             A more complicated example of a level-5 expression is:

                 A .AND. B .EQV. .NOT. C


13    7.1.1.7     General form of an expression

14    Expressions are level-5 expressions optionally involving defined binary operators. Defined binary oper-
15    ators have the lowest operator precedence (Table 7.7).

16    R722       expr                           is    [ expr defined-binary-op ] level-5-expr
17    R723       defined-binary-op               is    . letter [ letter ] ... .

18    C704       (R723) A defined-binary-op shall not contain more than 63 letters and shall not be the same as
19               any intrinsic-operator or logical-literal-constant .

             NOTE 7.7

             Simple examples of an expression are:

                         Example                                                   Syntactic class

                         A                                                         level-5-expr (R717)
                         B.UNION.C                                                 expr (R722)

             More complicated examples of an expression are:

                         (B .INTERSECT. C) .UNION. (X - Y)
                         A + B == C * D
                         .INVERSE. (A + B)
                         A + B .AND. C * D
                         E // G == H (1:10)





      120                                      WORKING DRAFT                                               SEP 2002


      SEP 2002                                   WORKING DRAFT                                  J3/02-007R3


 1    7.1.2    Intrinsic operations

 2    An intrinsic operation is either an intrinsic unary operation or an intrinsic binary operation. An
 3    intrinsic unary operation is an operation of the form intrinsic-operator x2 where x2 is of an intrinsic
 4    type (4.4) listed in Table 7.1 for the unary intrinsic operator.

 5    An intrinsic binary operation is an operation of the form x1 intrinsic-operator x2 where x1 and
 6    x2 are of the intrinsic types (4.4) listed in Table 7.1 for the binary intrinsic operator and are in shape
 7    conformance (7.1.5).


                        Table 7.1: Type of operands and results for intrinsic operators
                         Intrinsic operator         Type of    Type of              Type of
                                  op                   x1         x2              [x1] op x2

                              Unary +, �                       I, R, Z              I, R, Z
                                                        I      I, R, Z              I, R, Z
                        Binary +, �, *, /, **          R       I, R, Z              R, R, Z
                                                       Z       I, R, Z              Z, Z, Z
                                  //                   C          C                    C
                                                        I      I, R, Z              L, L, L
                              .EQ., .NE.,              R       I, R, Z              L, L, L
                               ==, /=                  Z       I, R, Z              L, L, L
                                                       C          C                    L
                                                        I        I, R                L, L
                       .GT., .GE., .LT., .LE.          R         I, R                L, L
                           >, >=, <, <=                C         I, R                L, L
                                .NOT.                             L                    L
                    .AND., .OR., .EQV., .NEQV.         L          L                    L
                    Note: The symbols I, R, Z, C, and L stand for the types integer, real, complex,
                          character, and logical, respectively. Where more than one type for x2 is
                          given, the type of the result of the operation is given in the same relative
                          position in the next column. For the intrinsic operators with operands of
                          type character, the kind type parameters of the operands shall be the same.



 8    A numeric intrinsic operation is an intrinsic operation for which the intrinsic-operator is a numeric
 9    operator (+, �, *, /, or **). A numeric intrinsic operator is the operator in a numeric intrinsic
10    operation.

11    For numeric intrinsic binary operations, the two operands may be of different numeric types or different
12    kind type parameters. Except for a value raised to an integer power, if the operands have different types
13    or kind type parameters, the effect is as if each operand that differs in type or kind type parameter from
14    those of the result is converted to the type and kind type parameter of the result before the operation
15    is performed. When a value of type real or complex is raised to an integer power, the integer operand
16    need not be converted.

17    A character intrinsic operation, relational intrinsic operation, and logical intrinsic operation
18    are similarly defined in terms of a character intrinsic operator (//), relational intrinsic operator
19    (.EQ., .NE., .GT., .GE., .LT., .LE., ==, /=, >, >=, <, and <=), and logical intrinsic operator
20    (.AND., .OR., .NOT., .EQV., and .NEQV.), respectively. For the character intrinsic operator //, the
21    kind type parameters shall be the same. For the relational intrinsic operators with character operands,
22    the kind type parameters shall be the same.

23    A numeric relational intrinsic operation is a relational intrinsic operation where the operands are
24    of numeric type. A character relational intrinsic operation is a relational intrinsic operation where
25    the operands are of type character.



      SEP 2002                                      WORKING DRAFT                                          121


      J3/02-007R3                                   WORKING DRAFT                                       SEP 2002


 1    7.1.3         Defined operations

 2    A defined operation is either a defined unary operation or a defined binary operation. A defined
 3    unary operation is an operation that has the form defined-unary-op                x2 and that is defined by a
 4    function and a generic interface (4.5.1, 12.3.2.1) or that has the form intrinsic-operator x2 where the
 5    type of x2 is not that required for the unary intrinsic operation (7.1.2), and that is defined by a function
 6    and a generic interface.

 7    A function defines the unary operation op x2 if

 8           (1)      The function is specified with a FUNCTION (12.5.2.1) or ENTRY (12.5.2.4) statement that
 9                    specifies one dummy argument d2,
10           (2)      Either

11                    (a)    A generic interface (12.3.2.1) provides the function with a generic-spec of OPERA-
12                           TOR (op), or

13                    (b)    There is a type-bound generic binding (4.5.1) in the declared type of x2 with a generic-
14                           spec of OPERATOR (op) and there is a corresponding binding to the function in the
15                           dynamic type of x2,

16           (3)      The type of d2 is compatible with the dynamic type of x2,
17           (4)      The type parameters, if any, of d2 match the corresponding type parameters of x2, and
18           (5)      Either

19                    (a)    The rank of x2 matches that of d2 or
20                    (b)    The function is elemental and there is no other function that defines the operation.


21    If d2 is an array, the shape of x2 shall match the shape of d2.

22    A defined binary operation is an operation that has the form x1 defined-binary-op x2 and that is
23    defined by a function and a generic interface or that has the form x1 intrinsic-operator x2 where the
24    types or ranks of either x1 or x2 or both are not those required for the intrinsic binary operation (7.1.2),
25    and that is defined by a function and a generic interface.

26    A function defines the binary operation x1 op x2 if

27           (1)      The function is specified with a FUNCTION (12.5.2.1) or ENTRY (12.5.2.4) statement that
28                    specifies two dummy arguments, d1 and d2,
29           (2)      Either

30                    (a)    A generic interface (12.3.2.1) provides the function with a generic-spec of OPERA-
31                           TOR (op), or

32                    (b)    There is a type-bound generic binding (4.5.1) in the declared type of x1 or x2 with a
33                           generic-spec of OPERATOR (op) and there is a corresponding binding to the function
34                           in the dynamic type of x1 or x2, respectively,

35           (3)      The types of d1 and d2 are compatible with the dynamic types of x1 and x2, respectively,
36           (4)      The type parameters, if any, of d1 and d2 match the corresponding type parameters of x1
37                    and x2, respectively, and
38           (5)      Either

39                    (a)    The ranks of x1 and x2 match those of d1 and d2 or
40                    (b)    The function is elemental, x1 and x2 are conformable, and there is no other function
41                           that defines the operation.


42    If d1 or d2 is an array, the shapes of x1 and x2 shall match the shapes of d1 and d2, respectively.





      122                                     WORKING DRAFT                                             SEP 2002


      SEP 2002                                 WORKING DRAFT                                        J3/02-007R3



           NOTE 7.8

           An intrinsic operator may be used as the operator in a defined operation. In such a case, the
           generic properties of the operator are extended.


 1    An extension operation is a defined operation in which the operator is of the form defined-unary-op
 2    or defined-binary-op. Such an operator is called an extension operator. The operator used in an
 3    extension operation may be such that a generic interface for the operator may specify more than one
 4    function.

 5    A defined elemental operation is a defined operation for which the function is elemental (12.7).


 6    7.1.4        Type, type parameters, and shape of an expression

 7    The type, type parameters, and shape of an expression depend on the operators and on the types, type
 8    parameters, and shapes of the primaries used in the expression, and are determined recursively from
 9    the syntactic form of the expression. The type of an expression is one of the intrinsic types (4.4) or a
10    derived type (4.5).

11    If an expression is a polymorphic primary or defined operation, the type parameters and the declared and
12    dynamic types of the expression are the same as those of the primary or defined operation. Otherwise
13    the type parameters and dynamic type of the expression are the same as its declared type and type
14    parameters; they are referred to simply as the type and type parameters of the expression.

15    R724       logical-expr                  is    expr

16    C705       (R724) logical-expr shall be of type logical.

17    R725       char-expr                     is    expr

18    C706       (R725) char-expr shall be of type character.

19    R726       default-char-expr             is    expr

20    C707       (R726) default-char-expr shall be of type default character.

21    R727       int-expr                      is    expr

22    C708       (R727) int-expr shall be of type integer.

23    R728       numeric-expr                  is    expr

24    C709       (R728) numeric-expr shall be of type integer, real, or complex.


25    7.1.4.1      Type, type parameters, and shape of a primary

26    The type, type parameters, and shape of a primary are determined according to whether the primary is a
27    constant, variable, array constructor, structure constructor, function reference, type parameter inquiry,
28    type parameter name, or parenthesized expression. If a primary is a constant, its type, type parameters,
29    and shape are those of the constant. If it is a structure constructor, it is scalar and its type and type
30    parameters are as described in 4.5.8. If it is an array constructor, its type, type parameters, and shape
31    are as described in 4.8. If it is a variable or function reference, its type, type parameters, and shape are
32    those of the variable (5.1.1, 5.1.2) or the function reference (12.4.2), respectively. If the function reference
33    is generic (12.3.2.1, 13.5) then its type, type parameters, and shape are those of the specific function
34    referenced, which is determined by the types, type parameters, and ranks of its actual arguments as
35    specified in 16.2.3. If it is a type parameter inquiry or type parameter name, it is a scalar integer with
36    the kind of the type parameter.




      SEP 2002                                        WORKING DRAFT                                              123


      J3/02-007R3                                    WORKING DRAFT                                       SEP 2002



 1    If a primary is a parenthesized expression, its type, type parameters, and shape are those of the expres-
 2    sion.

 3    If a pointer appears as one of the following, the associated target object is referenced:

 4             (1)      A primary in an intrinsic or defined operation,

 5             (2)      The expr of a parenthesized primary, or

 6             (3)      The only primary on the right-hand side of an intrinsic assignment statement.

 7    The type, type parameters, and shape of the primary are those of the current target. If the pointer is
 8    not associated with a target, it may appear as a primary only as an actual argument in a reference to
 9    a procedure whose corresponding dummy argument is declared to be a pointer, or as the target in a
10    pointer assignment statement.

11    A disassociated array pointer or an unallocated allocatable array has no shape but does have rank. The
12    type, type parameters, and rank of the result of the NULL intrinsic function depend on context (13.7.84).


13    7.1.4.2         Type, type parameters, and shape of the result of an operation

14    The type of the result of an intrinsic operation [x1] op x2 is specified by Table 7.1. The shape of the
15    result of an intrinsic operation is the shape of x2 if op is unary or if x1 is scalar, and is the shape of x1
16    otherwise.

17    The type, type parameters, and shape of the result of a defined operation [x1] op x2 is specified by the
18    function defining the operation (7.2).

19    An expression of an intrinsic type has a kind type parameter. An expression of type character also has
20    a character length parameter.

21    The type parameters of the result of an intrinsic operation are as follows:

22             (1)      For an expression x1 // x2 where // is the character intrinsic operator and x1 and x2 are
23                      of type character, the character length parameter is the sum of the lengths of the operands
24                      and the kind type parameter is the kind type parameter of x1, which shall be the same as
25                      the kind type parameter of x2.
26             (2)      For an expression op x2 where op is an intrinsic unary operator and x2 is of type integer,
27                      real, complex, or logical, the kind type parameter of the expression is that of the operand.

28             (3)      For an expression x1 op x2 where op is a numeric intrinsic binary operator with one operand
29                      of type integer and the other of type real or complex, the kind type parameter of the
30                      expression is that of the real or complex operand.

31             (4)      For an expression x1 op x2 where op is a numeric intrinsic binary operator with both
32                      operands of the same type and kind type parameters, or with one real and one complex
33                      with the same kind type parameters, the kind type parameter of the expression is identical
34                      to that of each operand. In the case where both operands are integer with different kind type
35                      parameters, the kind type parameter of the expression is that of the operand with the greater
36                      decimal exponent range if the decimal exponent ranges are different; if the decimal exponent
37                      ranges are the same, the kind type parameter of the expression is processor dependent, but
38                      it is the same as that of one of the operands. In the case where both operands are any
39                      of type real or complex with different kind type parameters, the kind type parameter of
40                      the expression is that of the operand with the greater decimal precision if the decimal
41                      precisions are different; if the decimal precisions are the same, the kind type parameter of
42                      the expression is processor dependent, but it is the same as that of one of the operands.

43             (5)      For an expression x1 op x2 where op is a logical intrinsic binary operator with both operands
44                      of the same kind type parameter, the kind type parameter of the expression is identical to
45                      that of each operand. In the case where both operands are of type logical with different




      124                                      WORKING DRAFT                                             SEP 2002


      SEP 2002                                         WORKING DRAFT                                   J3/02-007R3



 1                     kind type parameters, the kind type parameter of the expression is processor dependent,
 2                     but it is the same as that of one of the operands.

 3            (6)      For an expression x1 op x2 where op is a relational intrinsic operator, the expression has
 4                     the default logical kind type parameter.


 5    7.1.5          Conformability rules for elemental operations

 6    An elemental operation is an intrinsic operation or a defined elemental operation. Two entities are
 7    in shape conformance if both are arrays of the same shape, or one or both are scalars.

 8    For all elemental binary operations, the two operands shall be in shape conformance. In the case where
 9    one is a scalar and the other an array, the scalar is treated as if it were an array of the same shape as
10    the array operand with every element, if any, of the array equal to the value of the scalar.


11    7.1.6          Specification expression

12    A specification expression is an expression with limitations that make it suitable for use in specifi-
13    cations such as nonkind type parameters (R502) and array bounds (R517, R518).

14    R729      specification-expr                      is    scalar-int-expr

15    C710      (R729) The scalar-int-expr shall be a restricted expression.

16    A restricted expression is an expression in which each operation is intrinsic and each primary is

17            (1)      A constant or subobject of a constant,

18            (2)      An object designator with a base object that is a dummy argument that has neither the
19                     OPTIONAL nor the INTENT (OUT) attribute,

20            (3)      An object designator with a base object that is in a common block,

21            (4)      An object designator with a base object that is made accessible by use association or host
22                     association,

23            (5)      An array constructor where each element and the bounds and strides of each implied-DO
24                     are restricted expressions,

25            (6)      A structure constructor where each component is a restricted expression,

26            (7)      A specification inquiry where each designator or function argument is

27                     (a)    a restricted expression or

28                     (b)    a variable whose properties inquired about are not

29                            (i)      dependent on the upper bound of the last dimension of an assumed-size array,

30                            (ii)     deferred, or

31                            (iii)    defined by an expression that is not a restricted expression,

32            (8)      A reference to any other standard intrinsic function where each argument is a restricted
33                     expression,

34            (9)      A reference to a specification function where each argument is a restricted expression,

35            (10)     A type parameter of the derived type being defined,

36            (11)     An implied-DO variable within an array constructor where the bounds and strides of the
37                     corresponding implied-DO are restricted expressions, or

38            (12)     A restricted expression enclosed in parentheses,

39    where each subscript, section subscript, substring starting point, substring ending point, and type pa-
40    rameter value is a restricted expression, and where any final subroutine that is invoked is pure.

41    A specification inquiry is a reference to




      SEP 2002                                                WORKING DRAFT                                      125


      J3/02-007R3                                    WORKING DRAFT                                    SEP 2002



 1            (1)      an array inquiry function (13.5.7),

 2            (2)      the bit inquiry function BIT SIZE,

 3            (3)      the character inquiry function LEN,

 4            (4)      the kind inquiry function KIND,

 5            (5)      a numeric inquiry function (13.5.6),

 6            (6)      a type parameter inquiry (6.1.3), or

 7            (7)      an IEEE inquiry function (14.8.1),

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

10    Evaluation of a specification expression shall not directly or indirectly cause a procedure defined by the
11    subprogram in which it appears to be invoked.

             NOTE 7.9

             Specification functions are nonintrinsic functions that may be used in specification expressions to
             determine the attributes of data objects. The requirement that they be pure ensures that they
             cannot have side effects that could affect other objects being declared in the same specification-part .
             The requirement that they not be internal ensures that they cannot inquire, via host association,
             about other objects being declared in the same specification-part . The prohibition against recursion
             avoids the creation of a new activation record while construction of one is in progress.


12    A variable in a specification expression shall have its type and type parameters, if any, specified by a
13    previous declaration in the same scoping unit, by the implicit typing rules in effect for the scoping unit,
14    or by host or use association. If a variable in a specification expression is typed by the implicit typing
15    rules, its appearance in any subsequent type declaration statement shall confirm the implied type and
16    type parameters.

17    If a specification expression includes a specification inquiry that depends on a type parameter or an
18    array bound of an entity specified in the same specification-part , the type parameter or array bound
19    shall be specified in a prior specification of the specification-part . The prior specification may be to the
20    left of the specification inquiry in the same statement, but shall not be within the same entity-decl . If a
21    specification expression includes a reference to the value of an element of an array specified in the same
22    specification-part , the array shall be completely specified in prior declarations.

             NOTE 7.10

             The following are examples of specification expressions:


                LBOUND (B, 1) + 5          ! B is an assumed-shape dummy array
                M + LEN (C)                ! M and C are dummy arguments
                2 * PRECISION (A)          ! A is a real variable made accessible
                                           ! by a USE statement



23    7.1.7          Initialization expression

24    An initialization expression is an expression with limitations that make it suitable for use as a kind
25    type parameter, initializer, or named constant. It is an expression in which each operation is intrinsic,
26    and each primary is

27            (1)      A constant or subobject of a constant,

28            (2)      An array constructor where each element and the bounds and strides of each implied-DO
29                     are initialization expressions,




      126                                      WORKING DRAFT                                          SEP 2002


      SEP 2002                                          WORKING DRAFT                                  J3/02-007R3



 1            (3)     A structure constructor where each component-spec corresponding to an allocatable com-
 2                    ponent is a reference to the transformational intrinsic function NULL, and each other
 3                    component-spec is an initialization expression,

 4            (4)     A reference to an elemental standard intrinsic function, where each argument is an initial-
 5                    ization expression,

 6            (5)     A reference to a transformational standard intrinsic function other than NULL, where each
 7                    argument is an initialization expression,

 8            (6)     A reference to the transformational intrinsic function NULL that does not have an argu-
 9                    ment with a type parameter that is assumed or is defined by an expression that is not an
10                    initialization expression,

11            (7)     A reference to the transformational function IEEE SELECTED REAL KIND from the in-
12                    trinsic module IEEE ARITHMETIC (14), where each argument is an initialization expres-
13                    sion.

14            (8)     A specification inquiry where each designator or function argument is

15                    (a)      an initialization expression or

16                    (b)      a variable whose properties inquired about are not

17                             (i)      assumed,

18                             (ii)     deferred, or

19                             (iii)    defined by an expression that is not an initialization expression,

20            (9)     A kind type parameter of the derived type being defined,

21            (10)    An implied-DO variable within an array constructor where the bounds and strides of the
22                    corresponding implied-DO are initialization expressions, or

23            (11)    An initialization expression enclosed in parentheses,

24    and where each subscript, section subscript, substring starting point, substring ending point, and type
25    parameter value is an initialization expression.

26    R730      initialization-expr                     is    expr

27    C711      (R730) initialization-expr shall be an initialization expression.

28    R731      char-initialization-expr                is    char-expr

29    C712      (R731) char-initialization-expr shall be an initialization expression.

30    R732      int-initialization-expr                 is    int-expr

31    C713      (R732) int-initialization-expr shall be an initialization expression.

32    R733      logical-initialization-expr             is    logical-expr

33    C714      (R733) logical-initialization-expr shall be an initialization expression.

34    If an initialization expression includes a specification inquiry that depends on a type parameter or an
35    array bound of an entity specified in the same specification-part , the type parameter or array bound
36    shall be specified in a prior specification of the specification-part . The prior specification may be to the
37    left of the specification inquiry in the same statement, but shall not be within the same entity-decl .

           NOTE 7.11

           The following are examples of initialization expressions:


                3





      SEP 2002                                                 WORKING DRAFT                                  127


      J3/02-007R3                                WORKING DRAFT                                       SEP 2002



             NOTE 7.11 (cont.)

                   -3 + 4
                   'AB'
                   'AB' // 'CD'
                   ('AB' // 'CD') // 'EF'
                   SIZE (A)
                   DIGITS (X) + 4
                   4.0 * atan(1.0)
                   ceiling(number_of_decimal_digits / log10(radix(0.0)))


             where A is an explicit-shaped array with constant bounds and X is of type default real.


 1    7.1.8        Evaluation of operations

 2    An intrinsic operation requires the values of its operands.

 3    The execution of any numeric operation whose result is not defined by the arithmetic used by the
 4    processor is prohibited. Raising a negative-valued primary of type real to a real power is prohibited.

 5    The evaluation of a function reference shall neither affect nor be affected by the evaluation of any other
 6    entity within the statement. If a function reference causes definition or undefinition of an actual argument
 7    of the function, that argument or any associated entities shall not appear elsewhere in the same statement.
 8    However, execution of a function reference in the logical expression in an IF statement (8.1.2.4), the mask
 9    expression in a WHERE statement (7.4.3.1), or the subscripts and strides in a FORALL statement (7.4.4)
10    is permitted to define variables in the statement that is conditionally executed.

             NOTE 7.12

             For example, the statements


                   A (I) = F (I)
                   Y = G (X) + X


             are prohibited if the reference to F defines or undefines I or the reference to G defines or undefines
             X.

             However, in the statements


                   IF (F (X)) A = X
                   WHERE (G (X)) B = X


             F or G may define X.


11    The declared type of an expression in which a function reference appears does not affect, and is not
12    affected by, the evaluation of the actual arguments of the function.

13    Execution of an array element reference requires the evaluation of its subscripts. The type of an expres-
14    sion in which the array element reference appears does not affect, and is not affected by, the evaluation
15    of its subscripts. Execution of an array section reference requires the evaluation of its section subscripts.
16    The type of an expression in which an array section appears does not affect, and is not affected by, the
17    evaluation of the array section subscripts. Execution of a substring reference requires the evaluation of
18    its substring expressions. The type of an expression in which a substring appears does not affect, and
19    is not affected by, the evaluation of the substring expressions. It is not necessary for a processor to
20    evaluate any subscript expressions or substring expressions for an array of zero size or a character entity




      128                                    WORKING DRAFT                                           SEP 2002


      SEP 2002                                 WORKING DRAFT                                     J3/02-007R3



 1    of zero length.

 2    The appearance of an array constructor requires the evaluation of the bounds and stride of any array
 3    constructor implied-DO it may contain. The type of an expression in which an array constructor appears
 4    does not affect, and is not affected by, the evaluation of such bounds and stride expressions.

 5    When an elemental binary operation is applied to a scalar and an array or to two arrays of the same
 6    shape, the operation is performed element-by-element on corresponding array elements of the array
 7    operands. The processor may perform the element-by-element operations in any order.

           NOTE 7.13

           For example, the array expression


                 A + B


           produces an array of the same shape as A and B. The individual array elements of the result have
           the values of the first element of A added to the first element of B, the second element of A added
           to the second element of B, etc.


 8    When an elemental unary operator operates on an array operand, the operation is performed element-
 9    by-element, in any order, and the result is the same shape as the operand.


10    7.1.8.1    Evaluation of operands

11    It is not necessary for a processor to evaluate all of the operands of an expression, or to evaluate entirely
12    each operand, if the value of the expression can be determined otherwise.

           NOTE 7.14

           This principle is most often applicable to logical expressions, zero-sized arrays, and zero-length
           strings, but it applies to all expressions.

           For example, in evaluating the expression


                 X > Y .OR. L (Z)


           where X, Y, and Z are real and L is a function of type logical, the function reference L (Z) need
           not be evaluated if X is greater than Y. Similarly, in the array expression


                 W (Z) + A


           where A is of size zero and W is a function, the function reference W (Z) need not be evaluated.


13    If a statement contains a function reference in a part of an expression that need not be evaluated, all
14    entities that would have become defined in the execution of that reference become undefined at the
15    completion of evaluation of the expression containing the function reference.

           NOTE 7.15

           In the examples in Note 7.14, if L or W defines its argument, evaluation of the expressions under
           the specified conditions causes Z to become undefined, no matter whether or not L(Z) or W(Z) is
           evaluated.





      SEP 2002                                      WORKING DRAFT                                             129


      J3/02-007R3                                WORKING DRAFT                                      SEP 2002



 1    7.1.8.2    Integrity of parentheses

 2    The sections that follow state certain conditions under which a processor may evaluate an expression that
 3    is different from the one specified by applying the rules given in 7.1.1 and 7.2. However, any expression
 4    in parentheses shall be treated as a data entity.

             NOTE 7.16

             For example, in evaluating the expression A + (B � C) where A, B, and C are of numeric types, the
             difference of B and C shall be evaluated before the addition operation is performed; the processor
             shall not evaluate the mathematically equivalent expression (A + B) � C.


 5    7.1.8.3    Evaluation of numeric intrinsic operations

 6    The rules given in 7.2.1 specify the interpretation of a numeric intrinsic operation. Once the interpreta-
 7    tion has been established in accordance with those rules, the processor may evaluate any mathematically
 8    equivalent expression, provided that the integrity of parentheses is not violated.

 9    Two expressions of a numeric type are mathematically equivalent if, for all possible values of their
10    primaries, their mathematical values are equal.      However, mathematically equivalent expressions of
11    numeric type may produce different computational results.

             NOTE 7.17

             Any difference between the values of the expressions (1./3.)*3. and 1. is a computational difference,
             not a mathematical difference. The difference between the values of the expressions 5/2 and 5./2.
             is a mathematical difference, not a computational difference.

             The mathematical definition of integer division is given in 7.2.1.1.


             NOTE 7.18

             The following are examples of expressions with allowable alternative forms that may be used by the
             processor in the evaluation of those expressions. A, B, and C represent arbitrary real or complex
             operands; I and J represent arbitrary integer operands; and X, Y, and Z represent arbitrary
             operands of numeric type.

                     Expression                                           Allowable alternative form

                     X + Y                                                Y + X
                     X * Y                                                Y * X
                     -X + Y                                               Y - X
                     X + Y + Z                                            X + (Y + Z)
                     X - Y + Z                                            X - (Y - Z)
                     X * A / Z                                            X * (A / Z)
                     X * Y - X * Z                                        X * (Y - Z)
                     A / B / C                                            A / (B * C)
                     A / 5.0                                              0.2 * A

             The following are examples of expressions with forbidden alternative forms that shall not be used
             by a processor in the evaluation of those expressions.





      130                                    WORKING DRAFT                                          SEP 2002


      SEP 2002                              WORKING DRAFT                                      J3/02-007R3



          NOTE 7.18 (cont.)

                    Expression                                           Forbidden alternative form

                    I / 2                                                0.5 * I
                    X * I / J                                            X * (I / J)
                    I / J / A                                            I / (J * A)
                    (X + Y) + Z                                          X + (Y + Z)
                    (X * Y) - (X * Z)                                    X * (Y - Z)
                    X * (Y - Z)                                          X * Y - X * Z


 1    In addition to the parentheses required to establish the desired interpretation, parentheses may be
 2    included to restrict the alternative forms that may be used by the processor in the actual evaluation
 3    of the expression. This is useful for controlling the magnitude and accuracy of intermediate values
 4    developed during the evaluation of an expression.

          NOTE 7.19

          For example, in the expression


                 A + (B - C)


          the parenthesized expression (B � C) shall be evaluated and then added to A.

          The inclusion of parentheses may change the mathematical value of an expression. For example,
          the two expressions


                 A * I / J
                 A * (I / J)


          may have different mathematical values if I and J are of type integer.


 5    Each operand in a numeric intrinsic operation has a type that may depend on the order of evaluation
 6    used by the processor.

          NOTE 7.20

          For example, in the evaluation of the expression


                 Z + R + I


          where Z, R, and I represent data objects of complex, real, and integer type, respectively, the type of
          the operand that is added to I may be either complex or real, depending on which pair of operands
          (Z and R, R and I, or Z and I) is added first.


 7    7.1.8.4     Evaluation of the character intrinsic operation

 8    The rules given in 7.2.2 specify the interpretation of the character intrinsic operation. A processor is
 9    required to evaluate only as much of the character intrinsic operation as is required by the context in
10    which the expression appears.

          NOTE 7.21

          For example, the statements





      SEP 2002                                   WORKING DRAFT                                              131


      J3/02-007R3                                 WORKING DRAFT                                      SEP 2002



             NOTE 7.21 (cont.)

                   CHARACTER (LEN = 2) C1, C2, C3, CF
                   C1 = C2 // CF (C3)


             do not require the function CF to be evaluated, because only the value of C2 is needed to determine
             the value of C1 because C1 and C2 both have a length of 2.


 1    7.1.8.5       Evaluation of relational intrinsic operations

 2    The rules given in 7.2.3 specify the interpretation of relational intrinsic operations. Once the interpre-
 3    tation of an expression has been established in accordance with those rules, the processor may evaluate
 4    any other expression that is relationally equivalent, provided that the integrity of parentheses in any
 5    expression is not violated.

             NOTE 7.22

             For example, the processor may choose to evaluate the expression


                   I > J


             where I and J are integer variables, as


                   J - I < 0



 6    Two relational intrinsic operations are relationally equivalent if their logical values are equal for all
 7    possible values of their primaries.


 8    7.1.8.6      Evaluation of logical intrinsic operations

 9    The rules given in 7.2.4 specify the interpretation of logical intrinsic operations. Once the interpretation
10    of an expression has been established in accordance with those rules, the processor may evaluate any
11    other expression that is logically equivalent, provided that the integrity of parentheses in any expression
12    is not violated.

             NOTE 7.23

             For example, for the variables L1, L2, and L3 of type logical, the processor may choose to evaluate
             the expression


                   L1 .AND. L2 .AND. L3


             as


                   L1 .AND. (L2 .AND. L3)



13    Two expressions of type logical are logically equivalent if their values are equal for all possible values of
14    their primaries.


15    7.1.8.7      Evaluation of a defined operation

16    The rules given in 7.2 specify the interpretation of a defined operation. Once the interpretation of an
17    expression has been established in accordance with those rules, the processor may evaluate any other
18    expression that is equivalent, provided that the integrity of parentheses is not violated.

19    Two expressions of derived type are equivalent if their values are equal for all possible values of their



      132                                    WORKING DRAFT                                           SEP 2002


      SEP 2002                                   WORKING DRAFT                                   J3/02-007R3



 1    primaries.


 2    7.2        Interpretation of operations

 3    The intrinsic operations are those defined in 7.1.2. These operations are divided into the following
 4    categories: numeric, character, relational, and logical.        The interpretations defined in the following
 5    sections apply to both scalars and arrays; the interpretation for arrays is obtained by applying the
 6    interpretation for scalars element by element.

 7    The interpretation of a defined operation is provided by the function that defines the operation. The type,
 8    type parameters and interpretation of an expression that consists of an intrinsic or defined operation are
 9    independent of the type and type parameters of the context or any larger expression in which it appears.

             NOTE 7.24

             For example, if X is of type real, J is of type integer, and INT is the real-to-integer intrinsic
             conversion function, the expression INT (X + J) is an integer expression and X + J is a real
             expression.


10    The operators <, <=, >, >=, ==, and /= always have the same interpretations as the operators .LT.,
11    .LE., .GT., .GE., .EQ., and .NE., respectively.


12    7.2.1      Numeric intrinsic operations

13    A numeric operation is used to express a numeric computation. Evaluation of a numeric operation
14    produces a numeric value. The permitted data types for operands of the numeric intrinsic operations
15    are specified in 7.1.2.

16    The numeric operators and their interpretation in an expression are given in Table 7.2, where x1 denotes
17    the operand to the left of the operator and x2 denotes the operand to the right of the operator.

                            Table 7.2: Interpretation of the numeric intrinsic operators
                       Operator      Representing      Use of operator    Interpretation

                            **       Exponentiation       x1 ** x2        Raise x1 to the power x2
                            /        Division             x1 / x2         Divide x1 by x2
                            *        Multiplication       x1 * x2         Multiply x1 by x2
                            -        Subtraction           x1 - x2        Subtract x2 from x1
                            -        Negation               - x2          Negate x2
                            +        Addition             x1 + x2         Add x1 and x2
                            +        Identity               + x2          Same as x2



18    The interpretation of a division operation depends on the types of the operands (7.2.1.1).

19    If x1 and x2 are of type integer and x2 has a negative value, the interpretation of x1 ** x2 is the same
20    as the interpretation of 1/(x1 ** ABS (x2)), which is subject to the rules of integer division (7.2.1.1).

             NOTE 7.25

             For example, 2 ** (�3) has the value of 1/(2 ** 3), which is zero.


21    7.2.1.1    Integer division

22    One operand of type integer may be divided by another operand of type integer. Although the math-
23    ematical quotient of two integers is not necessarily an integer, Table 7.1 specifies that an expression



      SEP 2002                                         WORKING DRAFT                                        133


      J3/02-007R3                                   WORKING DRAFT                                    SEP 2002



 1    involving the division operator with two operands of type integer is interpreted as an expression of type
 2    integer. The result of such an operation is the integer closest to the mathematical quotient and between
 3    zero and the mathematical quotient inclusively.

             NOTE 7.26

             For example, the expression (�8) / 3 has the value (�2).


 4    7.2.1.2    Complex exponentiation

 5    In the case of a complex value raised to a complex power, the value of the operation x1 ** x2 is the
 6    principal value of xx2 .
                           1


 7    7.2.2      Character intrinsic operation

 8    The character intrinsic operator // is used to concatenate two operands of type character with the same
 9    kind type parameter. Evaluation of the character intrinsic operation produces a result of type character.

10    The interpretation of the character intrinsic operator // when used to form an expression is given in
11    Table 7.3, where x1 denotes the operand to the left of the operator and x2 denotes the operand to the
12    right of the operator.


                        Table 7.3: Interpretation of the character intrinsic operator //
                        Operator    Representing      Use of operator    Interpretation

                           //       Concatenation        x1 // x2        Concatenate x1 with x2



13    The result of the character intrinsic operation // is a character string whose value is the value of x1
14    concatenated on the right with the value of x2 and whose length is the sum of the lengths of x1 and x2.
15    Parentheses used to specify the order of evaluation have no effect on the value of a character expression.

             NOTE 7.27

             For example, the value of ('AB' // 'CDE') // 'F' is the string 'ABCDEF'. Also, the value of
             'AB' // ('CDE' // 'F') is the string 'ABCDEF'.


16    7.2.3      Relational intrinsic operations

17    A relational intrinsic operation is used to compare values of two operands using the relational intrinsic
18    operators .LT., .LE., .GT., .GE., .EQ., .NE., <, <=, >, >=, ==, and /=. The permitted types for
19    operands of the relational intrinsic operators are specified in 7.1.2.

             NOTE 7.28

             As shown in Table 7.1, a relational intrinsic operator cannot be used to compare the value of an
             expression of a numeric type with one of type character or logical. Also, two operands of type
             logical cannot be compared, a complex operand may be compared with another numeric operand
             only when the operator is .EQ., .NE., ==, or /=, and two character operands cannot be compared
             unless they have the same kind type parameter value.


20    Evaluation of a relational intrinsic operation produces a result of type default logical.

21    The interpretation of the relational intrinsic operators is given in Table 7.4, where x1 denotes the operand
22    to the left of the operator and x2 denotes the operand to the right of the operator.





      134                                  WORKING DRAFT                                             SEP 2002


      SEP 2002                                  WORKING DRAFT                                       J3/02-007R3


                             Table 7.4: Interpretation of the relational intrinsic operators
               Operator        Representing                Use of operator    Interpretation

                     .LT.      Less than                     x1 .LT. x2       x1 less than x2
                      <        Less than                      x1 < x2         x1 less than x2
                     .LE.      Less than or equal to         x1 .LE. x2       x1 less than or equal to x2
                     <=        Less than or equal to         x1 <= x2         x1 less than or equal to x2
                    .GT.       Greater than                  x1 .GT. x2       x1 greater than x2
                      >        Greater than                   x1 > x2         x1 greater than x2
                    .GE.       Greater than or equal to      x1 .GE. x2       x1 greater than or equal to x2
                     >=        Greater than or equal to      x1 >= x2         x1 greater than or equal to x2
                    .EQ.       Equal to                      x1 .EQ. x2       x1 equal to x2
                     ==        Equal to                      x1 == x2         x1 equal to x2
                    .NE.       Not equal to                  x1 .NE. x2       x1 not equal to x2
                     /=        Not equal to                   x1 /= x2        x1 not equal to x2



 1    A numeric relational intrinsic operation is interpreted as having the logical value true if the values of
 2    the operands satisfy the relation specified by the operator. A numeric relational intrinsic operation is
 3    interpreted as having the logical value false if the values of the operands do not satisfy the relation
 4    specified by the operator.

 5    In the numeric relational operation

 6                 x1 rel-op x2

 7    if the types or kind type parameters of x1 and x2 differ, their values are converted to the type and kind
 8    type parameter of the expression x1 + x2 before evaluation.

 9    A character relational intrinsic operation is interpreted as having the logical value true if the values of
10    the operands satisfy the relation specified by the operator. A character relational intrinsic operation
11    is interpreted as having the logical value false if the values of the operands do not satisfy the relation
12    specified by the operator.

13    For a character relational intrinsic operation, the operands are compared one character at a time in
14    order, beginning with the first character of each character operand. If the operands are of unequal
15    length, the shorter operand is treated as if it were extended on the right with blanks to the length of
16    the longer operand. If both x1 and x2 are of zero length, x1 is equal to x2; if every character of x1 is
17    the same as the character in the corresponding position in x2, x1 is equal to x2. Otherwise, at the first
18    position where the character operands differ, the character operand x1 is considered to be less than x2
19    if the character value of x1 at this position precedes the value of x2 in the collating sequence (4.4.4.1);
20    x1 is greater than x2 if the character value of x1 at this position follows the value of x2 in the collating
21    sequence.

           NOTE 7.29

           The collating sequence depends partially on the processor; however, the result of the use of the
           operators .EQ., .NE., ==, and /= does not depend on the collating sequence.

           For nondefault character types, the blank padding character is processor dependent.


22    7.2.4        Logical intrinsic operations

23    A logical operation is used to express a logical computation. Evaluation of a logical operation produces
24    a result of type logical. The permitted types for operands of the logical intrinsic operations are specified
25    in 7.1.2.




      SEP 2002                                          WORKING DRAFT                                           135


     J3/02-007R3                                       WORKING DRAFT                                                        SEP 2002



1    The logical operators and their interpretation when used to form an expression are given in Table 7.5,
2    where x1 denotes the operand to the left of the operator and x2 denotes the operand to the right of the
3    operator.


                               Table 7.5: Interpretation of the logical intrinsic operators
        Operator           Representing                           Use of operator         Interpretation

        .NOT.              Logical negation                       .NOT. x2                True if x2 is false
        .AND.              Logical conjunction                    x1 .AND. x2             True if x1 and x2 are both true
        .OR.               Logical inclusive disjunction          x1 .OR. x2              True if x1 and/or x2 is true
                                                                                          True if either x
        .NEQV.             Logical nonequivalence                 x                                          1 or x2 is true, but
                                                                   1 .NEQV. x2            not both
                                                                                          True if both x
        .EQV.              Logical equivalence                    x                                         1 and x2 are true or
                                                                   1 .EQV. x2             both are false



4    The values of the logical intrinsic operations are shown in Table 7.6.


                    Table 7.6: The values of operations involving logical intrinsic operators
                   x1        x2        .NOT. x2    x1 .AND. x2         x1 .OR. x2       x1 .EQV. x2     x1 .NEQV. x2

                  true      true         false        true                 true             true                   false
                  true      false         true        false                true            false                   true
                  false     true         false        false                true            false                   true
                  false     false         true        false               false             true                   false




5    7.3        Precedence of operators

6    There is a precedence among the intrinsic and extension operations corresponding to the form of expres-
7    sions specified in 7.1.1, which determines the order in which the operands are combined unless the order
8    is changed by the use of parentheses. This precedence order is summarized in Table 7.7.


                              Table 7.7: Categories of operations and relative precedence
                           Category of operation                        Operators                     Precedence

                                     Extension                    defined-unary-op                      Highest
                                     Numeric                                **                                .
                                     Numeric                              * or /                              .
                                     Numeric                           unary + or �                           .
                                     Numeric                           binary + or �                          .
                                     Character                              //                                .
                                     Relational       .EQ., .NE., .LT., .LE., .GT., .GE.,
                                                               ==, /=, <, <=, >, >=                           .
                                      Logical                             .NOT.                               .
                                      Logical                             .AND.                               .
                                      Logical                              .OR.                               .
                                      Logical                    .EQV. or .NEQV.                              .
                                     Extension                    defined-binary-op                     Lowest



9    The precedence of a defined operation is that of its operator.





     136                                           WORKING DRAFT                                                            SEP 2002


     SEP 2002                                WORKING DRAFT                                    J3/02-007R3



         NOTE 7.30

         For example, in the expression


             -A ** 2


         the exponentiation operator (**) has precedence over the negation operator (�); therefore, the
         operands of the exponentiation operator are combined to form an expression that is used as the
         operand of the negation operator. The interpretation of the above expression is the same as the
         interpretation of the expression


             - (A ** 2)



1    The general form of an expression (7.1.1) also establishes a precedence among operators in the same
2    syntactic class. This precedence determines the order in which the operands are to be combined in
3    determining the interpretation of the expression unless the order is changed by the use of parentheses.

         NOTE 7.31

         In interpreting a level-2-expr containing two or more binary operators + or �, each operand (add-
         operand ) is combined from left to right. Similarly, the same left-to-right interpretation for a mult-
         operand in add-operand , as well as for other kinds of expressions, is a consequence of the general
         form.    However, for interpreting a mult-operand expression when two or more exponentiation
         operators ** combine level-1-expr operands, each level-1-expr is combined from right to left.

         For example, the expressions


             2.1 + 3.4 + 4.9
             2.1 * 3.4 * 4.9
             2.1 / 3.4 / 4.9
             2 ** 3 ** 4
             'AB' // 'CD' // 'EF'


         have the same interpretations as the expressions


             (2.1 + 3.4) + 4.9
             (2.1 * 3.4) * 4.9
             (2.1 / 3.4) / 4.9
             2 ** (3 ** 4)
             ('AB' // 'CD') // 'EF'


         As a consequence of the general form (7.1.1), only the first add-operand of a level-2-expr may
         be preceded by the identity (+) or negation (�) operator. These formation rules do not permit
         expressions containing two consecutive numeric operators, such as A ** �B or A + �B. However,
         expressions such as A ** (�B) and A + (�B) are permitted. The rules do allow a binary operator
         or an intrinsic unary operator to be followed by a defined unary operator, such as:


             A * .INVERSE. B
             - .INVERSE. (B)


         As another example, in the expression


             A .OR. B .AND. C





     SEP 2002                                     WORKING DRAFT                                            137


      J3/02-007R3                                    WORKING DRAFT                                     SEP 2002



             NOTE 7.31 (cont.)

             the general form implies a higher precedence for the .AND. operator than for the .OR. opera-
             tor; therefore, the interpretation of the above expression is the same as the interpretation of the
             expression


                   A .OR. (B .AND. C)



             NOTE 7.32

             An expression may contain more than one category of operator. The logical expression


                   L .OR. A + B >= C


             where A, B, and C are of type real, and L is of type logical, contains a numeric operator, a relational
             operator, and a logical operator. This expression would be interpreted the same as the expression


                   L .OR. ((A + B) >= C)



             NOTE 7.33

             If

                     (1)    The operator ** is extended to type logical,

                     (2)    The operator .STARSTAR. is defined to duplicate the function of ** on type real,

                     (3)    .MINUS. is defined to duplicate the unary operator �, and

                     (4)    L1 and L2 are type logical and X and Y are type real,


             then in precedence: L1 ** L2 is higher than X * Y; X * Y is higher than X .STARSTAR. Y; and
             .MINUS. X is higher than �X.



 1    7.4          Assignment

 2    Execution of an assignment statement causes a variable to become defined or redefined. Execution of a
 3    pointer assignment statement causes a pointer to become associated with a target or causes its pointer
 4    association status to become disassociated or undefined. Execution of a WHERE statement or WHERE
 5    construct masks the evaluation of expressions and assignment of values in array assignment statements
 6    according to the value of a logical array expression. Execution of a FORALL statement or FORALL
 7    construct controls the assignment to elements of arrays by using a set of index variables and a mask
 8    expression.


 9    7.4.1        Assignment statement

10    A variable may be defined or redefined by execution of an assignment statement.


11    7.4.1.1       General form

12    R734         assignment-stmt             is    variable = expr

13    C715         (R734) The variable in an assignment-stmt shall not be a whole assumed-size array.





      138                                    WORKING DRAFT                                             SEP 2002


      SEP 2002                                 WORKING DRAFT                                      J3/02-007R3



           NOTE 7.34

           Examples of an assignment statement are:


                 A = 3.5 + X * Y
                 I = INT (A)



 1    An assignment-stmt shall meet the requirements of either a defined assignment statement or an intrinsic
 2    assignment statement.


 3    7.4.1.2      Intrinsic assignment statement

 4    An intrinsic assignment statement is an assignment statement that is not a defined assignment
 5    statement (7.4.1.4). In an intrinsic assignment statement, variable shall not be polymorphic, and

 6          (1)      If expr is an array then variable shall also be an array,

 7          (2)      The shape of variable and expr shall conform, and

 8          (3)      The declared types of variable and expr shall conform as specified in Table 7.8.


 9                    Table 7.8: Type conformance for the intrinsic assignment statement
                        Type of variable                          Type of expr

                            integer                           integer, real, complex
                              real                            integer, real, complex
                            complex                           integer, real, complex
                           character        character of the same kind type parameter as variable
                             logical                                 logical
                          derived type       same derived type and type parameters as variable



10    A numeric intrinsic assignment statement is an intrinsic assignment statement for which variable
11    and expr are of numeric type. A character intrinsic assignment statement is an intrinsic assign-
12    ment statement for which variable and expr are of type character. A logical intrinsic assignment
13    statement is an intrinsic assignment statement for which variable and expr are of type logical. A
14    derived-type intrinsic assignment statement is an intrinsic assignment statement for which vari-
15    able and expr are of derived type.

16    An array intrinsic assignment statement is an intrinsic assignment statement for which variable is
17    an array. The variable shall not be a many-one array section (6.2.2.3.2).

18    If variable is a pointer, it shall be associated with a definable target such that the type, type parameters,
19    and shape of the target and expr conform.


20    7.4.1.3      Interpretation of intrinsic assignments

21    Execution of an intrinsic assignment causes, in effect, the evaluation of the expression expr and all
22    expressions within variable (7.1.8), the possible conversion of expr to the type and type parameters
23    of variable (Table 7.9), and the definition of variable with the resulting value. The execution of the
24    assignment shall have the same effect as if the evaluation of all operations in expr and variable occurred
25    before any portion of variable is defined by the assignment. The evaluation of expressions within variable
26    shall neither affect nor be affected by the evaluation of expr . No value is assigned to variable if variable
27    is of type character and zero length, or is an array of size zero.

28    If variable is a pointer, the value of expr is assigned to the target of variable.

29    Both variable and expr may contain references to any portion of variable.




      SEP 2002                                       WORKING DRAFT                                           139


      J3/02-007R3                                   WORKING DRAFT                                    SEP 2002



             NOTE 7.35

             For example, in the character intrinsic assignment statement:


                STRING (2:5) = STRING (1:4)


             the assignment of the first character of STRING to the second character does not affect the
             evaluation of STRING (1:4). If the value of STRING prior to the assignment was 'ABCDEF', the
             value following the assignment is 'AABCDF'.


 1    If expr in an intrinsic assignment is a scalar and variable is an array, the expr is treated as if it were an
 2    array of the same shape as variable with every element of the array equal to the scalar value of expr .

 3    If variable in an intrinsic assignment is an array, the assignment is performed element-by-element on
 4    corresponding array elements of variable and expr .

             NOTE 7.36

             For example, if A and B are arrays of the same shape, the array intrinsic assignment


                A = B


             assigns the corresponding elements of B to those of A; that is, the first element of B is assigned to
             the first element of A, the second element of B is assigned to the second element of A, etc.


 5    The processor may perform the element-by-element assignment in any order.

             NOTE 7.37

             For example, the following program segment results in the values of the elements of array X being
             reversed:


                REAL X (10)
                    ...
                X (1:10) = X (10:1:-1)



 6    For a numeric intrinsic assignment statement, variable and expr may have different numeric types or
 7    different kind type parameters, in which case the value of expr is converted to the type and kind type
 8    parameter of variable according to the rules of Table 7.9.


                           Table 7.9: Numeric conversion and the assignment statement
                             Type of variable    Value Assigned

                             integer             INT (expr , KIND = KIND (variable))
                             real                REAL (expr , KIND = KIND (variable))
                             complex             CMPLX (expr , KIND = KIND (variable))
                             Note: The functions INT, REAL, CMPLX, and KIND are the
                                     generic functions defined in 13.7.



 9    For a logical intrinsic assignment statement, variable and expr may have different kind type parameters,
10    in which case the value of expr is converted to the kind type parameter of variable.

11    For a character intrinsic assignment statement, variable and expr shall have the same kind type parameter
12    value, but may have different character length parameters in which case the conversion of expr to the
13    length of variable is as follows:




      140                                     WORKING DRAFT                                          SEP 2002


      SEP 2002                                 WORKING DRAFT                                     J3/02-007R3



 1          (1)      If the length of variable is less than that of expr , the value of expr is truncated from the
 2                   right until it is the same length as variable.

 3          (2)      If the length of variable is greater than that of expr , the value of expr is extended on the
 4                   right with blanks until it is the same length as variable.

           NOTE 7.38

          For nondefault character types, the blank padding character is processor dependent.


 5    A derived-type intrinsic assignment is performed as if each component of variable were assigned from
 6    the corresponding component of expr using pointer assignment (7.4.2) for each pointer component,
 7    defined assignment for each nonpointer nonallocatable component of a type that has a type-bound
 8    defined assignment consistent with the component, and intrinsic assignment for each other nonpointer
 9    nonallocatable component. For an allocatable component the following sequence of operations is applied:

10          (1)      If the component of variable is allocated, it is deallocated.

11          (2)      If the component of expr is allocated, the corresponding component of variable is allocated
12                   with the same dynamic type and type parameters as the component of expr . If it is an array,
13                   it is allocated with the same bounds. The value of the component of expr is then assigned
14                   to the corresponding component of variable using defined assignment if the declared type
15                   of the component has a type-bound defined assignment consistent with the component, and
16                   intrinsic assignment for the dynamic type of that component otherwise.

17    The processor may perform the component-by-component assignment in any order or by any means that
18    has the same effect.

           NOTE 7.39

          For an example of a derived-type intrinsic assignment statement, if C and D are of the same
          derived type with a pointer component P and nonpointer components S, T, U, and V of type
          integer, logical, character, and another derived type, respectively, the intrinsic


                 C = D


          pointer assigns D % P to C % P. It assigns D % S to C % S, D % T to C % T, and D % U to C % U
          using intrinsic assignment. It assigns D % V to C % V using defined assignment if objects of that
          type have a compatible type-bound defined assignment, and intrinsic assignment otherwise.


           NOTE 7.40

          If an allocatable component of expr is unallocated, the corresponding component of variable has
          an allocation status of unallocated after execution of the assignment.


19    When variable is a subobject, the assignment does not affect the definition status or value of other parts
20    of the object. For example, if variable is an array section, the assignment does not affect the definition
21    status or value of the elements of the array not specified by the array section.


22    7.4.1.4      Defined assignment statement

23    A defined assignment statement is an assignment statement that is defined by a subroutine and a
24    generic interface (4.5.1, 12.3.2.1.2) that specifies ASSIGNMENT (=). A defined elemental assign-
25    ment statement is a defined assignment statement for which the subroutine is elemental (12.7).

26    A subroutine defines the defined assignment x1 = x2 if

27          (1)      The subroutine is specified with a SUBROUTINE (12.5.2.2) or ENTRY (12.5.2.4) statement
28                   that specifies two dummy arguments, d1 and d2,



      SEP 2002                                       WORKING DRAFT                                           141


      J3/02-007R3                                         WORKING DRAFT                                      SEP 2002



 1            (2)      Either

 2                     (a)    A generic interface (12.3.2.1) provides the subroutine with a generic-spec of ASSIGN-
 3                            MENT (=), or

 4                     (b)    There is a type-bound generic binding (4.5.1) in the declared type of x1 or x2 with
 5                            a generic-spec of ASSIGNMENT (=) and there is a corresponding binding to the
 6                            subroutine in the dynamic type of x1 or x2, respectively,

 7            (3)      The types of d1 and d2 are compatible with the dynamic types of x1 and x2, respectively,
 8            (4)      The type parameters, if any, of d1 and d2 match the corresponding type parameters of x1
 9                     and x2, respectively, and
10            (5)      Either

11                     (a)    The ranks of x1 and x2 match those of d1 and d2 or
12                     (b)    The subroutine is elemental, x1 and x2 are conformable, and there is no other sub-
13                            routine that defines the operation.


14    If d1 or d2 is an array, the shapes of x1 and x2 shall match the shapes of d1 and d2, respectively.

15    The types of x1 and x2 shall not both be numeric, both be logical, or both be character with the same
16    kind type parameter value.


17    7.4.1.5        Interpretation of defined assignment statements

18    The interpretation of a defined assignment is provided by the subroutine that defines it.

19    If the defined assignment is an elemental assignment and the variable in the assignment is an array, the
20    defined assignment is performed element-by-element, in any order, on corresponding elements of variable
21    and expr . If expr is a scalar, it is treated as if it were an array of the same shape as variable with every
22    element of the array equal to the scalar value of expr .

             NOTE 7.41

             The rules of defined assignment (12.3.2.1.2), procedure references (12.4), subroutine references
             (12.4.3), and elemental subroutine arguments (12.7.3) ensure that the defined assignment has the
             same effect as if the evaluation of all operations in x2 and x1 occurs before any portion of x1 is
             defined.


23    7.4.2          Pointer assignment

24    Pointer assignment causes a pointer to become associated with a target or causes its pointer association
25    status to become disassociated or undefined. Any previous association between the pointer and a target
26    is broken.

27    Pointer assignment for a pointer component of a structure may also take place by execution of a derived-
28    type intrinsic assignment statement (7.4.1.3).

29    A pointer may also become associated with a target by allocation of the pointer.

30    R735       pointer-assignment-stmt            is    data-pointer-object [ (bounds-spec-list ) ] => data-target
31                                                  or data-pointer-object (bounds-remapping-list ) => data-target
32                                                  or proc-pointer-object => proc-target
33    R736       data-pointer-object                is    variable-name
34                                                  or variable % data-pointer-component-name

35    C716       (R735) If data-target is polymorphic (5.1.1.8), data-pointer-object shall be polymorphic.





      142                                     WORKING DRAFT                                                  SEP 2002


      SEP 2002                                    WORKING DRAFT                                   J3/02-007R3



 1    C717       (R735) A data-pointer-object shall be type compatible (5.1.1.8) with data-target , and the corre-
 2               sponding kind type parameters shall be equal.

 3    C718       (R735) If bounds-spec-list is specified, the number of bounds-specs shall equal the rank of data-
 4               pointer-object .

 5    C719       (R735) If bounds-remapping-list is specified, the number of bounds-remappings shall equal the
 6               rank of data-pointer-object .

 7    C720       (R735) If bounds-remapping-list is specified, data-target shall have rank one; otherwise, the
 8               ranks of data-pointer-object and data-target shall be the same.

 9    C721       (R736) A variable-name shall have the POINTER attribute.

10    C722       (R736) A data-pointer-component-name shall be the name of a component of variable that is a
11               data pointer.

12    R737       bounds-spec                      is    lower-bound :
13    R738       bounds-remapping                 is    lower-bound : upper-bound
14    R739       data-target                      is    variable
15                                                or expr

16    C723       (R739) A variable shall have either the TARGET or POINTER attribute, and shall not be an
17               array section with a vector subscript.

18    C724       (R739) An expr shall be a reference to a function whose result is a data pointer.

19    R740       proc-pointer-object              is    proc-pointer-name
20                                                or variable % procedure-component-name

21    C725       (R740) A procedure-component-name shall be the name of a procedure pointer component of
22               variable.

23    R741       proc-target                      is    expr
24                                                or procedure-name

25    C726       (R741) An expr shall be a reference to a function whose result is a procedure pointer.

26    C727       (R741) A procedure-name shall be the name of an external, module, or dummy procedure, a
27               specific intrinsic function listed in 13.6 and not marked with a bullet (�), or a procedure pointer.

28    C728       (R741) The proc-target shall not be a nonintrinsic elemental procedure.


29    7.4.2.1     Data pointer assignment

30    If data-target is not a pointer, data-pointer-object becomes pointer associated with data-target . Other-
31    wise, the pointer association status of data-pointer-object becomes that of data-target ; if data-target is
32    associated with an object, data-pointer-object becomes associated with the same object. If data-target
33    is allocatable, it shall be allocated.

34    If data-pointer-object is polymorphic (5.1.1.8), it assumes the dynamic type of data-target .

35    If data-target is a disassociated pointer, all nondeferred type parameters of the declared type of data-
36    pointer-object that correspond to nondeferred type parameters of data-target shall have the same values
37    as the corresponding type parameters of data-target . Otherwise, all nondeferred type parameters of the
38    declared type of data-pointer-object shall have the same values as the corresponding type parameters of
39    data-target .





      SEP 2002                                           WORKING DRAFT                                         143


      J3/02-007R3                                 WORKING DRAFT                                        SEP 2002



 1    If pointer-object has nondeferred type parameters that correspond to deferred type parameters of data-
 2    target , data-target shall not be a pointer with undefined association status.

 3    If bounds-remapping-list is specified, data-target shall not be a disassociated or undefined pointer, and
 4    the size of data-target shall not be less than the size of data-pointer-object . The elements of the target
 5    of data-pointer-object , in array element order (6.2.2.2), are the first SIZE(pointer-object ) elements of
 6    data-target .

 7    If no bounds-remapping-list is specified, the extent of a dimension of data-pointer-object is the extent of
 8    the corresponding dimension of data-target . If bounds-spec-list is present, it specifies the lower bounds;
 9    otherwise, the lower bound of each dimension is the result of the intrinsic function LBOUND (13.7.58)
10    applied to the corresponding dimension of data-target . The upper bound of each dimension is one less
11    than the sum of the lower bound and the extent.


12    7.4.2.2    Procedure pointer assignment

13    If the proc-target is not a pointer, proc-pointer-object becomes pointer associated with proc-target . Other-
14    wise, the pointer association status of proc-pointer-object becomes that of proc-target ; if proc-target is
15    associated with a procedure, proc-pointer-object becomes associated with the same procedure.

16    If proc-pointer-object has an explicit interface, its characteristics shall be the same as proc-target except
17    that proc-target may be pure even if proc-pointer-object is not pure and proc-target may be an elemental
18    intrinsic procedure even if proc-pointer-object is not elemental.

19    If the characteristics of proc-pointer-object or proc-target are such that an explicit interface is required,
20    both proc-pointer-object and proc-target shall have an explicit interface.

21    If proc-pointer-object has an implicit interface and is explicitly typed or referenced as a function, proc-
22    target shall be a function. If proc-pointer-object has an implicit interface and is referenced as a subroutine,
23    proc-target shall be a subroutine.

24    If proc-target and proc-pointer-object are functions, they shall have the same type; corresponding type
25    parameters shall either both be deferred or both have the same value.

26    If procedure-name is a specific procedure name that is also a generic name, only the specific procedure
27    is associated with pointer-object.


28    7.4.2.3    Examples


             NOTE 7.42

             The following are examples of pointer assignment statements. (See Note 12.14 for declarations of
             P and BESSEL.)


                 NEW_NODE % LEFT => CURRENT_NODE
                 SIMPLE_NAME => TARGET_STRUCTURE % SUBSTRUCT % COMPONENT
                 PTR => NULL ( )
                 ROW => MAT2D (N, :)
                 WINDOW => MAT2D (I-1:I+1, J-1:J+1)
                 POINTER_OBJECT => POINTER_FUNCTION (ARG_1, ARG_2)
                 EVERY_OTHER => VECTOR (1:N:2)
                 WINDOW2 (0:, 0:) => MAT2D (ML:MU, NL:NU)
                 ! P is a procedure pointer and BESSEL is a procedure with a
                 ! compatible interface.
                 P => BESSEL





      144                                   WORKING DRAFT                                              SEP 2002


      SEP 2002                               WORKING DRAFT                                       J3/02-007R3



          NOTE 7.42 (cont.)


                 ! Likewise for a structure component.
                 STRUCT % COMPONENT => BESSEL



          NOTE 7.43

          It is possible to obtain high-rank views of (parts of) rank-one objects by specifying upper bounds
          in pointer assignment statements. Consider the following example, in which a matrix is under
          consideration. The matrix is stored as a rank-one object in MYDATA because its diagonal is needed
          for some reason � the diagonal cannot be gotten as a single object from a rank-two representation.
          The matrix is represented as a rank-two view of MYDATA.


          real, target :: MYDATA ( NR*NC )                 ! An automatic array
          real, pointer :: MATRIX ( :, : )                 ! A rank-two view of MYDATA
          real, pointer :: VIEW_DIAG ( : )
          MATRIX( 1:NR, 1:NC ) => MYDATA                   ! The MATRIX view of the data
          VIEW_DIAG => MYDATA( 1::NR+1 )                   ! The diagonal of MATRIX


          Rows, columns, or blocks of the matrix can be accessed as sections of MATRIX.


 1    7.4.3      Masked array assignment � WHERE

 2    The masked array assignment is used to mask the evaluation of expressions and assignment of values in
 3    array assignment statements, according to the value of a logical array expression.


 4    7.4.3.1     General form of the masked array assignment

 5    A masked array assignment is either a WHERE statement or a WHERE construct.

 6    R742       where-stmt                  is    WHERE ( mask-expr ) where-assignment-stmt
 7    R743       where-construct             is    where-construct-stmt
 8                                                         [ where-body-construct ] ...
 9                                                     [ masked-elsewhere-stmt
10                                                         [ where-body-construct ] ... ] ...
11                                                     [ elsewhere-stmt
12                                                         [ where-body-construct ] ... ]
13                                                     end-where-stmt
14    R744       where-construct-stmt        is    [where-construct-name:] WHERE ( mask-expr )
15    R745       where-body-construct        is    where-assignment-stmt
16                                           or where-stmt
17                                           or where-construct
18    R746       where-assignment-stmt       is    assignment-stmt
19    R747       mask-expr                   is    logical-expr
20    R748       masked-elsewhere-stmt       is    ELSEWHERE (mask-expr ) [where-construct-name]
21    R749       elsewhere-stmt              is    ELSEWHERE [where-construct-name]
22    R750       end-where-stmt              is    END WHERE [where-construct-name]

23    C729       (R746) A where-assignment-stmt that is a defined assignment shall be elemental.

24    C730       (R743) If the where-construct-stmt is identified by a where-construct-name, the corresponding
25               end-where-stmt shall specify the same where-construct-name. If the where-construct-stmt is
26               not identified by a where-construct-name, the corresponding end-where-stmt shall not specify
27               a where-construct-name. If an elsewhere-stmt or a masked-elsewhere-stmt is identified by a
28               where-construct-name, the corresponding where-construct-stmt shall specify the same where-



      SEP 2002                                      WORKING DRAFT                                       145


      J3/02-007R3                                  WORKING DRAFT                                     SEP 2002



 1               construct-name.

 2    C731       (R745) A statement that is part of a where-body-construct shall not be a branch target statement.

 3    If a where-construct contains a where-stmt , a masked-elsewhere-stmt , or another where-construct then
 4    each mask-expr within the where-construct shall have the same shape. In each where-assignment-stmt ,
 5    the mask-expr and the variable being defined shall be arrays of the same shape.

             NOTE 7.44

             Examples of a masked array assignment are:


                 WHERE (TEMP > 100.0) TEMP = TEMP - REDUCE_TEMP
                 WHERE (PRESSURE <= 1.0)
                       PRESSURE = PRESSURE + INC_PRESSURE
                       TEMP = TEMP - 5.0
                 ELSEWHERE
                       RAINING = .TRUE.
                 END WHERE



 6    7.4.3.2        Interpretation of masked array assignments

 7    When a WHERE statement or a where-construct-stmt is executed, a control mask is established. In
 8    addition, when a WHERE construct statement is executed, a pending control mask is established. If
 9    the statement does not appear as part of a where-body-construct , the mask-expr of the statement is
10    evaluated, and the control mask is established to be the value of mask-expr . The pending control mask
11    is established to have the value .NOT. mask-expr upon execution of a WHERE construct statement that
12    does not appear as part of a where-body-construct . The mask-expr is evaluated only once.

13    Each statement in a WHERE construct is executed in sequence.

14    Upon execution of a masked-elsewhere-stmt , the following actions take place in sequence:

15            (1)      The control mask mc is established to have the value of the pending control mask.
16            (2)      The pending control mask is established to have the value mc .AND. (.NOT. mask-expr ).
17            (3)      The control mask mc is established to have the value mc .AND. mask-expr .

18    The mask-expr is evaluated only once.

19    Upon execution of an ELSEWHERE statement, the control mask is established to have the value of the
20    pending control mask. No new pending control mask value is established.

21    Upon execution of an ENDWHERE statement, the control mask and pending control mask are es-
22    tablished to have the values they had prior to the execution of the corresponding WHERE construct
23    statement. Following the execution of a WHERE statement that appears as a where-body-construct , the
24    control mask is established to have the value it had prior to the execution of the WHERE statement.

             NOTE 7.45

             The establishment of control masks and the pending control mask is illustrated with the following
             example:


                 WHERE(cond1)               ! Statement 1
                 . . .
                 ELSEWHERE(cond2)           ! Statement 2
                 . . .





      146                                    WORKING DRAFT                                           SEP 2002


      SEP 2002                              WORKING DRAFT                                      J3/02-007R3



           NOTE 7.45 (cont.)

               ELSEWHERE                ! Statement 3
               . . .
               END WHERE


           Following execution of statement 1, the control mask has the value cond1 and the pending
           control mask has the value .NOT. cond1.         Following execution of statement 2, the control
           mask has the value (.NOT. cond1) .AND. cond2 and the pending control mask has the value
           (.NOT. cond1) .AND. (.NOT. cond2). Following execution of statement 3, the control mask has
           the value (.NOT. cond1) .AND. (.NOT. cond2). The false condition values are propagated through
           the execution of the masked ELSEWHERE statement.


 1    Upon execution of a WHERE construct statement that is part of a where-body-construct , the pending
 2    control mask is established to have the value mc .AND. (.NOT. mask-expr ). The control mask is then
 3    established to have the value mc .AND. mask-expr . The mask-expr is evaluated only once.

 4    Upon execution of a WHERE statement that is part of a where-body-construct , the control mask is
 5    established to have the value mc .AND. mask-expr . The pending mask is not altered.

 6    If a nonelemental function reference occurs in the expr or variable of a where-assignment-stmt or in a
 7    mask-expr , the function is evaluated without any masked control; that is, all of its argument expressions
 8    are fully evaluated and the function is fully evaluated. If the result is an array and the reference is not
 9    within the argument list of a nonelemental function, elements corresponding to true values in the control
10    mask are selected for use in evaluating the expr , variable or mask-expr .

11    If an elemental operation or function reference occurs in the expr or variable of a where-assignment-stmt
12    or in a mask-expr , and is not within the argument list of a nonelemental function reference, the operation
13    is performed or the function is evaluated only for the elements corresponding to true values of the control
14    mask.

15    If an array constructor appears in a where-assignment-stmt or in a mask-expr , the array constructor is
16    evaluated without any masked control and then the where-assignment-stmt is executed or the mask-expr
17    is evaluated.

18    When a where-assignment-stmt is executed, the values of expr that correspond to true values of the
19    control mask are assigned to the corresponding elements of variable.

20    The value of the control mask is established by the execution of a WHERE statement, a WHERE con-
21    struct statement, an ELSEWHERE statement, a masked ELSEWHERE statement, or an ENDWHERE
22    statement. Subsequent changes to the value of entities in a mask-expr have no effect on the value of the
23    control mask. The execution of a function reference in the mask expression of a WHERE statement is
24    permitted to affect entities in the assignment statement.

           NOTE 7.46

           Examples of function references in masked array assignments are:


               WHERE (A > 0.0)
               A = LOG (A)                 ! LOG is invoked only for positive elements.
               A = A / SUM (LOG (A))       ! LOG is invoked for all elements
                                           ! because SUM is transformational.
               END WHERE





      SEP 2002                                    WORKING DRAFT                                             147


      J3/02-007R3                                    WORKING DRAFT                                        SEP 2002



 1    7.4.4       FORALL

 2    FORALL constructs and statements are used to control the execution of assignment and pointer assign-
 3    ment statements with selection by sets of index values and an optional mask expression.


 4    7.4.4.1     The FORALL Construct

 5    The FORALL construct allows multiple assignments, masked array (WHERE) assignments, and nested
 6    FORALL constructs and statements to be controlled by a single forall-triplet-spec-list and scalar-mask-
 7    expr .

 8    R751       forall-construct              is    forall-construct-stmt
 9                                                        [forall-body-construct ] ...
10                                                        end-forall-stmt
11    R752       forall-construct-stmt         is    [forall-construct-name :] FORALL forall-header
12    R753       forall-header                 is    (forall-triplet-spec-list [, scalar-mask-expr ] )
13    R754       forall-triplet-spec           is    index-name = subscript : subscript [ : stride]
14    R618       subscript                     is    scalar-int-expr
15    R621       stride                        is    scalar-int-expr
16    R755       forall-body-construct         is    forall-assignment-stmt
17                                             or where-stmt
18                                             or where-construct
19                                             or forall-construct
20                                             or forall-stmt
21    R756       forall-assignment-stmt        is    assignment-stmt
22                                             or pointer-assignment-stmt
23    R757       end-forall-stmt               is    END FORALL [forall-construct-name ]

24    C732       (R757) If the forall-construct-stmt has a forall-construct-name, the end-forall-stmt shall have
25               the same forall-construct-name. If the end-forall-stmt has a forall-construct-name, the forall-
26               construct-stmt shall have the same forall-construct-name.

27    C733       (R753) The scalar-mask-expr shall be scalar and of type logical.

28    C734       (R753) Any procedure referenced in the scalar-mask-expr , including one referenced by a defined
29               operation, shall be a pure procedure (12.6).

30    C735       (R754) The index-name shall be a named scalar variable of type integer.

31    C736       (R754) A subscript or stride in a forall-triplet-spec shall not contain a reference to any index-
32               name in the forall-triplet-spec-list in which it appears.

33    C737       (R755) A statement in a forall-body-construct shall not define an index-name of the forall-
34               construct .

35    C738       (R755) Any procedure referenced in a forall-body-construct , including one referenced by a defined
36               operation, assignment, or finalization, shall be a pure procedure.

37    C739       (R755) A forall-body-construct shall not be a branch target.

             NOTE 7.47

             An example of a FORALL construct is:


                 REAL :: A(10, 10), B(10, 10) = 1.0
                 . . .





      148                                    WORKING DRAFT                                                SEP 2002


     SEP 2002                             WORKING DRAFT                                      J3/02-007R3



          NOTE 7.47 (cont.)

             FORALL (I = 1:10, J = 1:10, B(I, J) /= 0.0)
                 A(I, J) = REAL (I + J - 2)
                 B(I, J) = A(I, J) + B(I, J) * REAL (I * J)
             END FORALL



          NOTE 7.48

         An assignment statement that is a FORALL body construct may be a scalar or array assignment
         statement, or a defined assignment statement. The variable being defined will normally use each
         index name in the forall-triplet-spec-list. For example


             FORALL (I = 1:N, J = 1:N)
                 A(:, I, :, J) = 1.0 / REAL(I + J - 1)
             END FORALL


         broadcasts scalar values to rank-two subarrays of A.


          NOTE 7.49

         An example of a FORALL construct containing a pointer assignment statement is:


             TYPE ELEMENT
                 REAL ELEMENT_WT
                 CHARACTER (32), POINTER :: NAME
             END TYPE ELEMENT
             TYPE(ELEMENT) CHART(200)
             REAL WEIGHTS (1000)
             CHARACTER (32), TARGET :: NAMES (1000)
             . . .
             FORALL (I = 1:200, WEIGHTS (I + N - 1) > .5)
                 CHART(I) % ELEMENT_WT = WEIGHTS (I + N - 1)
                 CHART(I) % NAME => NAMES (I + N - 1)
             END FORALL


         The results of this FORALL construct cannot be achieved with a WHERE construct because a
         pointer assignment statement is not permitted in a WHERE construct.


1    An index-name in a forall-construct has a scope of the construct (16.3). It is a scalar variable that has
2    the type and type parameters that it would have if it were the name of a variable in the scoping unit
3    that includes the FORALL, and this type shall be integer type; it has no other attributes.

          NOTE 7.50

         The use of index-name variables in a FORALL construct does not affect variables of the same
         name, for example:


             INTEGER :: X = -1
             REAL A(5, 4)
             J = 100
             . . .
             FORALL (X = 1:5, J = 1:4)
                 A (X, J) = J





     SEP 2002                                   WORKING DRAFT                                            149


      J3/02-007R3                                     WORKING DRAFT                                     SEP 2002



             NOTE 7.50 (cont.)

                 END FORALL


             After execution of the FORALL, the variables X and J have the values -1 and 100 and A has the
             value


                           1 2 3 4
                           1 2 3 4
                           1 2 3 4
                           1 2 3 4
                           1 2 3 4



 1    7.4.4.2        Execution of the FORALL construct

 2    There are three stages in the execution of a FORALL construct:

 3            (1)      Determination of the values for index-name variables,

 4            (2)      Evaluation of the scalar-mask-expr , and

 5            (3)      Execution of the FORALL body constructs.


 6    7.4.4.2.1       Determination of the values for index variables

 7    The subscript and stride expressions in the forall-triplet-spec-list are evaluated. These expressions may
 8    be evaluated in any order. The set of values that a particular index-name variable assumes is determined
 9    as follows:

10            (1)      The lower bound m1, the upper bound m2, and the stride m3 are of type integer with the
11                     same kind type parameter as the index-name. Their values are established by evaluating
12                     the first subscript, the second subscript, and the stride expressions, respectively, including,
13                     if necessary, conversion to the kind type parameter of the index-name according to the rules
14                     for numeric conversion (Table 7.9). If a stride does not appear, m3 has the value 1. The
15                     value m3 shall not be zero.
16            (2)      Let the value of max be (m2 - m1 + m3)/m3. If max  0 for some index-name, the execution
17                     of the construct is complete. Otherwise, the set of values for the index-name is

18                          m1 + (k - 1) � m3         where k = 1, 2, ..., max.

19    The set of combinations of index-name values is the Cartesian product of the sets defined by each triplet
20    specification. An index-name becomes defined when this set is evaluated.

             NOTE 7.51

             The stride may be positive or negative; the FORALL body constructs are executed as long as
             max > 0. For the forall-triplet-spec


                 I = 10:1:-1


             max has the value 10


21    7.4.4.2.2       Evaluation of the mask expression

22    The scalar-mask-expr , if any, is evaluated for each combination of index-name values. If the scalar-
23    mask-expr is not present, it is as if it were present with the value true. The index-name variables may
24    be primaries in the scalar-mask-expr .

25    The active combination of index-name values is defined to be the subset of all possible combinations



      150                                     WORKING DRAFT                                             SEP 2002


      SEP 2002                             WORKING DRAFT                                         J3/02-007R3



 1    (7.4.4.2.1) for which the scalar-mask-expr has the value true.

           NOTE 7.52

          The index-name variables may appear in the mask, for example


              FORALL (I=1:10, J=1:10, A(I) > 0.0 .AND. B(J) < 1.0)
              . . .



 2    7.4.4.2.3    Execution of the FORALL body constructs

 3    The forall-body-construct s are executed in the order in which they appear. Each construct is executed
 4    for all active combinations of the index-name values with the following interpretation:

 5    Execution of a forall-assignment-stmt that is an assignment-stmt causes the evaluation of expr and all
 6    expressions within variable for all active combinations of index-name values. These evaluations may be
 7    done in any order. After all these evaluations have been performed, each expr value is assigned to the
 8    corresponding variable. The assignments may occur in any order.

 9    Execution of a forall-assignment-stmt that is a pointer-assignment-stmt causes the evaluation of all
10    expressions within data-target and pointer-object , the determination of any pointers within pointer-
11    object , and the determination of the target for all active combinations of index-name values. These
12    evaluations may be done in any order. After all these evaluations have been performed, each pointer-
13    object is associated with the corresponding data-target . These associations may occur in any order.

14    In a forall-assignment-stmt , a defined assignment subroutine shall not reference any variable that be-
15    comes defined or pointer-object that becomes associated by the statement.

           NOTE 7.53

          The following FORALL construct contains two assignment statements. The assignment to array
          B uses the values of array A computed in the previous statement, not the values A had prior to
          execution of the FORALL.


              FORALL (I = 2:N-1, J = 2:N-1 )
                   A (I, J) = A(I, J-1) + A(I, J+1) + A(I-1, J) + A(I+1, J)
                   B (I, J) = 1.0 / A(I, J)
              END FORALL


          Computations that would otherwise cause error conditions can be avoided by using an appropriate
          scalar-mask-expr that limits the active combinations of the index-name values. For example:


              FORALL (I = 1:N, Y(I) /= 0.0)
                   X(I) = 1.0 / Y(I)
              END FORALL



16    Each statement in a where-construct (7.4.3) within a forall-construct is executed in sequence. When
17    a where-stmt , where-construct-stmt or masked-elsewhere-stmt is executed, the statement's mask-expr is
18    evaluated for all active combinations of index-name values as determined by the outer forall-construct s,
19    masked by any control mask corresponding to outer where-construct s. Any where-assignment-stmt is
20    executed for all active combinations of index-name values, masked by the control mask in effect for the
21    where-assignment-stmt .





      SEP 2002                                   WORKING DRAFT                                            151


     J3/02-007R3                                      WORKING DRAFT                                 SEP 2002



            NOTE 7.54

            This FORALL construct contains a WHERE statement and an assignment statement.


               INTEGER A(5,4), B(5,4)
               FORALL ( I = 1:5 )
                     WHERE ( A(I,:) == 0 ) A(I,:) = I
                     B (I,:) = I / A(I,:)
               END FORALL


            When executed with the input array


                          0     0    0    0
                          1     1    1    0
               A     =     2    2    0    2
                          1     0    2    3
                          0     0    0    0


            the results will be


                          1     1    1    1                 1    1    1    1
                          1     1    1    2                 2    2    2    1
               A     =     2    2    3    2      B     =    1    1    1    1
                          1     4    2    3                 4    1    2    1
                          5     5    5    5                 1    1    1    1


            For an example of a FORALL construct containing a WHERE construct with an ELSEWHERE
            statement, see C.4.5.


1    Execution of a forall-stmt or forall-construct causes the evaluation of the subscript and stride expressions
2    in the forall-triplet-spec-list for all active combinations of the index-name values of the outer FORALL
3    construct. The set of combinations of index-name values for the inner FORALL is the union of the sets
4    defined by these bounds and strides for each active combination of the outer index-name values; it also
5    includes the outer index-name values. The scalar-mask-expr is then evaluated for all combinations of the
6    index-name values of the inner construct to produce a set of active combinations for the inner construct.
7    If there is no scalar-mask-expr , it is as if it were present with the value .TRUE.. Each statement in the
8    inner FORALL is then executed for each active combination of the index-name values.

            NOTE 7.55

            This FORALL construct contains a nested FORALL construct. It assigns the transpose of the
            strict lower triangle of array A (the section below the main diagonal) to the strict upper triangle
            of A.


               INTEGER A (3, 3)
               FORALL (I = 1:N-1 )
                     FORALL ( J=I+1:N )
                          A(I,J) = A(J,I)
                     END FORALL
               END FORALL


            If prior to execution N = 3 and





     152                                       WORKING DRAFT                                        SEP 2002


      SEP 2002                              WORKING DRAFT                                      J3/02-007R3



           NOTE 7.55 (cont.)

                           0    3    6
                 A    =    1    4    7
                           2    5    8


           then after execution


                           0    1    2
                 A    =    1    4    5
                           2    5    8



 1    7.4.4.3     The FORALL statement

 2    The FORALL statement allows a single assignment statement or pointer assignment to be controlled by
 3    a set of index values and an optional mask expression.

 4    R758       forall-stmt                is    FORALL forall-header forall-assignment-stmt

 5    A FORALL statement is equivalent to a FORALL construct containing a single forall-body-construct
 6    that is a forall-assignment-stmt .

 7    The scope of an index-name in a forall-stmt is the statement itself (16.3).

           NOTE 7.56

           Examples of FORALL statements are:


                 FORALL (I=1:N) A(I,I) = X(I)


           This statement assigns the elements of vector X to the elements of the main diagonal of matrix A.


                 FORALL (I = 1:N, J = 1:N)        X(I,J) = 1.0 / REAL (I+J-1)


           Array element X(I,J) is assigned the value (1.0 / REAL (I+J-1)) for values of I and J between 1
           and N, inclusive.


                 FORALL (I=1:N, J=1:N, Y(I,J) /= 0 .AND. I /= J)           X(I,J) = 1.0 / Y(I,J)


           This statement takes the reciprocal of each nonzero off-diagonal element of array Y(1:N, 1:N)
           and assigns it to the corresponding element of array X. Elements of Y that are zero or on the
           diagonal do not participate, and no assignments are made to the corresponding elements of X. The
           results from the execution of the example in Note 7.55 could be obtained with a single FORALL
           statement:


                 FORALL ( I = 1:N-1, J=1:N, J > I )        A(I,J) = A(J,I)


           For more examples of FORALL statements, see C.4.6.


 8    7.4.4.4     Restrictions on FORALL constructs and statements

 9    A many-to-one assignment is more than one assignment to the same object, or association of more
10    than one target with the same pointer, whether the object is referenced directly or indirectly through a
11    pointer. A many-to-one assignment shall not occur within a single statement in a FORALL construct or
12    statement. It is possible to assign or pointer assign to the same object in different assignment statements



      SEP 2002                                     WORKING DRAFT                                           153


     J3/02-007R3                                  WORKING DRAFT                                 SEP 2002



1    in a FORALL construct.

            NOTE 7.57

            The appearance of each index-name in the identification of the left-hand side of an assignment
            statement is helpful in eliminating many-to-one assignments, but it is not sufficient to guarantee
            there will be none. For example, the following is allowed


               FORALL (I = 1:10)
                   A (INDEX (I)) = B(I)
               END FORALL


            if and only if INDEX(1:10) contains no repeated values.


2    Within the scope of a FORALL construct, a nested FORALL statement or FORALL construct shall
3    not have the same index-name. The forall-header expressions within a nested FORALL may depend on
4    the values of outer index-name variables.





     154                                  WORKING DRAFT                                         SEP 2002


      SEP 2002                                   WORKING DRAFT                                      J3/02-007R3





 1    Section 8: Execution control

 2    The execution sequence may be controlled by constructs containing blocks and by certain executable
 3    statements that are used to alter the execution sequence.


 4    8.1        Executable constructs containing blocks

 5    The following are executable constructs that contain blocks:

 6            (1)      ASSOCIATE construct

 7            (2)      CASE construct

 8            (3)      DO construct

 9            (4)      IF construct

10            (5)      SELECT TYPE construct


11    There is also a nonblock form of the DO construct.


12    A block is a sequence of executable constructs that is treated as a unit.

13    R801       block                           is    [ execution-part-construct ] ...

14    Executable constructs may be used to control which blocks of a program are executed or how many times
15    a block is executed. Blocks are always bounded by statements that are particular to the construct in
16    which they are embedded; however, in some forms of the DO construct, a sequence of executable constructs without

17    a terminating boundary statement shall obey all other rules governing blocks (8.1.1).


             NOTE 8.1

             A block need not contain any executable constructs. Execution of such a block has no effect.


18    Any of these constructs may be named. If a construct is named, the name shall be the first lexical token
19    of the first statement of the construct and the last lexical token of the construct. In fixed source form, the

20    name preceding the construct shall be placed after character position 6.


21    A statement belongs to the innermost construct in which it appears unless it contains a construct name,
22    in which case it belongs to the named construct.

             NOTE 8.2

             An example of a construct containing a block is:


             IF (A > 0.0) THEN
                 B = SQRT (A)          ! These two statements
                 C = LOG (A)           ! form a block.
             END IF



23    8.1.1          Rules governing blocks

24    8.1.1.1        Executable constructs in blocks

25    If a block contains an executable construct, the executable construct shall be entirely within the block.




      SEP 2002                                          WORKING DRAFT                                            155


      J3/02-007R3                                   WORKING DRAFT                                     SEP 2002



 1    8.1.1.2     Control flow in blocks

 2    Transfer of control to the interior of a block from outside the block is prohibited. Transfers within a
 3    block and transfers from the interior of a block to outside the block may occur.

 4    Subroutine and function references (12.4.2, 12.4.3) may appear in a block.


 5    8.1.1.3     Execution of a block

 6    Execution of a block begins with the execution of the first executable construct in the block. Execution
 7    of the block is completed when the last executable construct in the sequence is executed or when a
 8    branch out of the block takes place.

             NOTE 8.3

             The action that takes place at the terminal boundary depends on the particular construct and on
             the block within that construct. It is usually a transfer of control.


 9    8.1.2       IF construct

10    The IF construct selects for execution at most one of its constituent blocks. The selection is based
11    on a sequence of logical expressions. The IF statement controls the execution of a single statement
12    (8.1.2.4) based on a single logical expression.


13    8.1.2.1     Form of the IF construct

14    R802       if-construct                 is    if-then-stmt
15                                                           block
16                                                       [ else-if-stmt
17                                                           block ] ...
18                                                       [ else-stmt
19                                                           block ]
20                                                       end-if-stmt
21    R803       if-then-stmt                 is    [ if-construct-name : ] IF ( scalar-logical-expr ) THEN
22    R804       else-if-stmt                 is    ELSE IF ( scalar-logical-expr ) THEN [ if-construct-name ]
23    R805       else-stmt                    is    ELSE [ if-construct-name ]
24    R806       end-if-stmt                  is    END IF [ if-construct-name ]

25    C801       (R802) If the if-then-stmt of an if-construct specifies an if-construct-name, the corresponding
26               end-if-stmt shall specify the same if-construct-name. If the if-then-stmt of an if-construct does
27               not specify an if-construct-name, the corresponding end-if-stmt shall not specify an if-construct-
28               name. If an else-if-stmt or else-stmt specifies an if-construct-name, the corresponding if-then-
29               stmt shall specify the same if-construct-name.


30    8.1.2.2     Execution of an IF construct

31    At most one of the blocks in the IF construct is executed. If there is an ELSE statement in the construct,
32    exactly one of the blocks in the construct is executed. The scalar logical expressions are evaluated in
33    the order of their appearance in the construct until a true value is found or an ELSE statement or END
34    IF statement is encountered. If a true value or an ELSE statement is found, the block immediately
35    following is executed and this completes the execution of the construct. The scalar logical expressions
36    in any remaining ELSE IF statements of the IF construct are not evaluated. If none of the evaluated
37    expressions is true and there is no ELSE statement, the execution of the construct is completed without
38    the execution of any block within the construct.

39    An ELSE IF statement or an ELSE statement shall not be a branch target statement. It is permissible



      156                                   WORKING DRAFT                                             SEP 2002


      SEP 2002                                 WORKING DRAFT                                    J3/02-007R3



 1    to branch to an END IF statement only from within its IF construct. Execution of an END IF statement
 2    has no effect.


 3    8.1.2.3     Examples of IF constructs


          NOTE 8.4


          IF (CVAR == 'RESET') THEN
                 I = 0; J = 0; K = 0
          END IF
          PROOF_DONE: IF (PROP) THEN
                 WRITE (3, '(''QED'')')
                 STOP
          ELSE
                 PROP = NEXTPROP
          END IF PROOF_DONE
          IF (A > 0) THEN
                 B = C/A
                 IF (B > 0) THEN
                     D = 1.0
                 END IF
          ELSE IF (C > 0) THEN
                 B = A/C
                 D = -1.0
          ELSE
                 B = ABS (MAX (A, C))
                 D = 0
          END IF



 4    8.1.2.4     IF statement

 5    The IF statement controls a single action statement (R214).

 6    R807       if-stmt                       is    IF ( scalar-logical-expr ) action-stmt

 7    C802       (R807) The action-stmt in the if-stmt shall not be an if-stmt , end-program-stmt , end-function-
 8               stmt , or end-subroutine-stmt .

 9    Execution of an IF statement causes evaluation of the scalar logical expression. If the value of the
10    expression is true, the action statement is executed. If the value is false, the action statement is not
11    executed and execution continues.

12    The execution of a function reference in the scalar logical expression may affect entities in the action
13    statement.

          NOTE 8.5

          An example of an IF statement is:


          IF (A > 0.0) A = LOG (A)





      SEP 2002                                        WORKING DRAFT                                         157


      J3/02-007R3                                        WORKING DRAFT                                 SEP 2002


 1    8.1.3          CASE construct

 2    The CASE construct selects for execution at most one of its constituent blocks. The selection is
 3    based on the value of an expression.


 4    8.1.3.1        Form of the CASE construct

 5    R808       case-construct                    is    select-case-stmt
 6                                                           [ case-stmt
 7                                                               block ] ...
 8                                                           end-select-stmt
 9    R809       select-case-stmt                  is    [ case-construct-name : ] SELECT CASE ( case-expr )
10    R810       case-stmt                         is    CASE case-selector [case-construct-name]
11    R811       end-select-stmt                   is    END SELECT [ case-construct-name ]

12    C803       (R808) If the select-case-stmt of a case-construct specifies a case-construct-name, the corre-
13               sponding end-select-stmt shall specify the same case-construct-name. If the select-case-stmt
14               of a case-construct does not specify a case-construct-name, the corresponding end-select-stmt
15               shall not specify a case-construct-name. If a case-stmt specifies a case-construct-name, the
16               corresponding select-case-stmt shall specify the same case-construct-name.

17    R812       case-expr                         is    scalar-int-expr
18                                                 or scalar-char-expr
19                                                 or scalar-logical-expr
20    R813       case-selector                     is    ( case-value-range-list )
21                                                 or DEFAULT

22    C804       (R808) No more than one of the selectors of one of the CASE statements shall be DEFAULT.

23    R814       case-value-range                  is    case-value
24                                                 or case-value :
25                                                 or : case-value
26                                                 or case-value : case-value
27    R815       case-value                        is    scalar-int-initialization-expr
28                                                 or scalar-char-initialization-expr
29                                                 or scalar-logical-initialization-expr

30    C805       (R808) For a given case-construct , each case-value shall be of the same type as case-expr . For
31               character type, the kind type parameters shall be the same; character length differences are
32               allowed.

33    C806       (R808) A case-value-range using a colon shall not be used if case-expr is of type logical.

34    C807       (R808) For a given case-construct , the case-value-ranges shall not overlap; that is, there shall
35               be no possible value of the case-expr that matches more than one case-value-range.


36    8.1.3.2        Execution of a CASE construct

37    The execution of the SELECT CASE statement causes the case expression to be evaluated. The resulting
38    value is called the case index. For a case value range list, a match occurs if the case index matches any
39    of the case value ranges in the list. For a case index with a value of c, a match is determined as follows:

40            (1)      If the case value range contains a single value v without a colon, a match occurs for type
41                     logical if the expression c .EQV. v is true, and a match occurs for type integer or character
42                     if the expression c == v is true.

43            (2)      If the case value range is of the form low : high, a match occurs if the expression low <= c
44                     .AND. c <= high is true.



      158                                     WORKING DRAFT                                            SEP 2002


      SEP 2002                                    WORKING DRAFT                                       J3/02-007R3



 1          (3)         If the case value range is of the form low :, a match occurs if the expression low <= c is true.

 2          (4)         If the case value range is of the form : high, a match occurs if the expression c <= high is
 3                      true.

 4          (5)         If no other selector matches and a DEFAULT selector appears, it matches the case index.

 5          (6)         If no other selector matches and the DEFAULT selector does not appear, there is no match.

 6    The block following the CASE statement containing the matching selector, if any, is executed. This
 7    completes execution of the construct.

 8    At most one of the blocks of a CASE construct is executed.

 9    A CASE statement shall not be a branch target statement. It is permissible to branch to an end-select-
10    stmt only from within its CASE construct.


11    8.1.3.3      Examples of CASE constructs


          NOTE 8.6

          An integer signum function:


          INTEGER FUNCTION SIGNUM (N)
          SELECT CASE (N)
          CASE (:-1)
                 SIGNUM = -1
          CASE (0)
                 SIGNUM = 0
          CASE (1:)
                 SIGNUM = 1
          END SELECT
          END



          NOTE 8.7

          A code fragment to check for balanced parentheses:


          CHARACTER (80) :: LINE
                 ...
          LEVEL = 0
          SCAN_LINE: DO I = 1, 80
                 CHECK_PARENS: SELECT CASE (LINE (I:I))
                 CASE ('(')
                     LEVEL = LEVEL + 1
                 CASE (')')
                     LEVEL = LEVEL - 1
                     IF (LEVEL < 0) THEN
                           PRINT *, 'UNEXPECTED RIGHT PARENTHESIS'
                           EXIT SCAN_LINE
                     END IF
                 CASE DEFAULT
                     ! Ignore all other characters
                 END SELECT CHECK_PARENS
          END DO SCAN_LINE
          IF (LEVEL > 0) THEN





      SEP 2002                                          WORKING DRAFT                                              159


      J3/02-007R3                                  WORKING DRAFT                               SEP 2002



             NOTE 8.7 (cont.)

                 PRINT *, 'MISSING RIGHT PARENTHESIS'
             END IF



             NOTE 8.8

             The following three fragments are equivalent:


             IF (SILLY == 1) THEN
                 CALL THIS
             ELSE
                 CALL THAT
             END IF
             SELECT CASE (SILLY == 1)
             CASE (.TRUE.)
                 CALL THIS
             CASE (.FALSE.)
                 CALL THAT
             END SELECT
             SELECT CASE (SILLY)
             CASE DEFAULT
                 CALL THAT
             CASE (1)
                 CALL THIS
             END SELECT



             NOTE 8.9

             A code fragment showing several selections of one block:


             SELECT CASE (N)
             CASE (1, 3:5, 8)      ! Selects 1, 3, 4, 5, 8
                 CALL SUB
             CASE DEFAULT
                 CALL OTHER
             END SELECT



 1    8.1.4       ASSOCIATE construct

 2    The ASSOCIATE construct associates named entities with expressions or variables during the execution
 3    of its block. These named construct entities (16.3) are associating entities (16.4.1.5). The names are
 4    associate names.


 5    8.1.4.1     Form of the ASSOCIATE construct

 6    R816       associate-construct         is    associate-stmt
 7                                                     block
 8                                                     end-associate-stmt
 9    R817       associate-stmt              is    [ associate-construct-name : ] ASSOCIATE
10                                                   (association-list )
11    R818       association                 is    associate-name => selector
12    R819       selector                    is    expr
13                                           or variable




      160                                  WORKING DRAFT                                       SEP 2002


      SEP 2002                                WORKING DRAFT                                      J3/02-007R3



 1    C808       (R818) If selector is not a variable or is a variable that has a vector subscript, associate-name
 2               shall not appear in a variable definition context (16.5.7).

 3    R820       end-associate-stmt           is    END ASSOCIATE [ associate-construct-name ]

 4    C809       (R820) If the associate-stmt of an associate-construct specifies an associate-construct-name,
 5               the corresponding end-associate-stmt shall specify the same associate-construct-name. If the
 6               associate-stmt of an associate-construct does not specify an associate-construct-name, the cor-
 7               responding end-associate-stmt shall not specify an associate-construct-name.


 8    8.1.4.2     Execution of the ASSOCIATE construct

 9    Execution of an ASSOCIATE construct causes execution of its associate-stmt followed by execution of
10    its block. During execution of that block each associate name identifies an entity, which is associated
11    (16.4.1.5) with the corresponding selector. The associating entity assumes the declared type and type
12    parameters of the selector. If and only if the selector is polymorphic, the associating entity is polymorphic
13    and assumes the dynamic type and type parameters of the selector.

14    The other attributes of the associating entity are described in 8.1.4.3.

15    It is permissible to branch to an end-associate-stmt only from within its ASSOCIATE construct.


16    8.1.4.3     Attributes of associate names

17    Within a SELECT TYPE or ASSOCIATE construct, each associating entity has the same rank as its
18    associated selector. The lower bound of each dimension is the result of the intrinsic function LBOUND
19    (13.7.58) applied to the corresponding dimension of selector . The upper bound of each dimension is one
20    less than the sum of the lower bound and the extent. The associating entity has the ASYNCHRONOUS,
21    INTENT, TARGET, or VOLATILE attribute if and only if the selector is a variable and has the attribute.
22    If the selector has the OPTIONAL attribute, it shall be present.

23    If the selector (8.1.4.1) is not permitted to appear in a variable definition context (16.5.7) or is an array
24    with a vector subscript, the associate name shall not appear in a variable definition context.


25    8.1.4.4     Examples of the ASSOCIATE construct


           NOTE 8.10

           The following example illustrates an association with an expression.


           ASSOCIATE ( Z => EXP(-(X**2+Y**2)) * COS(THETA) )
                 PRINT *, A+Z, A-Z
           END ASSOCIATE


           The following example illustrates an association with a derived-type variable.


           ASSOCIATE ( XC => AX%B(I,J)%C )
                 XC%DV = XC%DV + PRODUCT(XC%EV(1:N))
           END ASSOCIATE


           The following example illustrates association with an array section.


           ASSOCIATE ( ARRAY => AX%B(I,:)%C )
                 ARRAY(N)%EV = ARRAY(N-1)%EV





      SEP 2002                                       WORKING DRAFT                                            161


      J3/02-007R3                                    WORKING DRAFT                                    SEP 2002



             NOTE 8.10 (cont.)

             END ASSOCIATE


             The following example illustrates multiple associations.


             ASSOCIATE ( W => RESULT(I,J)%W, ZX => AX%B(I,J)%D, ZY => AY%B(I,J)%D )
                 W = ZX*X + ZY*Y
             END ASSOCIATE



 1    8.1.5       SELECT TYPE construct

 2    The SELECT TYPE construct selects for execution at most one of its constituent blocks. The selection
 3    is based on the dynamic type of an expression. A name is associated with the expression (16.3, 16.4.1.5),
 4    in the same way as for the ASSOCIATE construct.


 5    8.1.5.1     Form of the SELECT TYPE construct

 6    R821       select-type-construct         is    select-type-stmt
 7                                                       [ type-guard-stmt
 8                                                           block ] ...
 9                                                       end-select-type-stmt
10    R822       select-type-stmt              is    [ select-construct-name : ] SELECT TYPE
11                                                      ( [ associate-name => ] selector )

12    C810       (R822) If selector is not a named variable, associate-name => shall appear.

13    C811       (R822) If selector is not a variable or is a variable that has a vector subscript, associate-name
14               shall not appear in a variable definition context (16.5.7).

15    C812       (R822) The selector in a select-type-stmt shall be polymorphic.

16    R823       type-guard-stmt               is    TYPE IS ( extensible-type-name ) [ select-construct-name ]
17                                             or CLASS IS ( extensible-type-name ) [ select-construct-name ]
18                                             or CLASS DEFAULT [ select-construct-name ]

19    C813       (R823) If selector is not unlimited polymorphic, the extensible-type-name shall be the name of
20               an extension of the declared type of selector .

21    C814       (R823) For a given select-type-construct , the same extensible-type-name shall not be specified in
22               more than one TYPE IS type-guard-stmt and shall not be specified in more than one CLASS IS
23               type-guard-stmt .

24    C815       (R823) For a given select-type-construct , there shall be at most one CLASS DEFAULT type-
25               guard-stmt .

26    R824       end-select-type-stmt          is    END SELECT [ select-construct-name ]

27    C816       (R821) If the select-type-stmt of a select-type-construct specifies a select-construct-name, the
28               corresponding end-select-type-stmt shall specify the same select-construct-name. If the select-
29               type-stmt of a select-type-construct does not specify a select-construct-name, the corresponding
30               end-select-type-stmt shall not specify a select-construct-name. If a type-guard-stmt specifies a
31               select-construct-name, the corresponding select-type-stmt shall specify the same select-construct-
32               name.

33    The associate name of a SELECT TYPE construct is the associate-name if specified; otherwise it is the
34    name that constitutes the selector .



      162                                     WORKING DRAFT                                           SEP 2002


      SEP 2002                                   WORKING DRAFT                                     J3/02-007R3



 1    8.1.5.2      Execution of the SELECT TYPE construct

 2    Execution of a SELECT TYPE construct whose selector is not a variable causes the selector expression
 3    to be evaluated.

 4    A SELECT TYPE construct selects at most one block to be executed. During execution of that block,
 5    the associate name identifies an entity, which is associated (16.4.1.5) with the selector.

 6    The block to be executed is selected as follows:

 7          (1)        If the dynamic type of the selector is the same as the type named in a TYPE IS type guard
 8                     statement, the block following that statement is executed.

 9          (2)        Otherwise, if the dynamic type of the selector is an extension of exactly one type named in
10                     a CLASS IS type guard statement, the block following that statement is executed.

11          (3)        Otherwise, if the dynamic type of the selector is an extension of several types named in
12                     CLASS IS type guard statements, one of these statements must specify a type that is an
13                     extension of all the types specified in the others; the block following that statement is
14                     executed.

15          (4)        Otherwise, if there is a CLASS DEFAULT type guard statement, the block following that
16                     statement is executed.

           NOTE 8.11

           This algorithm does not examine the type guard statements in source text order when it looks for
           a match; it selects the most particular type guard when there are several potential matches.


17    Within the block following a TYPE IS type guard statement, the associating entity (16.4.5) is not
18    polymorphic (5.1.1.8), has the type named in the type guard statement, and has the type parameters of
19    the selector.

20    Within the block following a CLASS IS type guard statement, the associating entity is polymorphic and
21    has the declared type named in the type guard statement. The type parameters of the associating entity
22    are those of the type specified in the CLASS IS type guard statement.

23    Within the block following a CLASS DEFAULT type guard statement, the associating entity is poly-
24    morphic and has the same declared type as the selector. The type parameters of the associating entity
25    are those of the declared type of the selector.

           NOTE 8.12

           If the declared type of the selector is T, specifying CLASS DEFAULT has the same effect as
           specifying CLASS IS (T).


26    The other attributes of the associating entity are described in 8.1.4.3.

27    A type guard statement shall not be a branch target statement. It is permissible to branch to an
28    end-select-type-stmt only from within its SELECT TYPE construct.


29    8.1.5.3      Examples of the SELECT TYPE construct


           NOTE 8.13


           TYPE, EXTENSIBLE :: POINT
                 REAL :: X, Y
           END TYPE POINT





      SEP 2002                                       WORKING DRAFT                                           163


      J3/02-007R3                                 WORKING DRAFT                                 SEP 2002



             NOTE 8.13 (cont.)

             TYPE, EXTENDS(POINT) :: POINT_3D
                 REAL :: Z
             END TYPE POINT_3D
             TYPE, EXTENDS(POINT) :: COLOR_POINT
                 INTEGER :: COLOR
             END TYPE COLOR_POINT


             TYPE(POINT), TARGET :: P
             TYPE(POINT_3D), TARGET :: P3
             TYPE(COLOR_POINT), TARGET :: C
             CLASS(POINT), POINTER :: P_OR_C
             P_OR_C => C
             SELECT TYPE ( A => P_OR_C )
             CLASS IS ( POINT )
                 ! "CLASS ( POINT ) :: A" implied here
                 PRINT *, A%X, A%Y ! This block gets executed
             TYPE IS ( POINT_3D )
                 ! "TYPE ( POINT_3D ) :: A" implied here
                 PRINT *, A%X, A%Y, A%Z
             END SELECT



             NOTE 8.14

             The following example illustrates the omission of associate-name. It uses the declarations from
             Note 8.13.


             P_OR_C => P3
             SELECT TYPE ( P_OR_C )
             CLASS IS ( POINT )
                 ! "CLASS ( POINT ) :: P_OR_C" implied here
                 PRINT *, P_OR_C%X, P_OR_C%Y
             TYPE IS ( POINT_3D )
                 ! "TYPE ( POINT_3D ) :: P_OR_C" implied here
                 PRINT *, P_OR_C%X, P_OR_C%Y, P_OR_C%Z        ! This block gets executed
             END SELECT



 1    8.1.6       DO construct

 2    The DO construct specifies the repeated execution of a sequence of executable constructs.        Such a
 3    repeated sequence is called a loop. The EXIT and CYCLE statements may be used to modify the
 4    execution of a loop.

 5    The number of iterations of a loop may be determined at the beginning of execution of the DO construct,
 6    or may be left indefinite ("DO forever" or DO WHILE). In either case, an EXIT statement (8.1.6.4.4)
 7    anywhere in the DO construct may be executed to terminate the loop immediately. The current iteration
 8    of the loop may be curtailed by executing a CYCLE statement (8.1.6.4.3).


 9    8.1.6.1     Forms of the DO construct

10    The DO construct may be written in either a block form or a nonblock form.

11    R825       do-construct               is    block-do-construct
12                                          or nonblock-do-construct



      164                                  WORKING DRAFT                                        SEP 2002


      SEP 2002                                   WORKING DRAFT                                                 J3/02-007R3



 1    8.1.6.1.1    Form of the block DO construct

 2    R826    block-do-construct                 is    do-stmt
 3                                                           do-block
 4                                                           end-do
 5    R827    do-stmt                            is    label-do-stmt
 6                                               or nonlabel-do-stmt
 7    R828    label-do-stmt                      is    [ do-construct-name : ] DO label [ loop-control ]
 8    R829    nonlabel-do-stmt                   is    [ do-construct-name : ] DO [ loop-control ]
 9    R830    loop-control                       is    [ , ] do-variable = scalar-int-expr , scalar-int-expr
10                                                       [ , scalar-int-expr ]
11                                               or [ , ] WHILE ( scalar-logical-expr )
12    R831    do-variable                        is    scalar-int-variable

13    C817    (R831) The do-variable shall be a named scalar variable of type integer.

14    R832    do-block                           is    block
15    R833    end-do                             is    end-do-stmt
16                                               or continue-stmt
17    R834    end-do-stmt                        is    END DO [ do-construct-name ]

18    C818    (R826) If the do-stmt of a block-do-construct specifies a do-construct-name, the corresponding
19            end-do shall be an end-do-stmt specifying the same do-construct-name. If the do-stmt of a
20            block-do-construct does not specify a do-construct-name, the corresponding end-do shall not
21            specify a do-construct-name.

22    C819    (R826) If the do-stmt is a nonlabel-do-stmt , the corresponding end-do shall be an end-do-stmt .

23    C820    (R826) If the do-stmt is a label-do-stmt , the corresponding end-do shall be identified with the
24            same label .


25    8.1.6.1.2    Form of the nonblock DO construct

26    R835    nonblock-do-construct              is    action-term-do-construct
27                                               or    outer-shared-do-construct
28    R836    action-term-do-construct           is    label-do-stmt
29                                                           do-body
30                                                           do-term-action-stmt
31    R837    do-body                            is    [ execution-part-construct ] ...
32    R838    do-term-action-stmt                is    action-stmt


33    C821    (R838) A do-term-action-stmt shall not be a continue-stmt , a goto-stmt , a return-stmt , a stop-stmt , an exit-stmt ,
34            a cycle-stmt , an end-function-stmt , an end-subroutine-stmt , an end-program-stmt , or an arithmetic-if-stmt .


35    C822    (R835) The do-term-action-stmt shall be identified with a label and the corresponding label-do-stmt shall refer
36            to the same label.


37    R839    outer-shared-do-construct          is    label-do-stmt
38                                                           do-body
39                                                           shared-term-do-construct
40    R840    shared-term-do-construct           is    outer-shared-do-construct
41                                               or    inner-shared-do-construct
42    R841    inner-shared-do-construct          is    label-do-stmt
43                                                           do-body
44                                                           do-term-shared-stmt
45    R842    do-term-shared-stmt                is    action-stmt


46    C823    (R842) A do-term-shared-stmt shall not be a goto-stmt , a return-stmt , a stop-stmt , an exit-stmt , a cycle-stmt ,
47            an end-function-stmt , an end-subroutine-stmt , an end-program-stmt , or an arithmetic-if-stmt .


48    C824    (R840) The do-term-shared-stmt shall be identified with a label and all of the label-do-stmt s of the shared-term-
49            do-construct shall refer to the same label.




      SEP 2002                                           WORKING DRAFT                                                        165


      J3/02-007R3                                      WORKING DRAFT                                              SEP 2002



 1    The do-term-action-stmt , do-term-shared-stmt , or shared-term-do-construct following the do-body of a nonblock DO con-
 2    struct is called the DO termination of that construct.


 3    Within a scoping unit, all DO constructs whose DO statements refer to the same label are nonblock DO constructs, and

 4    are said to share the statement identified by that label.


 5    8.1.6.2        Range of the DO construct

 6    The range of a block DO construct is the do-block , which shall satisfy the rules for blocks (8.1.1). In
 7    particular, transfer of control to the interior of such a block from outside the block is prohibited. It
 8    is permitted to branch to the end-do of a block DO construct only from within the range of that DO
 9    construct.


10    The range of a nonblock DO construct consists of the do-body and the following DO termination. The end of such a

11    range is not bounded by a particular statement as for the other executable constructs (e.g., END IF); nevertheless, the

12    range satisfies the rules for blocks (8.1.1). Transfer of control into the do-body or to the DO termination from outside the

13    range is prohibited; in particular, it is permitted to branch to a do-term-shared-stmt only from within the range of the

14    corresponding inner-shared-do-construct .


15    8.1.6.3        Active and inactive DO constructs

16    A DO construct is either active or inactive. Initially inactive, a DO construct becomes active only
17    when its DO statement is executed.

18    Once active, the DO construct becomes inactive only when the construct is terminated (8.1.6.4.4).


19    8.1.6.4        Execution of a DO construct

20    A DO construct specifies a loop, that is, a sequence of executable constructs that is executed repeatedly.
21    There are three phases in the execution of a DO construct: initiation of the loop, execution of the loop
22    range, and termination of the loop.


23    8.1.6.4.1       Loop initiation

24    When the DO statement is executed, the DO construct becomes active. If loop-control is

25        [ , ] do-variable = scalar-int-expr 1 , scalar-int-expr 2 [ , scalar-int-expr 3 ]

26    the following steps are performed in sequence:

27            (1)      The initial parameter m1, the terminal parameter m2, and the incrementation parameter m3
28                     are of type integer with the same kind type parameter as the do-variable. Their values are es-
29                     tablished by evaluating scalar-int-expr 1, scalar-int-expr 2, and scalar-int-expr 3, respectively,
30                     including, if necessary, conversion to the kind type parameter of the do-variable according
31                     to the rules for numeric conversion (Table 7.9). If scalar-int-expr 3 does not appear, m3 has
32                     the value 1. The value of m3 shall not be zero.
33            (2)      The DO variable becomes defined with the value of the initial parameter m1.
34            (3)      The iteration count is established and is the value of the expression (m2 - m1 + m3)/m3,
35                     unless that value is negative, in which case the iteration count is 0.

             NOTE 8.15

             The iteration count is zero whenever:

                 m1 > m2 and m3 > 0, or
                 m1 < m2 and m3 < 0.





      166                                          WORKING DRAFT                                                  SEP 2002


      SEP 2002                                     WORKING DRAFT                                               J3/02-007R3




 1    If loop-control is omitted, no iteration count is calculated. The effect is as if a large positive iteration
 2    count, impossible to decrement to zero, were established. If loop-control is [ , ] WHILE (scalar-logical-
 3    expr ), the effect is as if loop-control were omitted and the following statement inserted as the first
 4    statement of the do-block :

 5    IF (.NOT. (scalar- logical-expr )) EXIT

 6    At the completion of the execution of the DO statement, the execution cycle begins.


 7    8.1.6.4.2      The execution cycle

 8    The execution cycle of a DO construct consists of the following steps performed in sequence repeatedly
 9    until termination:

10            (1)    The iteration count, if any, is tested. If it is zero, the loop terminates and the DO construct
11                   becomes inactive. If loop-control is [ , ] WHILE (scalar-logical-expr ), the scalar-logical-expr
12                   is evaluated; if the value of this expression is false, the loop terminates and the DO construct
13                   becomes inactive. If, as a result, all of the DO constructs sharing the do-term-shared-stmt are inactive,

14                   the execution of all of these constructs is complete. However, if some of the DO constructs sharing the

15                   do-term-shared-stmt are active, execution continues with step (3) of the execution cycle of the active DO

16                   construct whose DO statement was most recently executed.

17            (2)    If the iteration count is nonzero, the range of the loop is executed.

18            (3)    The iteration count, if any, is decremented by one. The DO variable, if any, is incremented
19                   by the value of the incrementation parameter m3.

20    Except for the incrementation of the DO variable that occurs in step (3), the DO variable shall neither
21    be redefined nor become undefined while the DO construct is active.


22    8.1.6.4.3      CYCLE statement

23    Step (2) in the above execution cycle may be curtailed by executing a CYCLE statement from within
24    the range of the loop.

25    R843      cycle-stmt                         is    CYCLE [ do-construct-name ]

26    C825      (R843) If a cycle-stmt refers to a do-construct-name, it shall be within the range of that do-
27              construct ; otherwise, it shall be within the range of at least one do-construct .

28    A CYCLE statement belongs to a particular DO construct. If the CYCLE statement refers to a DO
29    construct name, it belongs to that DO construct; otherwise, it belongs to the innermost DO construct
30    in which it appears.

31    Execution of a CYCLE statement causes immediate progression to step (3) of the current execution cycle
32    of the DO construct to which it belongs. If this construct is a nonblock DO construct, the do-term-action-stmt or

33    do-term-shared-stmt is not executed.


34    In a block DO construct, a transfer of control to the end-do has the same effect as execution of a CYCLE
35    statement belonging to that construct. In a nonblock DO construct, transfer of control to the do-term-action-stmt

36    or do-term-shared-stmt causes that statement or construct itself to be executed. Unless a further transfer of control results,

37    step (3) of the current execution cycle of the DO construct is then executed.


38    8.1.6.4.4      Loop termination

39    The EXIT statement provides one way of terminating a loop.

40    R844      exit-stmt                          is    EXIT [ do-construct-name ]



      SEP 2002                                            WORKING DRAFT                                                       167


      J3/02-007R3                                    WORKING DRAFT                                       SEP 2002



 1    C826       (R844) If an exit-stmt refers to a do-construct-name, it shall be within the range of that do-
 2               construct ; otherwise, it shall be within the range of at least one do-construct .

 3    An EXIT statement belongs to a particular DO construct. If the EXIT statement refers to a DO
 4    construct name, it belongs to that DO construct; otherwise, it belongs to the innermost DO construct
 5    in which it appears.

 6    The loop terminates, and the DO construct becomes inactive, when any of the following occurs:

 7            (1)      Determination that the iteration count is zero or the scalar-logical-expr is false, when tested
 8                     during step (1) of the above execution cycle

 9            (2)      Execution of an EXIT statement belonging to the DO construct

10            (3)      Execution of an EXIT statement or a CYCLE statement that is within the range of the DO
11                     construct, but that belongs to an outer DO construct

12            (4)      Transfer of control from a statement within the range of a DO construct to a statement that
13                     is neither the end-do nor within the range of the same DO construct

14            (5)      Execution of a RETURN statement within the range of the DO construct

15            (6)      Execution of a STOP statement anywhere in the program; or termination of the program
16                     for any other reason.

17    When a DO construct becomes inactive, the DO variable, if any, of the DO construct retains its last
18    defined value.


19    8.1.6.5        Examples of DO constructs


             NOTE 8.16

             The following program fragment computes a tensor product of two arrays:


             DO I = 1, M
                 DO J = 1, N
                       C (I, J) = SUM (A (I, J, :) * B (:, I, J))
                 END DO
             END DO



             NOTE 8.17

             The following program fragment contains a DO construct that uses the WHILE form of loop-
             control . The loop will continue to execute until an end-of-file or input/output error is encountered,
             at which point the DO statement terminates the loop. When a negative value of X is read, the
             program skips immediately to the next READ statement, bypassing most of the range of the loop.



             READ (IUN, '(1X, G14.7)', IOSTAT = IOS) X
             DO WHILE (IOS == 0)
                 IF (X >= 0.) THEN
                       CALL SUBA (X)
                       CALL SUBB (X)
                            ...
                       CALL SUBZ (X)
                 ENDIF
                 READ (IUN, '(1X, G14.7)', IOSTAT = IOS) X
             END DO





      168                                       WORKING DRAFT                                            SEP 2002


      SEP 2002                                        WORKING DRAFT                                               J3/02-007R3



              NOTE 8.18

              The following example behaves exactly the same as the one in Note 8.17. However, the READ
              statement has been moved to the interior of the range, so that only one READ statement is needed.
              Also, a CYCLE statement has been used to avoid an extra level of IF nesting.


              DO          ! A "DO WHILE + 1/2" loop
                    READ (IUN, '(1X, G14.7)', IOSTAT = IOS) X
                    IF (IOS /= 0) EXIT
                    IF (X < 0.) CYCLE
                    CALL SUBA (X)
                    CALL SUBB (X)
                        . . .
                    CALL SUBZ (X)
              END DO



              NOTE 8.19

              Additional examples of DO constructs are in C.5.3.



 1    8.2           Branching

 2    Branching is used to alter the normal execution sequence. A branch causes a transfer of control from
 3    one statement in a scoping unit to a labeled branch target statement in the same scoping unit. Branching
 4    may be caused by a GOTO statement, a computed GOTO statement, an arithmetic IF statement, a

 5    CALL statement that has an alt-return-spec, or an input/output statement that has an END= or ERR=
 6    specifier. Although procedure references and control constructs can cause transfer of control, they are
 7    not branches. A branch target statement is an action-stmt , an associate-stmt , an end-associate-stmt ,
 8    an if-then-stmt , an end-if-stmt , a select-case-stmt , an end-select-stmt , a select-type-stmt , an end-select-
 9    type-stmt , a do-stmt , an end-do-stmt , a forall-construct-stmt , a do-term-action-stmt, a do-term-shared-stmt, or
10    a where-construct-stmt .


11    8.2.1          GO TO statement

12    R845          goto-stmt                         is    GO TO label

13    C827          (R845) The label shall be the statement label of a branch target statement that appears in the
14                  same scoping unit as the goto-stmt .

15    Execution of a GO TO statement causes a transfer of control so that the branch target statement
16    identified by the label is executed next.


17    8.2.2          Computed GO TO statement

18    R846          computed-goto-stmt                is    GO TO ( label -list ) [ , ] scalar-int-expr


19    C828          (R846 Each label in label -list shall be the statement label of a branch target statement that appears in the same
20                  scoping unit as the computed-goto-stmt .


              NOTE 8.20

              The same statement label may appear more than once in a label list.



21    Execution of a computed GO TO statement causes evaluation of the scalar integer expression. If this value is i such that

22    1  i  n where n is the number of labels in label -list, a transfer of control occurs so that the next statement executed is





      SEP 2002                                                  WORKING DRAFT                                                   169


      J3/02-007R3                                         WORKING DRAFT                                                SEP 2002



 1    the one identified by the ith label in the list of labels. If i is less than 1 or greater than n, the execution sequence continues

 2    as though a CONTINUE statement were executed.


 3    8.2.3       Arithmetic IF statement

 4    R847       arithmetic-if-stmt                 is    IF ( scalar-numeric-expr ) label , label , label


 5    C829       (R847) Each label shall be the label of a branch target statement that appears in the same scoping unit as the
 6               arithmetic-if-stmt .


 7    C830       (R847) The scalar-numeric-expr shall not be of type complex.


              NOTE 8.21

              The same label may appear more than once in one arithmetic IF statement.



 8    Execution of an arithmetic IF statement causes evaluation of the numeric expression followed by a transfer of control. The

 9    branch target statement identified by the first label, the second label, or the third label is executed next depending on

10    whether the value of the numeric expression is less than zero, equal to zero, or greater than zero, respectively.



11    8.3        CONTINUE statement

12    Execution of a CONTINUE statement has no effect.

13    R848       continue-stmt                      is    CONTINUE


14    8.4        STOP statement

15    R849       stop-stmt                          is    STOP [ stop-code ]
16    R850       stop-code                          is    scalar-char-constant
17                                                  or digit [ digit [ digit [ digit [ digit ] ] ] ]

18    C831       (R850) scalar-char-constant shall be of type default character.

19    Execution of a STOP statement causes normal termination (2.3.4) of execution of the program. At the
20    time of termination, the stop code, if any, is available in a processor-dependent manner. Leading zero
21    digits in the stop code are not significant. If any exception (14) is signaling, the processor shall issue
22    a warning indicating which exceptions are signaling; this warning shall be on the unit identified by the
23    named constant ERROR UNIT from the ISO FORTRAN ENV intrinsic module (13.8.3.1.3).





      170                                         WORKING DRAFT                                                        SEP 2002


      SEP 2002                               WORKING DRAFT                                     J3/02-007R3





 1    Section 9: Input/output statements

 2    Input statements provide the means of transferring data from external media to internal storage or
 3    from an internal file to internal storage. This process is called reading. Output statements provide
 4    the means of transferring data from internal storage to external media or from internal storage to an
 5    internal file. This process is called writing. Some input/output statements specify that editing of the
 6    data is to be performed.

 7    In addition to the statements that transfer data, there are auxiliary input/output statements to ma-
 8    nipulate the external medium, or to describe or inquire about the properties of the connection to the
 9    external medium.

10    The input/output statements are the OPEN, CLOSE, READ, WRITE, PRINT, BACKSPACE, END-
11    FILE, REWIND, FLUSH, WAIT, and INQUIRE statements.

12    The READ statement is a data transfer input statement. The WRITE statement and the PRINT
13    statement are data transfer output statements.           The OPEN statement and the CLOSE state-
14    ment are file connection statements. The INQUIRE statement is a file inquiry statement. The
15    BACKSPACE, ENDFILE, and REWIND statements are file positioning statements.

16    A file is composed of either a sequence of file storage units or a sequence of records, which provide an
17    extra level of organization to the file. A file composed of records is called a record file. A file composed
18    of file storage units is called a stream file. A processor may allow a file to be viewed both as a record
19    file and as a stream file; in this case the relationship between the file storage units when viewed as a
20    stream file and the records when viewed as a record file is processor dependent.

21    A file is either an external file or an internal file.


22    9.1       Records

23    A record is a sequence of values or a sequence of characters. For example, a line on a terminal is usually
24    considered to be a record. However, a record does not necessarily correspond to a physical entity. There
25    are three kinds of records:

26            (1)      Formatted

27            (2)      Unformatted

28            (3)      Endfile

             NOTE 9.1

             What is called a "record" in Fortran is commonly called a "logical record". There is no concept
             in Fortran of a "physical record."


29    9.1.1          Formatted record

30    A formatted record consists of a sequence of characters that are capable of representation in the
31    processor; however, a processor may prohibit some control characters (3.1) from appearing in a formatted
32    record. The length of a formatted record is measured in characters and depends primarily on the number
33    of characters put into the record when it is written. However, it may depend on the processor and the
34    external medium. The length may be zero. Formatted records may be read or written only by formatted
35    input/output statements.




      SEP 2002                                     WORKING DRAFT                                           171


      J3/02-007R3                                  WORKING DRAFT                                    SEP 2002



 1    Formatted records may be prepared by means other than Fortran.


 2    9.1.2          Unformatted record

 3    An unformatted record consists of a sequence of values in a processor-dependent form and may contain
 4    data of any type or may contain no data. The length of an unformatted record is measured in file storage
 5    units (9.2.4) and depends on the output list (9.5.2) used when it is written, as well as on the processor
 6    and the external medium. The length may be zero. Unformatted records may be read or written only
 7    by unformatted input/output statements.


 8    9.1.3          Endfile record

 9    An endfile record is written explicitly by the ENDFILE statement; the file shall be connected for
10    sequential access. An endfile record is written implicitly to a file connected for sequential access when
11    the most recent data transfer statement referring to the file is a data transfer output statement, no
12    intervening file positioning statement referring to the file has been executed, and

13            (1)      A REWIND or BACKSPACE statement references the unit to which the file is connected
14                     or

15            (2)      The unit is closed, either explicitly by a CLOSE statement, implicitly by a program termi-
16                     nation not caused by an error condition, or implicitly by another OPEN statement for the
17                     same unit.

18    An endfile record may occur only as the last record of a file. An endfile record does not have a length
19    property.

             NOTE 9.2

             An endfile record does not necessarily have any physical embodiment. The processor may use a
             record count or other means to register the position of the file at the time an ENDFILE statement
             is executed, so that it can take appropriate action when that position is reached again during
             a read operation. The endfile record, however it is implemented, is considered to exist for the
             BACKSPACE statement (9.7.1).



20    9.2       External files

21    An external file is any file that exists in a medium external to the program.

22    At any given time, there is a processor-dependent set of allowed access methods, a processor-dependent
23    set of allowed forms, a processor-dependent set of allowed actions, and a processor-dependent set of
24    allowed record lengths for a file.

             NOTE 9.3

             For example, the processor-dependent set of allowed actions for a printer would likely include the
             write action, but not the read action.


25    A file may have a name; a file that has a name is called a named file. The name of a named file is
26    represented by a character string value. The set of allowable names for a file is processor dependent.

27    An external file that is connected to a unit has a position property (9.2.3).

             NOTE 9.4

             For more explanatory information on external files, see C.6.1.





      172                                    WORKING DRAFT                                          SEP 2002


      SEP 2002                                WORKING DRAFT                                       J3/02-007R3


 1    9.2.1        File existence

 2    At any given time, there is a processor-dependent set of external files that are said to exist for a program.
 3    A file may be known to the processor, yet not exist for a program at a particular time.

           NOTE 9.5

           Security reasons may prevent a file from existing for a program. A newly created file may exist
           but contain no records.


 4    To create a file means to cause a file to exist that did not exist previously. To delete a file means to
 5    terminate the existence of the file.

 6    All input/output statements may refer to files that exist. An INQUIRE, OPEN, CLOSE, WRITE,
 7    PRINT, REWIND, FLUSH, or ENDFILE statement also may refer to a file that does not exist. Execu-
 8    tion of a WRITE, PRINT, or ENDFILE statement referring to a preconnected file that does not exist
 9    creates the file.


10    9.2.2        File access

11    There are three methods of accessing the data of an external file: sequential, direct, and stream. Some
12    files may have more than one allowed access method; other files may be restricted to one access method.

           NOTE 9.6

           For example, a processor may allow only sequential access to a file on magnetic tape. Thus, the
           set of allowed access methods depends on the file and the processor.


13    The method of accessing a file is determined when the file is connected to a unit (9.4.3) or when the file
14    is created if the file is preconnected (9.4.4).


15    9.2.2.1      Sequential access

16    Sequential access is a method of accessing the records of an external record file in order.

17    When connected for sequential access, an external file has the following properties:

18          (1)      The order of the records is the order in which they were written if the direct access method
19                   is not a member of the set of allowed access methods for the file. If the direct access method
20                   is also a member of the set of allowed access methods for the file, the order of the records
21                   is the same as that specified for direct access. In this case, the first record accessible by
22                   sequential access is the record whose record number is 1 for direct access. The second record
23                   accessible by sequential access is the record whose record number is 2 for direct access, etc.
24                   A record that has not been written since the file was created shall not be read.

25          (2)      The records of the file are either all formatted or all unformatted, except that the last record
26                   of the file may be an endfile record. Unless the previous reference to the file was a data
27                   transfer output statement or a file positioning statement, the last record, if any, of the file
28                   shall be an endfile record.

29          (3)      The records of the file shall be read or written only by sequential access input/output
30                   statements.


31    9.2.2.2      Direct access

32    Direct access is a method of accessing the records of an external record file in arbitrary order.

33    When connected for direct access, an external file has the following properties:




      SEP 2002                                       WORKING DRAFT                                             173


      J3/02-007R3                                    WORKING DRAFT                                        SEP 2002



 1            (1)      Each record of the file is uniquely identified by a positive integer called the record number.
 2                     The record number of a record is specified when the record is written. Once established,
 3                     the record number of a record can never be changed. The order of the records is the order
 4                     of their record numbers.

             NOTE 9.7

             A record may not be deleted; however, a record may be rewritten.

 5            (2)      The records of the file are either all formatted or all unformatted. If the sequential access
 6                     method is also a member of the set of allowed access methods for the file, its endfile record,
 7                     if any, is not considered to be part of the file while it is connected for direct access. If the
 8                     sequential access method is not a member of the set of allowed access methods for the file,
 9                     the file shall not contain an endfile record.

10            (3)      The records of the file shall be read or written only by direct access input/output statements.

11            (4)      All records of the file have the same length.

12            (5)      Records need not be read or written in the order of their record numbers. Any record may
13                     be written into the file while it is connected to a unit. For example, it is permissible to write
14                     record 3, even though records 1 and 2 have not been written. Any record may be read from
15                     the file while it is connected to a unit, provided that the record has been written since the
16                     file was created, and if a READ statement for this connection is permitted.

17            (6)      The records of the file shall not be read or written using list-directed formatting (10.9),
18                     namelist formatting (10.10), or a nonadvancing input/output statement (9.2.3.1).


19    9.2.2.3        Stream access

20    Stream access is a method of accessing the file storage units (9.2.4) of an external stream file.

21    The properties of an external file connected for stream access depend on whether the connection is for
22    unformatted or formatted access.

23    When connected for unformatted stream access, an external file has the following properties:

24            (1)      The file storage units of the file shall be read or written only by stream access input/output
25                     statements.

26            (2)      Each file storage unit in the file is uniquely identified by a positive integer called the position.
27                     The first file storage unit in the file is at position 1. The position of each subsequent file
28                     storage unit is one greater than that of its preceding file storage unit.

29            (3)      If it is possible to position the file, the file storage units need not be read or written in
30                     order of their position. For example, it might be permissible to write the file storage unit
31                     at position 3, even though the file storage units at positions 1 and 2 have not been written.
32                     Any file storage unit may be read from the file while it is connected to a unit, provided that
33                     the file storage unit has been written since the file was created, and if a READ statement
34                     for this connection is permitted.

35    When connected for formatted stream access, an external file has the following properties:

36            (1)      Some file storage units of the file may contain record markers; this imposes a record structure
37                     on the file in addition to its stream structure. There may or may not be a record marker
38                     at the end of the file. If there is no record marker at the end of the file, the final record is
39                     incomplete.

40            (2)      No maximum length (9.4.5.11) is applicable to these records.

41            (3)      Writing an empty record with no record marker has no effect.





      174                                      WORKING DRAFT                                              SEP 2002


      SEP 2002                                 WORKING DRAFT                                        J3/02-007R3



           NOTE 9.8

           Because the record structure is determined from the record markers that are stored in the file
           itself, an incomplete record at the end of the file is necessarily not empty.

 1          (4)      The file storage units of the file shall be read or written only by formatted stream access
 2                   input/output statements.

 3          (5)      Each file storage unit in the file is uniquely identified by a positive integer called the position.
 4                   The first file storage unit in the file is at position 1. The relationship between positions of
 5                   successive file storage units is processor dependent; not all positive integers need correspond
 6                   to valid positions.

 7          (6)      If it is possible to position the file, the file position can be set to a position that was
 8                   previously identified by the POS= specifier in an INQUIRE statement.

           NOTE 9.9

           There may be some character positions in the file that do not correspond to characters written; this
           is because on some processors a record marker may be written to the file as a carriage-return/line-
           feed or other sequence. The means of determining the position in a file connected for stream access
           is via the POS= specifier in an INQUIRE statement (9.9.1.20).


 9    9.2.3        File position

10    Execution of certain input/output statements affects the position of an external file. Certain circum-
11    stances can cause the position of a file to become indeterminate.

12    The initial point of a file is the position just before the first record or file storage unit. The terminal
13    point is the position just after the last record or file storage unit. If there are no records or file storage
14    units in the file, the initial point and the terminal point are the same position.

15    If a record file is positioned within a record, that record is the current record; otherwise, there is no
16    current record.

17    Let n be the number of records in the file. If 1 < i  n and a file is positioned within the ith record or
18    between the (i - 1)th record and the ith record, the (i - 1)th record is the preceding record. If n  1
19    and the file is positioned at its terminal point, the preceding record is the nth and last record. If n = 0
20    or if a file is positioned at its initial point or within the first record, there is no preceding record.

21    If 1  i < n and a file is positioned within the ith record or between the ith and (i + 1)th record, the
22    (i + 1)th record is the next record. If n  1 and the file is positioned at its initial point, the first record
23    is the next record. If n = 0 or if a file is positioned at its terminal point or within the nth (last) record,
24    there is no next record.

25    For a file connected for stream access, the file position is either between two file storage units, at the
26    initial point of the file, at the terminal point of the file, or undefined.


27    9.2.3.1      Advancing and nonadvancing input/output

28    An advancing input/output statement always positions a record file after the last record read or
29    written, unless there is an error condition.

30    A nonadvancing input/output statement may position a record file at a character position within
31    the current record, or a subsequent record (10.7.2). Using nonadvancing input/output, it is possible to
32    read or write a record of the file by a sequence of input/output statements, each accessing a portion
33    of the record. It is also possible to read variable-length records and be notified of their lengths. If a
34    nonadvancing output statement leaves a file positioned within a current record and no further output
35    statement is executed for the file before it is closed or a BACKSPACE, ENDFILE, or REWIND statement



      SEP 2002                                        WORKING DRAFT                                              175


      J3/02-007R3                                   WORKING DRAFT                                   SEP 2002



 1    is executed for it, the effect is as if the output statement were the corresponding advancing output
 2    statement.


 3    9.2.3.2     File position prior to data transfer

 4    The positioning of the file prior to data transfer depends on the method of access: sequential, direct, or
 5    stream.

 6    For sequential access on input, if there is a current record, the file position is not changed. Otherwise,
 7    the file is positioned at the beginning of the next record and this record becomes the current record.
 8    Input shall not occur if there is no next record or if there is a current record and the last data transfer
 9    statement accessing the file performed output.

10    If the file contains an endfile record, the file shall not be positioned after the endfile record prior to data
11    transfer. However, a REWIND or BACKSPACE statement may be used to reposition the file.

12    For sequential access on output, if there is a current record, the file position is not changed and the
13    current record becomes the last record of the file. Otherwise, a new record is created as the next record
14    of the file; this new record becomes the last and current record of the file and the file is positioned at
15    the beginning of this record.

16    For direct access, the file is positioned at the beginning of the record specified by the REC= specifier.
17    This record becomes the current record.

18    For stream access, the file is positioned immediately before the file storage unit specified by the POS=
19    specifier; if there is no POS= specifier, the file position is not changed.

20    File positioning for child data transfer statements is described in 9.5.3.7.


21    9.2.3.3     File position after data transfer

22    If an error condition (9.10) occurred, the position of the file is indeterminate. If no error condition
23    occurred, but an end-of-file condition (9.10) occurred as a result of reading an endfile record, the file is
24    positioned after the endfile record.

25    For unformatted stream access, if no error condition occurred, the file position is not changed. For
26    unformatted stream output, if the file position exceeds the previous terminal point of the file, the
27    terminal point is set to the file position.

             NOTE 9.10

             An unformatted stream output statement with a POS= specifier and an empty output list can
             have the effect of extending the terminal point of a file without actually writing any data.


28    For a formatted stream output statement, if no error condition occurred, the terminal point of the file
29    is set to the highest-numbered position to which data was transferred by the statement.

             NOTE 9.11

             The highest-numbered position might not be the current one if the output involved T or TL edit
             descriptors (10.7.1.1).


30    For formatted stream input, if an end-of-file condition occurred, the file position is not changed.

31    For nonadvancing input, if no error condition or end-of-file condition occurred, but an end-of-record
32    condition (9.10) occurred, the file is positioned after the record just read. If no error condition, end-of-
33    file condition, or end-of-record condition occurred in a nonadvancing input statement, the file position




      176                                    WORKING DRAFT                                          SEP 2002


      SEP 2002                                    WORKING DRAFT                                        J3/02-007R3



 1    is not changed. If no error condition occurred in a nonadvancing output statement, the file position is
 2    not changed.

 3    In all other cases, the file is positioned after the record just read or written and that record becomes the
 4    preceding record.


 5    9.2.4          File storage units

 6    A file storage unit is the basic unit of storage in a stream file or an unformatted record file. It is the
 7    unit of file position for stream access, the unit of record length for unformatted files, and the unit of file
 8    size for all external files.

 9    Every value in a stream file or an unformatted record file shall occupy an integer number of file storage
10    units; if the stream or record file is unformatted, this number shall be the same for all scalar values of
11    the same type and type parameters. The number of file storage units required for an item of a given type
12    and type parameters may be determined using the IOLENGTH= specifier of the INQUIRE statement
13    (9.9.3).

14    For a file connected for unformatted stream access, the processor shall not have alignment restrictions
15    that prevent a value of any type from being stored at any positive integer file position.

16    It is recommended that the file storage unit be an 8-bit octet where this choice is practical.

             NOTE 9.12

             The requirement that every data value occupy an integer number of file storage units implies that
             data items inherently smaller than a file storage unit will require padding. This suggests that the
             file storage unit be small to avoid wasted space. Ideally, the file storage unit would be chosen such
             that padding is never required. A file storage unit of one bit would always meet this goal, but
             would likely be impractical because of the alignment requirements.

             The prohibition on alignment restrictions prohibits the processor from requiring data alignments
             larger than the file storage unit.

             The 8-bit octet is recommended as a good compromise that is small enough to accommodate the
             requirements of many applications, yet not so small that the data alignment requirements are likely
             to cause significant performance problems.



17    9.3         Internal files

18    Internal files provide a means of transferring and converting data from internal storage to internal
19    storage.

20    An internal file is a record file with the following properties:

21            (1)      The file is a variable of default character type that is not an array section with a vector
22                     subscript.

23            (2)      A record of an internal file is a scalar character variable.

24            (3)      If the file is a scalar character variable, it consists of a single record whose length is the same
25                     as the length of the scalar character variable. If the file is a character array, it is treated
26                     as a sequence of character array elements. Each array element, if any, is a record of the
27                     file. The ordering of the records of the file is the same as the ordering of the array elements
28                     in the array (6.2.2.2) or the array section (6.2.2.3). Every record of the file has the same
29                     length, which is the length of an array element in the array.

30            (4)      A record of the internal file becomes defined by writing the record.             If the number of
31                     characters written in a record is less than the length of the record, the remaining portion



      SEP 2002                                          WORKING DRAFT                                               177


      J3/02-007R3                                        WORKING DRAFT                                  SEP 2002



 1                    of the record is filled with blanks. The number of characters to be written shall not exceed
 2                    the length of the record.

 3            (5)     A record may be read only if the record is defined.

 4            (6)     A record of an internal file may become defined (or undefined) by means other than an
 5                    output statement. For example, the character variable may become defined by a character
 6                    assignment statement.

 7            (7)     An internal file is always positioned at the beginning of the first record prior to data transfer,
 8                    except for child data transfer statements (9.5.3.7). This record becomes the current record.

 9            (8)     The initial value of a connection mode (9.4.1) is the value that would be implied by an
10                    initial OPEN statement without the corresponding keyword.

11            (9)     Reading and writing records shall be accomplished only by sequential access formatted
12                    input/output statements.

13            (10)    An internal file shall not be specified as the unit in a file connection statement, a file
14                    positioning statement, or a file inquiry statement.


15    9.4       File connection

16    A unit, specified by an io-unit , provides a means for referring to a file.

17    R901      io-unit                            is    file-unit-number
18                                                 or *
19                                                 or internal-file-variable
20    R902      file-unit-number                    is    scalar-int-expr
21    R903      internal-file-variable              is    default-char-variable

22    C901      (R903) The default-char-variable shall not be an array section with a vector subscript.

23    A unit is either an external unit or an internal unit. An external unit is used to refer to an external
24    file and is specified by an asterisk or a file-unit-number whose value is nonnegative or equal to one of
25    the named constants INPUT UNIT, OUTPUT UNIT, or ERROR UNIT of the ISO FORTRAN ENV
26    module (13.8.3). An internal unit is used to refer to an internal file and is specified by an internal-
27    file-variable or a file-unit-number whose value is equal to the unit argument of an active derived-type
28    input/output procedure (9.5.3.7). The value of a file-unit-number shall identify a valid unit.

29    The external unit identified by a particular value of a scalar-int-expr is the same external unit in all
30    program units of the program.

             NOTE 9.13

             In the example:


             SUBROUTINE A
                READ (6) X
                      ...
             SUBROUTINE B
                N = 6
                REWIND N


             the value 6 used in both program units identifies the same external unit.


31    An asterisk identifies particular processor-dependent external units that are preconnected for format-
32    ted sequential access (9.5.3.2). These units are also identified by unit numbers defined by the named
33    constants INPUT UNIT and OUTPUT UNIT of the ISO FORTRAN ENV module (13.8.3).




      178                                      WORKING DRAFT                                            SEP 2002


      SEP 2002                             WORKING DRAFT                                      J3/02-007R3



 1    This standard identifies a processor-dependent external unit for the purpose of error reporting. This
 2    unit shall be preconnected for sequential formatted output. The processor may define this to be the
 3    same as the output unit identified by an asterisk. This unit is also identified by a unit number defined
 4    by the named constant ERROR UNIT of the ISO FORTRAN ENV intrinsic module.


 5    9.4.1       Connection modes

 6    A connection for formatted input/output has several changeable modes: the blank interpretation mode
 7    (10.7.6), delimiter mode (10.9.2, 10.10.2.1), sign mode (10.7.4), decimal edit mode (10.7.8), I/O round-
 8    ing mode (10.6.1.2.6), pad mode (9.5.3.4.2), and scale factor (10.7.5). A connection for unformatted
 9    input/output has no changeable modes.

10    Values for the modes of a connection are established when the connection is initiated. If the connection
11    is initiated by an OPEN statement, the values are as specified, either explicitly or implicitly, by the
12    OPEN statement. If the connection is initiated other than by an OPEN statement (that is, if the file is
13    an internal file or preconnected file) the values established are those that would be implied by an initial
14    OPEN statement without the corresponding keywords.

15    The scale factor cannot be explicitly specified in an OPEN statement; it is implicitly 0.

16    The modes of a connection to an external file may be changed by a subsequent OPEN statement that
17    modifies the connection.

18    The modes of a connection may be temporarily changed by a corresponding keyword specifier in a
19    data transfer statement or by an edit descriptor. Keyword specifiers take effect at the beginning of
20    execution of the data transfer statement. Edit descriptors take effect when they are encountered in
21    format processing. When a data transfer statement terminates, the values for the modes are reset to the
22    values in effect immediately before the data transfer statement was executed.


23    9.4.2       Unit existence

24    At any given time, there is a processor-dependent set of external units that are said to exist for a
25    program.

26    All input/output statements may refer to units that exist. The CLOSE, INQUIRE, and WAIT state-
27    ments also may refer to units that do not exist.


28    9.4.3       Connection of a file to a unit

29    An external unit has a property of being connected or not connected. If connected, it refers to an
30    external file. An external unit may become connected by preconnection or by the execution of an OPEN
31    statement. The property of connection is symmetric; the unit is connected to a file if and only if the file
32    is connected to the unit.

33    Every input/output statement except an OPEN, CLOSE, INQUIRE, or WAIT statement shall refer to
34    a unit that is connected to a file and thereby make use of or affect that file.

35    A file may be connected and not exist (9.2.1).

           NOTE 9.14

           An example is a preconnected external file that has not yet been written.


36    A unit shall not be connected to more than one file at the same time, and a file shall not be connected to
37    more than one unit at the same time. However, means are provided to change the status of an external
38    unit and to connect a unit to a different file.




      SEP 2002                                   WORKING DRAFT                                            179


      J3/02-007R3                                 WORKING DRAFT                                     SEP 2002



 1    This standard defines means of portable interoperation with C. C streams are described in 7.19.2 of the C
 2    standard. Whether a unit may be connected to a file which is also connected to a C stream is processor
 3    dependent. It is processor dependent whether the files connected to the units INPUT UNIT, OUT-
 4    PUT UNIT, and ERROR UNIT correspond to the predefined C text streams standard input, standard
 5    output, and standard error.

 6    After an external unit has been disconnected by the execution of a CLOSE statement, it may be con-
 7    nected again within the same program to the same file or to a different file. After an external file has
 8    been disconnected by the execution of a CLOSE statement, it may be connected again within the same
 9    program to the same unit or to a different unit.

               NOTE 9.15

               The only means of referencing a file that has been disconnected is by the appearance of its name
               in an OPEN or INQUIRE statement. There may be no means of reconnecting an unnamed file
               once it is disconnected.


10    An internal unit is always connected to the internal file designated by the variable that identifies the
11    unit.

               NOTE 9.16

               For more explanatory information on file connection properties, see C.6.5.


12    9.4.4        Preconnection

13    Preconnection means that the unit is connected to a file at the beginning of execution of the program
14    and therefore it may be specified in input/output statements without the prior execution of an OPEN
15    statement.


16    9.4.5        The OPEN statement

17    An OPEN statement initiates or modifies the connection between an external file and a specified unit.
18    The OPEN statement may be used to connect an existing file to a unit, create a file that is preconnected,
19    create a file and connect it to a unit, or change certain modes of a connection between a file and a unit.

20    An external unit may be connected by an OPEN statement in any program unit of a program and, once
21    connected, a reference to it may appear in any program unit of the program.

22    If a unit is connected to a file that exists, execution of an OPEN statement for that unit is permitted.
23    If the FILE= specifier is not included in such an OPEN statement, the file to be connected to the unit
24    is the same as the file to which the unit is already connected.

25    If the file to be connected to the unit does not exist but is the same as the file to which the unit is
26    preconnected, the modes specified by an OPEN statement become a part of the connection.

27    If the file to be connected to the unit is not the same as the file to which the unit is connected, the effect
28    is as if a CLOSE statement without a STATUS= specifier had been executed for the unit immediately
29    prior to the execution of an OPEN statement.

30    If the file to be connected to the unit is the same as the file to which the unit is connected, only the
31    specifiers for changeable modes (9.4.1) may have values different from those currently in effect. If the
32    POSITION= specifier appears in such an OPEN statement, the value specified shall not disagree with
33    the current position of the file. If the STATUS= specifier is included in such an OPEN statement, it shall
34    be specified with the value OLD. Execution of such an OPEN statement causes any new values of the
35    specifiers for changeable modes to be in effect, but does not cause any change in any of the unspecified
36    specifiers and the position of the file is unaffected. The ERR=, IOSTAT=, and IOMSG= specifiers from



      180                                   WORKING DRAFT                                           SEP 2002


      SEP 2002                             WORKING DRAFT                                      J3/02-007R3



 1    any previously executed OPEN statement have no effect on any currently executed OPEN statement.

 2    A STATUS= specifier with a value of OLD is always allowed when the file to be connected to the unit is
 3    the same as the file to which the unit is connected. In this case, if the status of the file was SCRATCH
 4    before execution of the OPEN statement, the file will still be deleted when the unit is closed, and the
 5    file is still considered to have a status of SCRATCH.

 6    If a file is already connected to a unit, execution of an OPEN statement on that file and a different unit
 7    is not permitted.

 8    R904    open-stmt                    is    OPEN ( connect-spec-list )
 9    R905    connect-spec                 is    [ UNIT = ] file-unit-number
10                                         or ACCESS = scalar-default-char-expr
11                                         or ACTION = scalar-default-char-expr
12                                         or ASYNCHRONOUS = scalar-default-char-expr
13                                         or BLANK = scalar-default-char-expr
14                                         or DECIMAL = scalar-default-char-expr
15                                         or DELIM = scalar-default-char-expr
16                                         or ERR = label
17                                         or FILE = file-name-expr
18                                         or FORM = scalar-default-char-expr
19                                         or IOMSG = iomsg-variable
20                                         or IOSTAT = scalar-int-variable
21                                         or PAD = scalar-default-char-expr
22                                         or POSITION = scalar-default-char-expr
23                                         or RECL = scalar-int-expr
24                                         or ROUND = scalar-default-char-expr
25                                         or SIGN = scalar-default-char-expr
26                                         or STATUS = scalar-default-char-expr
27    R906    file-name-expr                is    scalar-default-char-expr
28    R907    iomsg-variable               is    scalar-default-char-variable

29    C902    (R905) No specifier shall appear more than once in a given connect-spec-list.

30    C903    (R905) A file-unit-number shall be specified; if the optional characters UNIT= are omitted, the
31            file-unit-number shall be the first item in the connect-spec-list.

32    C904    (R905) The label used in the ERR= specifier shall be the statement label of a branch target
33            statement that appears in the same scoping unit as the OPEN statement.

34    If the STATUS= specifier has the value NEW or REPLACE, the FILE= specifier shall appear. If the
35    STATUS= specifier has the value SCRATCH, the FILE= specifier shall not appear. If the STATUS=
36    specifier has the value OLD, the FILE= specifier shall appear unless the unit is connected and the file
37    connected to the unit exists.

38    A specifier that requires a scalar-default-char-expr may have a limited list of character values. These
39    values are listed for each such specifier. Any trailing blanks are ignored. The value specified is without
40    regard to case. Some specifiers have a default value if the specifier is omitted.

41    The IOSTAT=, ERR=, and IOMSG= specifiers are described in 9.10.

           NOTE 9.17

           An example of an OPEN statement is:


           OPEN (10, FILE = 'employee.names', ACTION = 'READ', PAD = 'YES')





      SEP 2002                                    WORKING DRAFT                                          181


      J3/02-007R3                                WORKING DRAFT                                        SEP 2002



             NOTE 9.18

             For more explanatory information on the OPEN statement, see C.6.4.


 1    9.4.5.1    ACCESS= specifier in the OPEN statement

 2    The scalar-default-char-expr shall evaluate to SEQUENTIAL, DIRECT, or STREAM. The ACCESS=
 3    specifier specifies the access method for the connection of the file as being sequential, direct, or stream.
 4    If this specifier is omitted, the default value is SEQUENTIAL. For an existing file, the specified access
 5    method shall be included in the set of allowed access methods for the file. For a new file, the processor
 6    creates the file with a set of allowed access methods that includes the specified method.


 7    9.4.5.2    ACTION= specifier in the OPEN statement

 8    The scalar-default-char-expr shall evaluate to READ, WRITE, or READWRITE. READ specifies that
 9    the WRITE, PRINT, and ENDFILE statements shall not refer to this connection. WRITE specifies
10    that READ statements shall not refer to this connection. READWRITE permits any input/output
11    statements to refer to this connection. If this specifier is omitted, the default value is processor dependent.
12    If READWRITE is included in the set of allowable actions for a file, both READ and WRITE also shall
13    be included in the set of allowed actions for that file. For an existing file, the specified action shall be
14    included in the set of allowed actions for the file. For a new file, the processor creates the file with a set
15    of allowed actions that includes the specified action.


16    9.4.5.3    ASYNCHRONOUS= specifier in the OPEN statement

17    The scalar-default-char-expr shall evaluate to YES or NO. If YES is specified, asynchronous input/output
18    on the unit is allowed. If NO is specified, asynchronous input/output on the unit is not allowed. If this
19    specifier is omitted, the default value is NO.


20    9.4.5.4    BLANK= specifier in the OPEN statement

21    The scalar-default-char-expr shall evaluate to NULL or ZERO. The BLANK= specifier is permitted only
22    for a connection for formatted input/output. It specifies the current value of the blank interpretation
23    mode (10.7.6, 9.5.1.5) for input for this connection. This mode has no effect on output. It is a changeable
24    mode (9.4.1). If this specifier is omitted in an OPEN statement that initiates a connection, the default
25    value is NULL.


26    9.4.5.5    DECIMAL= specifier in the OPEN statement

27    The scalar-default-char-expr shall evaluate to COMMA or POINT. The DECIMAL= specifier is per-
28    mitted only for a connection for formatted input/output. It specifies the current value of the decimal
29    edit mode (10.7.8, 9.5.1.6) for this connection. This is a changeable mode (9.4.1). If this specifier is
30    omitted in an OPEN statement that initiates a connection, the default value is POINT.


31    9.4.5.6    DELIM= specifier in the OPEN statement

32    The scalar-default-char-expr shall evaluate to APOSTROPHE, QUOTE, or NONE. The DELIM= spec-
33    ifier is permitted only for a connection for formatted input/output. It specifies the current value of the
34    delimiter mode (9.5.1.7) for list-directed (10.9.2) and namelist (10.10.2.1) output for the connection.
35    This mode has no effect on input. It is a changeable mode (9.4.1). If this specifier is omitted in an
36    OPEN statement that initiates a connection, the default value is NONE.


37    9.4.5.7    FILE= specifier in the OPEN statement

38    The value of the FILE= specifier is the name of the file to be connected to the specified unit. Any trailing
39    blanks are ignored. The file-name-expr shall be a name that is allowed by the processor. If this specifier



      182                                  WORKING DRAFT                                              SEP 2002


      SEP 2002                             WORKING DRAFT                                      J3/02-007R3



 1    is omitted and the unit is not connected to a file, the STATUS= specifier shall be specified with a value
 2    of SCRATCH; in this case, the connection is made to a processor-dependent file. The interpretation of
 3    case is processor dependent.


 4    9.4.5.8     FORM= specifier in the OPEN statement

 5    The scalar-default-char-expr shall evaluate to FORMATTED or UNFORMATTED. The FORM= spec-
 6    ifier determines whether the file is being connected for formatted or unformatted input/output. If this
 7    specifier is omitted, the default value is UNFORMATTED if the file is being connected for direct access
 8    or stream access, and the default value is FORMATTED if the file is being connected for sequential
 9    access. For an existing file, the specified form shall be included in the set of allowed forms for the file.
10    For a new file, the processor creates the file with a set of allowed forms that includes the specified form.


11    9.4.5.9     PAD= specifier in the OPEN statement

12    The scalar-default-char-expr shall evaluate to YES or NO. The PAD= specifier is permitted only for a
13    connection for formatted input/output. It specifies the current value of the pad mode (9.5.3.4.2, 9.5.1.9)
14    for input for this connection. This mode has no effect on output. It is a changeable mode (9.4.1). If this
15    specifier is omitted in an OPEN statement that initiates a connection, the default value is YES.

           NOTE 9.19

          For nondefault character types, the blank padding character is processor dependent.


16    9.4.5.10     POSITION= specifier in the OPEN statement

17    The scalar-default-char-expr shall evaluate to ASIS, REWIND, or APPEND. The connection shall be
18    for sequential or stream access. A new file is positioned at its initial point. REWIND positions an
19    existing file at its initial point. APPEND positions an existing file such that the endfile record is the
20    next record, if it has one. If an existing file does not have an endfile record, APPEND positions the
21    file at its terminal point. ASIS leaves the position unchanged if the file exists and already is connected.
22    ASIS leaves the position unspecified if the file exists but is not connected. If this specifier is omitted,
23    the default value is ASIS.


24    9.4.5.11     RECL= specifier in the OPEN statement

25    The value of the RECL= specifier shall be positive. It specifies the length of each record in a file being
26    connected for direct access, or specifies the maximum length of a record in a file being connected for
27    sequential access. This specifier shall not appear when a file is being connected for stream access. This
28    specifier shall appear when a file is being connected for direct access. If this specifier is omitted when
29    a file is being connected for sequential access, the default value is processor dependent. If the file is
30    being connected for formatted input/output, the length is the number of characters for all records that
31    contain only characters of type default character. When a record contains any nondefault characters,
32    the appropriate value for the RECL= specifier is processor dependent. If the file is being connected for
33    unformatted input/output, the length is measured in file storage units. For an existing file, the value of
34    the RECL= specifier shall be included in the set of allowed record lengths for the file. For a new file,
35    the processor creates the file with a set of allowed record lengths that includes the specified value.


36    9.4.5.12     ROUND= specifier in the OPEN statement

37    The scalar-default-char-expr shall evaluate to one of UP, DOWN, ZERO, NEAREST, COMPATIBLE,
38    or PROCESSOR DEFINED. The ROUND= specifier is permitted only for a connection for formatted
39    input/output. It specifies the current value of the I/O rounding mode (10.6.1.2.6, 9.5.1.12) for this
40    connection. This is a changeable mode (9.4.1). If this specifier is omitted in an OPEN statement that
41    initiates a connection, the I/O rounding mode is processor dependent; it shall be one of the above modes.




      SEP 2002                                   WORKING DRAFT                                                183


      J3/02-007R3                                WORKING DRAFT                                    SEP 2002



             NOTE 9.20

             A processor is free to select any I/O rounding mode for the default mode. The mode might
             correspond to UP, DOWN, ZERO, NEAREST, or COMPATIBLE; or it might be a completely
             different I/O rounding mode.


 1    9.4.5.13     SIGN= specifier in the OPEN statement

 2    The scalar-default-char-expr shall evaluate to one of PLUS, SUPPRESS, or PROCESSOR DEFINED.
 3    The SIGN= specifier is permitted only for a connection for formatted input/output. It specifies the
 4    current value of the sign mode (10.7.4, 9.5.1.13) for this connection. This is a changeable mode (9.4.1).
 5    If this specifier is omitted in an OPEN statement that initiates a connection, the default value is PRO-
 6    CESSOR DEFINED.


 7    9.4.5.14     STATUS= specifier in the OPEN statement

 8    The scalar-default-char-expr shall evaluate to OLD, NEW, SCRATCH, REPLACE, or UNKNOWN. If
 9    OLD is specified, the file shall exist. If NEW is specified, the file shall not exist.

10    Successful execution of an OPEN statement with NEW specified creates the file and changes the status
11    to OLD. If REPLACE is specified and the file does not already exist, the file is created and the status is
12    changed to OLD. If REPLACE is specified and the file does exist, the file is deleted, a new file is created
13    with the same name, and the status is changed to OLD. If SCRATCH is specified, the file is created
14    and connected to the specified unit for use by the program but is deleted at the execution of a CLOSE
15    statement referring to the same unit or at the normal termination of the program.

             NOTE 9.21

             SCRATCH shall not be specified with a named file.


16    If UNKNOWN is specified, the status is processor dependent. If this specifier is omitted, the default
17    value is UNKNOWN.


18    9.4.6       The CLOSE statement

19    The CLOSE statement is used to terminate the connection of a specified unit to an external file.

20    Execution of a CLOSE statement for a unit may occur in any program unit of a program and need not
21    occur in the same program unit as the execution of an OPEN statement referring to that unit.

22    Execution of a CLOSE statement performs a wait operation for any pending asynchronous data transfer
23    operations for the specified unit.

24    Execution of a CLOSE statement specifying a unit that does not exist or has no file connected to it is
25    permitted and affects no file.

26    After a unit has been disconnected by execution of a CLOSE statement, it may be connected again
27    within the same program, either to the same file or to a different file. After a named file has been
28    disconnected by execution of a CLOSE statement, it may be connected again within the same program,
29    either to the same unit or to a different unit, provided that the file still exists.

30    At normal termination of execution of a program, all units that are connected are closed. Each unit
31    is closed with status KEEP unless the file status prior to termination of execution was SCRATCH, in
32    which case the unit is closed with status DELETE.





      184                                   WORKING DRAFT                                         SEP 2002


      SEP 2002                                WORKING DRAFT                                        J3/02-007R3



             NOTE 9.22

             The effect is as though a CLOSE statement without a STATUS= specifier were executed on each
             connected unit.


 1    R908       close-stmt                   is    CLOSE ( close-spec-list )
 2    R909       close-spec                   is    [ UNIT = ] file-unit-number
 3                                            or IOSTAT = scalar-int-variable
 4                                            or IOMSG = iomsg-variable
 5                                            or ERR = label
 6                                            or STATUS = scalar-default-char-expr

 7    C905       (R909) No specifier shall appear more than once in a given close-spec-list.

 8    C906       (R909) A file-unit-number shall be specified; if the optional characters UNIT= are omitted, the
 9               file-unit-number shall be the first item in the close-spec-list.

10    C907       (R909) The label used in the ERR= specifier shall be the statement label of a branch target
11               statement that appears in the same scoping unit as the CLOSE statement.

12    The scalar-default-char-expr has a limited list of character values. Any trailing blanks are ignored. The
13    value specified is without regard to case.

14    The IOSTAT=, ERR=, and IOMSG= specifiers are described in 9.10.

             NOTE 9.23

             An example of a CLOSE statement is:


             CLOSE (10, STATUS = 'KEEP')



             NOTE 9.24

             For more explanatory information on the CLOSE statement, see C.6.6.


15    9.4.6.1     STATUS= specifier in the CLOSE statement

16    The scalar-default-char-expr shall evaluate to KEEP or DELETE. The STATUS= specifier determines
17    the disposition of the file that is connected to the specified unit. KEEP shall not be specified for a file
18    whose status prior to execution of a CLOSE statement is SCRATCH. If KEEP is specified for a file that
19    exists, the file continues to exist after the execution of a CLOSE statement. If KEEP is specified for a
20    file that does not exist, the file will not exist after the execution of a CLOSE statement. If DELETE is
21    specified, the file will not exist after the execution of a CLOSE statement. If this specifier is omitted, the
22    default value is KEEP, unless the file status prior to execution of the CLOSE statement is SCRATCH,
23    in which case the default value is DELETE.


24    9.5        Data transfer statements

25    The READ statement is the data transfer input statement.                   The WRITE statement and the
26    PRINT statement are the data transfer output statements.

27    R910       read-stmt                    is    READ ( io-control-spec-list ) [ input-item-list ]
28                                            or READ format [ , input-item-list ]
29    R911       write-stmt                   is    WRITE ( io-control-spec-list ) [ output-item-list ]
30    R912       print-stmt                   is    PRINT format [ , output-item-list ]





      SEP 2002                                       WORKING DRAFT                                          185


      J3/02-007R3                                   WORKING DRAFT                                  SEP 2002



             NOTE 9.25

             Examples of data transfer statements are:


                READ (6, *) SIZE
                READ 10, A, B
                WRITE (6, 10) A, S, J
                PRINT 10, A, S, J
             10 FORMAT (2E16.3, I5)



 1    9.5.1      Control information list

 2    A control information list is an io-control-spec-list. It governs data transfer.

 3    R913      io-control-spec               is    [ UNIT = ] io-unit
 4                                            or [ FMT = ] format
 5                                            or [ NML = ] namelist-group-name
 6                                            or ADVANCE = scalar-default-char-expr
 7                                            or ASYNCHRONOUS = scalar-char-initialization-expr
 8                                            or BLANK = scalar-default-char-expr
 9                                            or DECIMAL = scalar-default-char-expr
10                                            or DELIM = scalar-default-char-expr
11                                            or END = label
12                                            or EOR = label
13                                            or ERR = label
14                                            or ID = scalar-int-variable
15                                            or IOMSG = iomsg-variable
16                                            or IOSTAT = scalar-int-variable
17                                            or PAD = scalar-default-char-expr
18                                            or POS = scalar-int-expr
19                                            or REC = scalar-int-expr
20                                            or ROUND = scalar-default-char-expr
21                                            or SIGN = scalar-default-char-expr
22                                            or SIZE = scalar-int-variable

23    C908      (R913) No specifier shall appear more than once in a given io-control-spec-list.

24    C909      (R913) An io-unit shall be specified; if the optional characters UNIT= are omitted, the io-unit
25              shall be the first item in the io-control-spec-list.

26    C910      (R913) A DELIM= or SIGN= specifier shall not appear in a read-stmt .

27    C911      (R913) A BLANK=, PAD=, END=, EOR=, or SIZE= specifier shall not appear in a write-stmt .

28    C912      (R913) The label in the ERR=, EOR=, or END= specifier shall be the statement label of a
29              branch target statement that appears in the same scoping unit as the data transfer statement.

30    C913      (R913) A namelist-group-name shall be the name of a namelist group.

31    C914      (R913) A namelist-group-name shall not appear if an input-item-list or an output-item-list
32              appears in the data transfer statement.

33    C915      (R913) An io-control-spec-list shall not contain both a format and a namelist-group-name.

34    C916      (R913) If format appears without a preceding FMT=, it shall be the second item in the io-
35              control-spec-list and the first item shall be io-unit .




      186                                   WORKING DRAFT                                          SEP 2002


      SEP 2002                              WORKING DRAFT                                      J3/02-007R3



 1    C917    (R913) If namelist-group-name appears without a preceding NML=, it shall be the second item
 2            in the io-control-spec-list and the first item shall be io-unit .

 3    C918    (R913) If io-unit is not a file-unit-number , the io-control-spec-list shall not contain a REC=
 4            specifier or a POS= specifier.

 5    C919    (R913) If the REC= specifier appears, an END= specifier shall not appear, a namelist-group-
 6            name shall not appear, and the format , if any, shall not be an asterisk.

 7    C920    (R913) An ADVANCE= specifier may appear only in a formatted sequential or stream in-
 8            put/output statement with explicit format specification (10.1) whose control information list
 9            does not contain an internal-file-variable as the io-unit .

10    C921    (R913) If an EOR= specifier appears, an ADVANCE= specifier also shall appear.

11    C922    (R913) If a SIZE= specifier appears, an ADVANCE= specifier also shall appear.

12    C923    (R913) The scalar-char-initialization-expr in an ASYNCHRONOUS= specifier shall be of type
13            default character and shall have the value YES or NO.

14    C924    (R913) An ASYNCHRONOUS= specifier with a value YES shall not appear unless io-unit is a
15            file-unit-number .

16    C925    (R913) If an ID= specifier appears, an ASYNCHRONOUS= specifier with the value YES shall
17            also appear.

18    C926    (R913) If a POS= specifier appears, the io-control-spec-list shall not contain a REC= specifier.

19    C927    (R913) If a DECIMAL=, BLANK=, PAD=, SIGN=, or ROUND= specifier appears, a format
20            or namelist-group-name shall also appear.

21    C928    (R913) If a DELIM= specifier appears, either format shall be an asterisk or namelist-group-name
22            shall appear.

23    A SIZE= specifier may appear only in an input statement that contains an ADVANCE= specifier with
24    the value NO.

25    An EOR= specifier may appear only in an input statement that contains an ADVANCE= specifier with
26    the value NO.

27    If the data transfer statement contains a format or namelist-group-name, the statement is a formatted
28    input/output statement; otherwise, it is an unformatted input/output statement.

29    The ADVANCE=, ASYNCHRONOUS=, DECIMAL=, BLANK=, DELIM=, PAD=, SIGN=, and
30    ROUND= specifiers have a limited list of character values.          Any trailing blanks are ignored.    The
31    values specified are without regard to case.

32    The IOSTAT=, ERR=, EOR=, END=, and IOMSG= specifiers are described in 9.10.

          NOTE 9.26

          An example of a READ statement is:


          READ (IOSTAT = IOS, UNIT = 6, FMT = '(10F8.2)') A, B





      SEP 2002                                       WORKING DRAFT                                           187


      J3/02-007R3                                  WORKING DRAFT                                     SEP 2002



 1    9.5.1.1     FMT= specifier in a data transfer statement

 2    The FMT= specifier supplies a format specification or specifies list-directed formatting for a formatted
 3    input/output statement.

 4    R914       format                      is    default-char-expr
 5                                           or label
 6                                           or *

 7    C929       (R914) The label shall be the label of a FORMAT statement that appears in the same scoping
 8               unit as the statement containing the FMT= specifier.

 9    The default-char-expr shall evaluate to a valid format specification (10.1.1 and 10.1.2).

             NOTE 9.27

             A default-char-expr includes a character constant.


10    If default-char-expr is an array, it is treated as if all of the elements of the array were specified in array
11    element order and were concatenated.

12    If format is *, the statement is a list-directed input/output statement.

             NOTE 9.28

             An example in which the format is a character expression is:


             READ (6, FMT = "(" // CHAR_FMT // ")" )           X, Y, Z


             where CHAR FMT is a default character variable.


13    9.5.1.2     NML= specifier in a data transfer statement

14    The NML= specifier supplies the namelist-group-name (5.4). This name identifies a particular collection
15    of data objects on which transfer is to be performed.

16    If a namelist-group-name appears, the statement is a namelist input/output statement.


17    9.5.1.3     ADVANCE= specifier in a data transfer statement

18    The scalar-default-char-expr shall evaluate to YES or NO. The ADVANCE= specifier determines wheth-
19    er advancing input/output occurs for this input/output statement. If YES is specified, advancing in-
20    put/output occurs. If NO is specified, nonadvancing input/output occurs (9.2.3.1). If this specifier is
21    omitted from an input/output statement that allows the specifier, the default value is YES.


22    9.5.1.4     ASYNCHRONOUS= specifier in a data transfer statement

23    The ASYNCHRONOUS= specifier determines whether this input/output statement is synchronous or
24    asynchronous. If YES is specified, the statement and the input/output operation are said to be asyn-
25    chronous. If NO is specified or if the specifier is omitted, the statement and the input/output operation
26    are said to be synchronous.

27    Asynchronous input/output is permitted only for external files opened with an ASYNCHRONOUS=
28    specifier with the value YES in the OPEN statement.





      188                                  WORKING DRAFT                                             SEP 2002


      SEP 2002                                 WORKING DRAFT                                   J3/02-007R3



           NOTE 9.29

           Both synchronous and asynchronous input/output are allowed for files opened with an ASYN-
           CHRONOUS= specifier of YES. For other files, only synchronous input/output is allowed; this
           includes files opened with an ASYNCHRONOUS= specifier of NO, files opened without an ASYN-
           CHRONOUS= specifier, preconnected files accessed without an OPEN statement, and internal
           files.

           The ASYNCHRONOUS= specifier value in a data transfer statement is an initialization expression
           because it effects compiler optimizations and, therefore, needs to be known at compile time.


 1    The processor may perform an asynchronous data transfer operation asynchronously, but it is not re-
 2    quired to do so. Records and file storage units read or written by asynchronous data transfer statements
 3    are read, written, and processed in the same order as they would have been if the data transfer statements
 4    were synchronous.

 5    If a variable is used in an asynchronous data transfer statement as

 6          (1)       an item in an input/output list,

 7          (2)       a group object in a namelist, or

 8          (3)       a SIZE= specifier

 9    the base object of the data-ref is implicitly given the ASYNCHRONOUS attribute in the scoping unit
10    of the data transfer statement. This attribute may be confirmed by explicit declaration.

11    When an asynchronous input/output statement is executed, the set of storage units specified by the
12    item list or NML= specifier, plus the storage units specified by the SIZE= specifier, is defined to be the
13    pending input/output storage sequence for the data transfer operation.

           NOTE 9.30

           A pending input/output storage sequence is not necessarily a contiguous set of storage units.


14    A pending input/output storage sequence affector is a variable of which any part is associated with a
15    storage unit in a pending input/output storage sequence.


16    9.5.1.5       BLANK= specifier in a data transfer statement

17    The scalar-default-char-expr shall evaluate to NULL or ZERO. The BLANK= specifier temporarily
18    changes (9.4.1) the blank interpretation mode (10.7.6, 9.4.5.4) for the connection. If the specifier is
19    omitted, the mode is not changed.


20    9.5.1.6       DECIMAL= specifier in a data transfer statement

21    The scalar-default-char-expr shall evaluate to COMMA or POINT. The DECIMAL= specifier temporar-
22    ily changes (9.4.1) the decimal edit mode (10.7.8, 9.4.5.5) for the connection. If the specifier is omitted,
23    the mode is not changed.


24    9.5.1.7       DELIM= specifier in a data transfer statement

25    The scalar-default-char-expr shall evaluate to APOSTROPHE, QUOTE, or NONE. The DELIM= spec-
26    ifier temporarily changes (9.4.1) the delimiter mode (10.9.2, 10.10.2.1, 9.4.5.6) for the connection. If the
27    specifier is omitted, the mode is not changed.





      SEP 2002                                       WORKING DRAFT                                          189


      J3/02-007R3                                   WORKING DRAFT                                    SEP 2002



 1    9.5.1.8     ID= specifier in a data transfer statement

 2    Successful execution of an asynchronous data transfer statement containing an ID= specifier causes the
 3    variable specified in the ID= specifier to become defined with a processor-dependent value. This value
 4    is referred to as the identifier of the data transfer operation. It can be used in a subsequent WAIT or
 5    INQUIRE statement to identify the particular data transfer operation.

 6    If an error occurs during the execution of a data transfer statement containing an ID= specifier, the
 7    variable specified in the ID= specifier becomes undefined.

 8    A child data transfer statement shall not specify the ID= specifier.


 9    9.5.1.9     PAD= specifier in a data transfer statement

10    The scalar-default-char-expr shall evaluate to YES or NO. The PAD= specifier temporarily changes
11    (9.4.1) the pad mode (9.5.3.4.2, 9.4.5.9) for the connection. If the specifier is omitted, the mode is not
12    changed.


13    9.5.1.10     POS= specifier in a data transfer statement

14    The POS= specifier specifies the file position in file storage units. This specifier may appear only in
15    an input/output statement that specifies a unit connected for stream access. A child data transfer
16    statement shall not specify this specifier.

17    A processor may prohibit the use of POS= with particular files that do not have the properties necessary
18    to support random positioning.      A processor may also prohibit positioning a particular file to any
19    position prior to its current file position if the file does not have the properties necessary to support such
20    positioning.

             NOTE 9.31

             A file that represents connection to a device or data stream might not be positionable.


21    If the file is connected for formatted stream access, the file position specified by POS= shall be equal to
22    either 1 (the beginning of the file) or a value previously returned by a POS= specifier in an INQUIRE
23    statement for the file.


24    9.5.1.11     REC= specifier in a data transfer statement

25    The REC= specifier specifies the number of the record that is to be read or written. This specifier
26    may appear only in an input/output statement that specifies a unit connected for direct access; it
27    shall not appear in a child data transfer statement. If the control information list contains a REC=
28    specifier, the statement is a direct access input/output statement. A child data transfer statement
29    is a direct access data transfer statement if the parent is a direct access data transfer statement. Any
30    other data transfer statement is a sequential access input/output statement or a stream access
31    input/output statement, depending on whether the file connection is for sequential access or stream
32    access.


33    9.5.1.12     ROUND= specifier in a data transfer statement

34    The scalar-default-char-expr shall evaluate to one of the values specified in 9.4.5.12. The ROUND=
35    specifier temporarily changes (9.4.1) the I/O rounding mode (10.6.1.2.6, 9.4.5.12) for the connection. If
36    the specifier is omitted, the mode is not changed.





      190                                  WORKING DRAFT                                             SEP 2002


      SEP 2002                               WORKING DRAFT                                          J3/02-007R3



 1    9.5.1.13      SIGN= specifier in a data transfer statement

 2    The scalar-default-char-expr shall evaluate to PLUS, SUPPRESS, or PROCESSOR DEFINED. The
 3    SIGN= specifier temporarily changes (9.4.1) the sign mode (10.7.4, 9.4.5.13) for the connection. If the
 4    specifier is omitted, the mode is not changed.


 5    9.5.1.14      SIZE= specifier in a data transfer statement

 6    When a synchronous nonadvancing input statement terminates, the variable specified in the SIZE=
 7    specifier becomes defined with the count of the characters transferred by data edit descriptors during
 8    execution of the current input statement. Blanks inserted as padding (9.5.3.4.2) are not counted.

 9    For asynchronous nonadvancing input, the storage units specified in the SIZE= specifier become defined
10    with the count of the characters transferred when the corresponding wait operation is executed.


11    9.5.2       Data transfer input/output list

12    An input/output list specifies the entities whose values are transferred by a data transfer input/output
13    statement.

14    R915     input-item                    is    variable
15                                           or io-implied-do
16    R916     output-item                   is    expr
17                                           or io-implied-do
18    R917     io-implied-do                 is    ( io-implied-do-object -list , io-implied-do-control )
19    R918     io-implied-do-object          is    input-item
20                                           or output-item
21    R919     io-implied-do-control         is    do-variable = scalar-int-expr ,
22                                                    scalar-int-expr [ , scalar-int-expr ]

23    C930     (R915) A variable that is an input-item shall not be a whole assumed-size array.

24    C931     (R915) A variable that is an input-item shall not be a procedure pointer.

25    C932     (R919) The do-variable shall be a named scalar variable of type integer.

26    C933     (R918) In an input-item-list, an io-implied-do-object shall be an input-item. In an output-item-
27             list, an io-implied-do-object shall be an output-item.

28    C934     (R916) An expression that is an output-item shall not have a value that is a procedure pointer.

29    An input-item shall not appear as, nor be associated with, the do-variable of any io-implied-do that
30    contains the input-item.

           NOTE 9.32

           A constant, an expression involving operators or function references, or an expression enclosed in
           parentheses may appear as an output list item but shall not appear as an input list item.


31    If an input item is a pointer, it shall be associated with a definable target and data are transferred from
32    the file to the associated target. If an output item is a pointer, it shall be associated with a target and
33    data are transferred from the target to the file.





      SEP 2002                                      WORKING DRAFT                                            191


      J3/02-007R3                                WORKING DRAFT                                       SEP 2002



             NOTE 9.33

             Data transfers always involve the movement of values between a file and internal storage. A
             pointer as such cannot be read or written. Therefore, a pointer may not appear as an item in
             an input/output list unless it is associated with a target that can receive a value (input) or can
             deliver a value (output).


 1    If an input item or an output item is allocatable, it shall be allocated.

 2    A list item shall not be polymorphic unless it is processed by a user-defined derived-type input/output
 3    procedure (9.5.3.7).

 4    The do-variable of an io-implied-do that is in another io-implied-do shall not appear as, nor be associated
 5    with, the do-variable of the containing io-implied-do.

 6    The following rules describing whether to expand an input/output list item are re-applied to each
 7    expanded list item until none of the rules apply.

 8    If an array appears as an input/output list item, it is treated as if the elements, if any, were specified in
 9    array element order (6.2.2.2). However, no element of that array may affect the value of any expression
10    in the input-item, nor may any element appear more than once in an input-item.

             NOTE 9.34

             For example:


             INTEGER A (100), J (100)
                ...
             READ *, A (A)                                       ! Not allowed
             READ *, A (LBOUND (A, 1) : UBOUND (A, 1))           ! Allowed
             READ *, A (J)                                       ! Allowed if no two elements
                                                                 !     of J have the same value
             A(1) = 1; A(10) = 10
             READ *, A (A (1) : A (10))                          ! Not allowed



11    If a list item of derived type in an unformatted input/output statement is not processed by a user-defined
12    derived-type input/output procedure (9.5.3.7), and if any subobject of that list item would be processed
13    by a user-defined derived-type input/output procedure, the list item is treated as if all of the components
14    of the object were specified in the list in component order (4.5.4); those components shall be accessible
15    in the scoping unit containing the input/output statement and shall not be pointers or allocatable.

16    An effective input/output list item of derived type in an unformatted input/output statement is treated
17    as a single value in a processor-dependent form unless the list item or a subobject thereof is processed
18    by a user-defined derived-type input/output procedure (9.5.3.7).

             NOTE 9.35

             The appearance of a derived-type object as an input/output list item in an unformatted in-
             put/output statement is not equivalent to the list of its components.

             Unformatted input/output involving derived-type list items forms the single exception to the rule
             that the appearance of an aggregate list item (such as an array) is equivalent to the appearance
             of its expanded list of component parts. This exception permits the processor greater latitude in
             improving efficiency or in matching the processor-dependent sequence of values for a derived-type
             object to similar sequences for aggregate objects used by means other than Fortran. However,





      192                                  WORKING DRAFT                                             SEP 2002


      SEP 2002                                WORKING DRAFT                                       J3/02-007R3



           NOTE 9.35 (cont.)

           formatted input/output of all list items and unformatted input/output of list items other than
           those of derived types adhere to the above rule.


 1    If a list item of derived type in a formatted input/output statement is not processed by a user-defined
 2    derived-type input/output procedure, that list item is treated as if all of the components of the list item
 3    were specified in the list in component order; those components shall be accessible in the scoping unit
 4    containing the input/output statement and shall not be pointers or allocatable.

 5    If a derived-type list item is not treated as a list of its individual components, that list item's ultimate
 6    components shall not have the POINTER or ALLOCATABLE attribute unless that list item is processed
 7    by a user-defined derived-type input/output procedure.

 8    The scalar objects resulting when a data transfer statement's list items are expanded according to the
 9    rules in this section for handling array and derived-type list items are called effective items. Zero-sized
10    arrays and implied-DO lists with an iteration count of zero do not contribute to the effective list items.
11    A scalar character item of zero length is an effective list item.

           NOTE 9.36

           In a formatted input/output statement, edit descriptors are associated with effective list items,
           which are always scalar. The rules in 9.5.2 determine the set of effective list items corresponding
           to each actual list item in the statement. These rules may have to be applied repetitively until all
           of the effective list items are scalar items.


12    For an implied-DO, the loop initialization and execution is the same as for a DO construct (8.1.6.4).

13    An input/output list shall not contain an item of nondefault character type if the input/output statement
14    specifies an internal file.

           NOTE 9.37

           An example of an output list with an implied-DO is:


           WRITE (LP, FMT = '(10F8.2)') (LOG (A (I)), I = 1, N + 9, K), G



15    9.5.3        Execution of a data transfer input/output statement

16    Execution of a WRITE or PRINT statement for a file that does not exist creates the file unless an error
17    condition occurs.

18    The effect of executing a synchronous data transfer input/output statement shall be as if the following
19    operations were performed in the order specified:

20          (1)      Determine the direction of data transfer.

21          (2)      Identify the unit.

22          (3)      Perform a wait operation for all pending input/output operations for the unit. If an error,
23                   end-of-file, or end-of-record condition occurs during any of the wait operations, steps 4
24                   through 8 are skipped for the current data transfer statement.

25          (4)      Establish the format if one is specified.

26          (5)      Position the file prior to data transfer (9.2.3.2) unless the statement is a child data transfer
27                   statement (9.5.3.7).

28          (6)      Transfer data between the file and the entities specified by the input/output list (if any) or
29                   namelist.




      SEP 2002                                       WORKING DRAFT                                             193


      J3/02-007R3                                  WORKING DRAFT                                      SEP 2002



 1           (7)     Determine whether an error, end-of-file, or end-of-record condition has occurred.

 2           (8)     Position the file after data transfer (9.2.3.3) unless the statement is a child data transfer
 3                   statement (9.5.3.7).

 4           (9)     Cause any variable specified in a SIZE= specifier to become defined.

 5           (10)    If an error, end-of-file, or end-of-record condition occurred, processing continues as specified
 6                   in 9.10; otherwise any variable specified in an IOSTAT= specifier is assigned the value zero.

 7    The effect of executing an asynchronous data transfer input/output statement shall be as if the following
 8    operations were performed in the order specified:

 9           (1)     Determine the direction of data transfer.

10           (2)     Identify the unit.

11           (3)     Establish the format if one is specified.

12           (4)     Position the file prior to data transfer (9.2.3.2).

13           (5)     Establish the set of storage units identified by the input/output list. For a READ statement,
14                   this might require some or all of the data in the file to be read if an input variable is used
15                   in an implied-DO in the input/output list, as a subscript , substring-range, stride, or is
16                   otherwise referenced.

17           (6)     Initiate an asynchronous data transfer between the file and the entities specified by the
18                   input/output list (if any) or namelist. The asynchronous data transfer may complete (and
19                   an error, end-of-file, or end-of-record condition may occur) during the execution of this data
20                   transfer statement or during a later wait operation.

21           (7)     Determine whether an error, end-of-file, or end-of-record condition has occurred. The con-
22                   ditions may occur during the execution of this data transfer statement or during the corre-
23                   sponding wait operation, but not both.

24                   Also, any of these conditions that would have occurred during the corresponding wait oper-
25                   ation for a previously pending data transfer operation that does not have an ID= specifier
26                   may occur during the execution of this data transfer statement.

27           (8)     Position the file as if the data transfer had finished (9.2.3.3).

28           (9)     Cause any variable specified in a SIZE= specifier to become undefined.

29           (10)    If an error, end-of-file, or end-of-record condition occurred, processing continues as specified
30                   in 9.10; otherwise any variable specified in an IOSTAT= specifier is assigned the value zero.

31    For an asynchronous data transfer statement, the data transfers may occur during execution of the
32    statement, during execution of the corresponding wait operation, or anywhere between. The data transfer
33    operation is considered to be pending until a corresponding wait operation is performed.

34    For asynchronous output, a pending input/output storage sequence affector (9.5.1.4) shall not be rede-
35    fined, become undefined, or have its pointer association status changed.

36    For asynchronous input, a pending input/output storage sequence affector shall not be referenced, be-
37    come defined, become undefined, become associated with a dummy argument that has the VALUE
38    attribute, or have its pointer association status changed.

39    Error, end-of-file, and end-of-record conditions in an asynchronous data transfer operation may occur
40    during execution of either the data transfer statement or the corresponding wait operation. If an ID=
41    specifier does not appear in the initiating data transfer statement, the conditions may occur during the
42    execution of any subsequent data transfer or wait operation for the same unit. When a condition occurs
43    for a previously executed asynchronous data transfer statement, a wait operation is performed for all
44    pending data transfer operations on that unit. When a condition occurs during a subsequent statement,
45    any actions specified by IOSTAT=, IOMSG=, ERR=, END=, and EOR= specifiers for that statement
46    are taken.





      194                                     WORKING DRAFT                                           SEP 2002


      SEP 2002                                 WORKING DRAFT                                      J3/02-007R3



           NOTE 9.38

           Because end-of-file and error conditions for asynchronous data transfer statements without an
           ID= specifier may be reported by the processor during the execution of a subsequent data transfer
           statement, it may be impossible for the user to determine which input/output statement caused
           the condition. Reliably detecting which READ statement caused an end-of-file condition requires
           that all asynchronous READ statements for the unit include an ID= specifier.


 1    9.5.3.1    Direction of data transfer

 2    Execution of a READ statement causes values to be transferred from a file to the entities specified by
 3    the input list, if any, or specified within the file itself for namelist input. Execution of a WRITE or
 4    PRINT statement causes values to be transferred to a file from the entities specified by the output list
 5    and format specification, if any, or by the namelist-group-name for namelist output.


 6    9.5.3.2    Identifying a unit

 7    A data transfer input/output statement that contains an input/output control list includes a UNIT=
 8    specifier that identifies an external or internal unit. A READ statement that does not contain an
 9    input/output control list specifies a particular processor-dependent unit, which is the same as the unit
10    identified by * in a READ statement that contains an input/output control list. The PRINT statement
11    specifies some other processor-dependent unit, which is the same as the unit identified by * in a WRITE
12    statement. Thus, each data transfer input/output statement identifies an external or internal unit.

13    The unit identified by a data transfer input/output statement shall be connected to a file when execution
14    of the statement begins.

           NOTE 9.39

           The file may be preconnected.


15    9.5.3.3    Establishing a format

16    If the input/output control list contains * as a format, list-directed formatting is established. If namelist-
17    group-name appears, namelist formatting is established. If no format or namelist-group-name is spec-
18    ified, unformatted data transfer is established. Otherwise, the format specification identified by the
19    FMT= specifier is established.

20    On output, if an internal file has been specified, a format specification that is in the file or is associated
21    with the file shall not be specified.


22    9.5.3.4    Data transfer

23    Data are transferred between the file and the entities specified by the input/output list or namelist.
24    The list items are processed in the order of the input/output list for all data transfer input/output
25    statements except namelist formatted data transfer statements. The list items for a namelist input
26    statement are processed in the order of the entities specified within the input records. The list items
27    for a namelist output statement are processed in the order in which the variables are specified in the
28    namelist-group-object -list. Effective items are derived from the input/output list items as described in
29    9.5.2.

30    All values needed to determine which entities are specified by an input/output list item are determined
31    at the beginning of the processing of that item.

32    All values are transmitted to or from the entities specified by a list item prior to the processing of any
33    succeeding list item for all data transfer input/output statements.




      SEP 2002                                     WORKING DRAFT                                               195


      J3/02-007R3                                  WORKING DRAFT                                       SEP 2002



             NOTE 9.40

             In the example,


             READ (N) N, X (N)


             the old value of N identifies the unit, but the new value of N is the subscript of X.


 1    All values following the name= part of the namelist entity (10.10) within the input records are transmit-
 2    ted to the matching entity specified in the namelist-group-object -list prior to processing any succeeding
 3    entity within the input record for namelist input statements. If an entity is specified more than once
 4    within the input record during a namelist formatted data transfer input statement, the last occurrence
 5    of the entity specifies the value or values to be used for that entity.

 6    An input list item, or an entity associated with it, shall not contain any portion of an established format
 7    specification.

 8    If the input/output item is a pointer, data are transferred between the file and the associated target.

 9    If an internal file has been specified, an input/output list item shall not be in the file or associated with
10    the file.

             NOTE 9.41

             The file is a data object.


11    A DO variable becomes defined and its iteration count established at the beginning of processing of the
12    items that constitute the range of an io-implied-do.

13    On output, every entity whose value is to be transferred shall be defined.


14    9.5.3.4.1      Unformatted data transfer

15    During unformatted data transfer, data are transferred without editing between the file and the entities
16    specified by the input/output list. If the file is connected for sequential or direct access, exactly one
17    record is read or written.

18    Objects of intrinsic or derived types may be transferred by means of an unformatted data transfer
19    statement.

20    A value in the file is stored in a contiguous sequence of file storage units, beginning with the file storage
21    unit immediately following the current file position.

22    After each value is transferred, the current file position is moved to a point immediately after the last
23    file storage unit of the value.

24    On input from a file connected for sequential or direct access, the number of file storage units required
25    by the input list shall be less than or equal to the number of file storage units in the record.

26    On input, if the file storage units transferred do not contain a value with the same type and type
27    parameters as the input list entity, then the resulting value of the entity is processor-dependent except
28    in the following cases:

29            (1)    A complex list entity may correspond to two real values of the same kind stored in the file,
30                   or vice-versa.

31            (2)    A default character list entity of length n may correspond to n default characters stored in
32                   the file, regardless of the length parameters of the entities that were written to these storage
33                   units of the file. If the file is connected for stream input, the characters may have been



      196                                   WORKING DRAFT                                              SEP 2002


      SEP 2002                                WORKING DRAFT                                      J3/02-007R3



 1                 written by formatted stream output.

 2    On output to a file connected for unformatted direct access, the output list shall not specify more values
 3    than can fit into the record. If the file is connected for direct access and the values specified by the
 4    output list do not fill the record, the remainder of the record is undefined.

 5    If the file is connected for unformatted sequential access, the record is created with a length sufficient
 6    to hold the values from the output list. This length shall be one of the set of allowed record lengths for
 7    the file and shall not exceed the value specified in the RECL= specifier, if any, of the OPEN statement
 8    that established the connection.

 9    If the file is not connected for unformatted input/output, unformatted data transfer is prohibited.

10    The unit specified shall be an external unit.


11    9.5.3.4.2    Formatted data transfer

12    During formatted data transfer, data are transferred with editing between the file and the entities
13    specified by the input/output list or by the namelist-group-name. Format control is initiated and editing
14    is performed as described in Section 10.

15    The current record and possibly additional records are read or written.

16    Values may be transferred by means of a formatted data transfer statement to or from objects of intrinsic
17    or derived types. In the latter case, the transfer is in the form of values of intrinsic types to or from the
18    components of intrinsic types that ultimately comprise these structured objects unless the derived-type
19    list item is processed by a user-defined derived-type input/output procedure (9.5.3.7).

20    If the file is not connected for formatted input/output, formatted data transfer is prohibited.

21    During advancing input when the pad mode has the value NO, the input list and format specification
22    shall not require more characters from the record than the record contains.

23    During advancing input when the pad mode has the value YES, blank characters are supplied by the
24    processor if the input list and format specification require more characters from the record than the
25    record contains.

26    During nonadvancing input when the pad mode has the value NO, an end-of-record condition (9.10)
27    occurs if the input list and format specification require more characters from the record than the record
28    contains, and the record is complete (9.2.2.3). If the record is incomplete, an end-of-file condition occurs
29    instead of an end-of-record condition.

30    During nonadvancing input when the pad mode has the value YES, blank characters are supplied by the
31    processor if an input item and its corresponding data edit descriptor require more characters from the
32    record than the record contains. If the record is incomplete, an end-of-file condition occurs; otherwise
33    an end-of-record condition occurs.

34    If the file is connected for direct access, the record number is increased by one as each succeeding record
35    is read or written.

36    On output, if the file is connected for direct access or is an internal file and the characters specified by
37    the output list and format do not fill a record, blank characters are added to fill the record.

38    On output, the output list and format specification shall not specify more characters for a record than
39    have been specified by a RECL= specifier in the OPEN statement or the record length of an internal
40    file.





      SEP 2002                                     WORKING DRAFT                                              197


      J3/02-007R3                                  WORKING DRAFT                                       SEP 2002



 1    9.5.3.5       List-directed formatting

 2    If list-directed formatting has been established, editing is performed as described in 10.9.


 3    9.5.3.6       Namelist formatting

 4    If namelist formatting has been established, editing is performed as described in 10.10.

 5    Every allocatable namelist-group-object in the namelist group shall be allocated and every namelist-
 6    group-object that is a pointer shall be associated with a target. If a namelist-group-object is polymorphic
 7    or has an ultimate component that is allocatable or a pointer, that object shall be processed by a user-
 8    defined derived-type input/output procedure (9.5.3.7).


 9    9.5.3.7       User-defined derived-type input/output

10    User-defined derived-type input/output procedures allow a program to override the default handling of
11    derived-type objects and values in data transfer input/output statements described in 9.5.2.

12    A user-defined derived-type input/output procedure is a procedure accessible by a dtio-generic-spec
13    (12.3.2.1). A particular user-defined derived-type input/output procedure is selected as described in
14    9.5.3.7.3.


15    9.5.3.7.1      Executing user-defined derived-type input/output data transfers

16    If a derived-type input/output procedure is selected as specified in 9.5.3.7.3, the processor shall call the se-
17    lected user-defined derived-type input/output procedure for any appropriate data transfer input/output
18    statements executed in that scoping unit. The user-defined derived-type input/output procedure controls
19    the actual data transfer operations for the derived-type list item.

20    A data transfer statement that includes a derived-type list item and that causes a user-defined derived-
21    type input/output procedure to be invoked is called a parent data transfer statement. A data
22    transfer statement that is executed while a parent data transfer statement is being processed and that
23    specifies the unit passed into a user-defined derived-type input/output procedure is called a child data
24    transfer statement.

             NOTE 9.42

             A user-defined derived-type input/output procedure will usually contain child data transfer state-
             ments that read values from or write values to the current record or at the current file position.
             The effect of executing the user-defined derived-type input/output procedure is similar to that of
             substituting the list items from any child data transfer statements into the parent data transfer
             statement's list items, along with similar substitutions in the format specification.


             NOTE 9.43

             A particular execution of a READ, WRITE or PRINT statement can be both a parent and a
             child data transfer statement. A user-defined derived-type input/output procedure can indirectly
             call itself or another user-defined derived-type input/output procedure by executing a child data
             transfer statement containing a list item of derived type, where a matching interface is accessible
             for that derived type. If a user-defined derived-type input/output procedure calls itself indirectly
             in this manner, it shall be declared RECURSIVE.


25    A child data transfer statement is processed differently from a nonchild data transfer statement in the
26    following ways:


27       � Executing a child data transfer statement does not position the file prior to data transfer.



      198                                       WORKING DRAFT                                          SEP 2002


      SEP 2002                              WORKING DRAFT                                      J3/02-007R3



 1       � An unformatted child data transfer statement does not position the file after data transfer is
 2            complete.


 3    9.5.3.7.2    User-defined derived-type input/output procedures

 4    For a particular derived type and a particular set of kind type parameter values, there are four possible
 5    sets of characteristics for user-defined derived-type input/output procedures; one each for formatted
 6    input, formatted output, unformatted input, and unformatted output. The user need not supply all four
 7    procedures. The procedures are specified to be used for derived-type input/output by interface blocks
 8    (12.3.2.1) or by derived-type procedure bindings (4.5.1.5), with a dtio-generic-spec.

 9    In the four interfaces, which specify the characteristics of user-defined procedures for derived-type in-
10    put/output, the following syntax term is used:

11    R920      dtv-type-spec               is    TYPE( derived-type-spec )
12                                          or CLASS( derived-type-spec )

13    C935      (R920) If derived-type-spec specifies an extensible type, the CLASS keyword shall be used;
14              otherwise, the TYPE keyword shall be used.

15    C936      (R920) All nonkind type parameters of derived-type-spec shall be assumed.

16    If the generic-spec is READ (FORMATTED), the characteristics shall be the same as those specified by
17    the following interface:



18                 SUBROUTINE my_read_routine_formatted                           &
19                                                    (dtv,                       &
20                                                      unit,                     &
21                                                      iotype, v_list,           &
22                                                      iostat, iomsg)
23                    ! the derived-type value/variable
24                    dtv-type-spec , INTENT(INOUT) :: dtv
25                    INTEGER, INTENT(IN) :: unit ! unit number
26                    ! the edit descriptor string
27                    CHARACTER (LEN=*), INTENT(IN) :: iotype
28                    INTEGER, INTENT(IN) :: v_list(:)
29                    INTEGER, INTENT(OUT) :: iostat
30                    CHARACTER (LEN=*), INTENT(INOUT) :: iomsg
31                 END



32    If the generic-spec is READ (UNFORMATTED), the characteristics shall be the same as those specified
33    by the following interface:



34                 SUBROUTINE my_read_routine_unformatted                         &
35                                                    (dtv,                       &
36                                                      unit,                     &
37                                                      iostat, iomsg)
38                    ! the derived-type value/variable
39                    dtv-type-spec , INTENT(INOUT) :: dtv
40                    INTEGER, INTENT(IN) :: unit
41                    INTEGER, INTENT(OUT) :: iostat
42                    CHARACTER (LEN=*), INTENT(INOUT) :: iomsg
43                 END




      SEP 2002                                     WORKING DRAFT                                          199


      J3/02-007R3                                WORKING DRAFT                                   SEP 2002



 1    If the generic-spec is WRITE (FORMATTED), the characteristics shall be the same as those specified
 2    by the following interface:



 3                 SUBROUTINE my_write_routine_formatted                        &
 4                                                 (dtv,                        &
 5                                                  unit,                       &
 6                                                  iotype, v_list,             &
 7                                                  iostat, iomsg)
 8                   ! the derived-type value/variable
 9                   dtv-type-spec , INTENT(IN) :: dtv
10                   INTEGER, INTENT(IN) :: unit
11                   ! the edit descriptor string
12                   CHARACTER (LEN=*), INTENT(IN) :: iotype
13                   INTEGER, INTENT(IN) :: v_list(:)
14                   INTEGER, INTENT(OUT) :: iostat
15                   CHARACTER (LEN=*), INTENT(INOUT) :: iomsg
16                 END



17    If the generic-spec is WRITE (UNFORMATTED), the characteristics shall be the same as those specified
18    by the following interface:



19                 SUBROUTINE my_write_routine_unformatted                      &
20                                                 (dtv,                        &
21                                                  unit,                       &
22                                                  iostat, iomsg)
23                   ! the derived-type value/variable
24                   dtv-type-spec , INTENT(IN) :: dtv
25                   INTEGER, INTENT(IN) :: unit
26                   INTEGER, INTENT(OUT) :: iostat
27                   CHARACTER (LEN=*), INTENT(INOUT) :: iomsg
28                 END



29    The actual specific procedure names (the my ... routine ... procedure names above) are not signifi-
30    cant. In the discussion here and elsewhere, the dummy arguments in these interfaces are referred by the
31    names given above; the names are, however, arbitrary.

32    In addition to the characteristics specified by the above interfaces, the dtv dummy argument may
33    optionally have the VOLATILE attribute.

34    When a user-defined derived-type input/output procedure is invoked, the processor shall pass a unit
35    argument that has a value as follows:


36       � If the parent data transfer statement uses a file-unit-number , the value of the unit argument shall
37           be that of the file-unit-number .

38       � If the parent data transfer statement is a WRITE statement with an asterisk unit or a PRINT
39           statement, the unit argument shall have the same value as the OUTPUT UNIT named constant
40           of the ISO FORTRAN ENV intrinsic module (13.8.3).

41       � If the parent data transfer statement is a READ statement with an asterisk unit or a READ
42           statement without an io-control-spec-list, the unit argument shall have the same value as the
43           INPUT UNIT named constant of the ISO FORTRAN ENV intrinsic module (13.8.3).




      200                                  WORKING DRAFT                                         SEP 2002


      SEP 2002                               WORKING DRAFT                                         J3/02-007R3



 1       � Otherwise the parent data transfer statement must access an internal file, in which case the unit
 2          argument shall have a processor-dependent negative value.


           NOTE 9.44

           Because the unit argument value will be negative when the parent data transfer statement speci-
           fies an internal file, a user-defined derived-type input/output procedure should not execute an IN-
           QUIRE statement without checking that the unit argument is nonnegative or is equal to one of the
           named constants INPUT UNIT, OUTPUT UNIT, or ERROR UNIT of the ISO FORTRAN ENV
           intrinsic module(13.8.3.1).


 3    For formatted data transfer, the processor shall pass an iotype argument that has a value as follows:


 4       � "LISTDIRECTED" if the parent data transfer statement specified list directed formatting,

 5       � "NAMELIST" if the parent data transfer statement specified namelist formatting, or

 6       � "DT" concatenated with the char-literal-constant , if any, of the edit descriptor, if the parent data
 7          transfer statement contained a format specification and the list item's corresponding edit descriptor
 8          was a DT edit descriptor.


 9    If the parent data transfer statement is a READ statement, the dtv dummy argument is argument
10    associated with the effective list item that caused the user-defined derived-type input procedure to be
11    invoked, as if the effective list item were an actual argument in this procedure reference (2.5.6).

12    If the parent data transfer statement is a WRITE or PRINT statement, the processor shall provide the
13    value of the effective list item in the dtv dummy argument.

14    If the v -list of the edit descriptor appears in the parent data transfer statement, the processor shall
15    provide the values from it in the v list dummy argument, with the same number of elements in the
16    same order as v -list. If there is no v -list in the edit descriptor or if the data transfer statement specifies
17    list-directed or namelist formatting, the processor shall provide v list as a zero-sized array.

           NOTE 9.45

           The user's procedure may chose to interpret an element of the v list argument as a field width,
           but this is not required. If it does, it would be appropriate to fill an output field with "*"s if the
           width is too small.


18    The iostat argument is used to report whether an error, end-of-record, or end-of-file condition (9.10)
19    occurs. If an error condition occurs, the user-defined derived-type input/output procedure shall assign
20    a positive value to the iostat argument. Otherwise, if an end-of-file condition occurs, the user-defined
21    derived-type input procedure shall assign the value of the named constant IOSTAT END (13.8.3.2.1)
22    to the iostat argument. Otherwise, if an end-of-record condition occurs, the user-defined derived-type
23    input procedure shall assign the value of the named constant IOSTAT EOR (13.8.3.2.2) to iostat.
24    Otherwise, the user-defined derived-type input/output procedure shall assign the value zero to the
25    iostat argument.

26    If the user-defined derived-type input/output procedure returns a nonzero value for the iostat argument,
27    the procedure shall also return an explanatory message in the iomsg argument. Otherwise, the procedure
28    shall not change the value of the iomsg argument.

           NOTE 9.46

           The values of the iostat and iomsg arguments set in a user-defined derived-type input/output
           procedure need not be passed to all of the parent data transfer statements.




      SEP 2002                                      WORKING DRAFT                                               201


      J3/02-007R3                                  WORKING DRAFT                                    SEP 2002



 1    If the iostat argument of the user-defined derived-type input/output procedure has a nonzero value
 2    when that procedure returns, and the processor therefore terminates execution of the program as de-
 3    scribed in 9.10, the processor shall make the value of the iomsg argument available in a processor-
 4    dependent manner.

 5    When a parent READ statement is active, an input/output statement shall not read from any external
 6    unit other than the one specified by the dummy argument unit and shall not perform output to any
 7    external unit.

 8    When a parent WRITE or PRINT statement is active, an input/output statement shall not perform
 9    output to any external unit other than the one specified by the dummy argument unit and shall not
10    read from any external unit.

11    When a parent data transfer statement is active, a data transfer statement that specifies an internal file
12    is permitted.

13    OPEN, CLOSE, BACKSPACE, ENDFILE, and REWIND statements shall not be executed while a
14    parent data transfer statement is active.

15    A user-defined derived-type input/output procedure may use a FORMAT with a DT edit descriptor for
16    handling a component of the derived type that is itself of a derived type. A child data transfer statement
17    that is a list directed or namelist input/output statement may contain a list item of derived type.

18    Because a child data transfer statement does not position the file prior to data transfer, the child data
19    transfer statement starts transferring data from where the file was positioned by the parent data transfer
20    statement's most recently processed effective list item or record positioning edit descriptor. This is not
21    necessarily at the beginning of a record.

22    A record positioning edit descriptor, such as TL and TR, used on unit by a child data transfer statement
23    shall not cause the record position to be positioned before the record position at the time the user-defined
24    derived-type input/output procedure was invoked.

             NOTE 9.47

             A robust user-defined derived-type input/output procedure may wish to use INQUIRE to deter-
             mine the settings of BLANK=, PAD=, ROUND=, DECIMAL=, and DELIM= for an external
             unit. The INQUIRE provides values as specified in 9.9.


25    Neither a parent nor child data transfer statement shall be asynchronous.

26    A user-defined derived-type input/output procedure, and any procedures invoked therefrom, shall not
27    define, nor cause to become undefined, any storage location referenced by any input/output list item,
28    the corresponding format, or any specifer in any active parent data transfer statement, except through
29    the dtv argument.

             NOTE 9.48

             A child data transfer statement shall not specify the ID=, POS=, or REC= specifiers in an
             input/output control list.


30    9.5.3.7.3    Resolving derived-type input/output procedure references

31    A suitable generic interface for user-defined derived-type input/output of an effective item is one that
32    has a dtio-generic-spec that is appropriate to the direction (read or write) and form (formatted or
33    unformatted) of the data transfer as specified in 9.5.3.7, and has a specific interface whose dtv argument
34    is compatible with the effective item according to the rules for argument association in 12.4.1.2.





      202                                  WORKING DRAFT                                            SEP 2002


      SEP 2002                                      WORKING DRAFT                                       J3/02-007R3



 1    When an effective item (9.5.2) that is of derived-type is encountered during a data transfer, user-defined
 2    derived-type input/output occurs if both of the following conditions are true:

 3              (1)      The circumstances of the input/output are such that user-defined derived-type input/output
 4                       is permitted; that is, either

 5                       (a)    the transfer was initiated by a list-directed, namelist, or unformatted input/output
 6                              statement, or

 7                       (b)    a format specification is supplied for the input/output statement, and the edit de-
 8                              scriptor corresponding to the effective item is a DT edit descriptor.

 9              (2)      A suitable user-defined derived-type input/output procedure is available; that is, either

10                       (a)    the declared type of the effective item has a suitable type-bound generic binding, or

11                       (b)    a suitable generic interface is accessible.


12    If (2a) is true, the procedure referenced is determined as for explicit type-bound procedure references
13    (12.4); that is, the binding with the appropriate specific interface is located in the declared type of the
14    effective item, and the corresponding binding in the dynamic type of the effective item is selected.

15    If (2a) is false and (2b) is true, the reference is to the procedure identified by the appropriate specific
16    interface in the interface block. This reference shall not be to a dummy procedure or dummy procedure
17    pointer that is not present, or a disassociated procedure pointer.


18    9.5.4            Termination of data transfer statements

19    Termination of an input/output data transfer statement occurs when any of the following conditions are
20    met:

21              (1)      Format processing encounters a data edit descriptor and there are no remaining elements
22                       in the input-item-list or output-item-list.

23              (2)      Unformatted or list-directed data transfer exhausts the input-item-list or output-item-list.

24              (3)      Namelist output exhausts the namelist-group-object -list.

25              (4)      An error condition occurs.

26              (5)      An end-of-file condition occurs.

27              (6)      A slash (/) is encountered as a value separator (10.9, 10.10) in the record being read during
28                       list-directed or namelist input.

29              (7)      An end-of-record condition occurs during execution of a nonadvancing input statement
30                       (9.10).


31    9.6         Waiting on pending data transfer

32    Execution of an asynchronous data transfer statement in which neither an error, end-of-record, nor end-
33    of-file condition occurs initiates a pending data transfer operation. There may be multiple pending data
34    transfer operations for the same or multiple units simultaneously. A pending data transfer operation
35    remains pending until a corresponding wait operation is performed. A wait operation may be performed
36    by a WAIT, INQUIRE, CLOSE, or file positioning statement.


37    9.6.1            WAIT statement

38    A WAIT statement performs a wait operation for specified pending asynchronous data transfer opera-
39    tions.

              NOTE 9.49

              The CLOSE, INQUIRE, and file positioning statements may also perform wait operations.




      SEP 2002                                               WORKING DRAFT                                       203


      J3/02-007R3                                   WORKING DRAFT                                     SEP 2002



 1    R921      wait-stmt                     is    WAIT (wait-spec-list )
 2    R922      wait-spec                     is    [ UNIT = ] file-unit-number
 3                                            or END = label
 4                                            or EOR = label
 5                                            or ERR = label
 6                                            or ID = scalar-int-variable
 7                                            or IOMSG = iomsg-variable
 8                                            or IOSTAT = scalar-int-variable

 9    C937      (R922) No specifier shall appear more than once in a given wait-spec-list.

10    C938      (R922) A file-unit-number shall be specified; if the optional characters UNIT= are omitted, the
11              file-unit-number shall be the first item in the wait-spec-list.

12    C939      (R922) The label in the ERR=, EOR=, or END= specifier shall be the statement label of a
13              branch target statement that appears in the same scoping unit as the WAIT statement.

14    The IOSTAT=, ERR=, EOR=, END=, and IOMSG= specifiers are described in 9.10.

15    The value of the variable specified in the ID= specifier shall be the identifier of a pending data transfer
16    operation for the specified unit. If the ID= specifier appears, a wait operation for the specified data
17    transfer operation is performed. If the ID= specifier is omitted, wait operations for all pending data
18    transfers for the specified unit are performed.

19    Execution of a WAIT statement specifying a unit that does not exist, has no file connected to it, or was
20    not opened for asynchronous input/output is permitted, provided that the WAIT statement has no ID=
21    specifier; such a WAIT statement does not cause an error or end-of-file condition to occur.

             NOTE 9.50

             An EOR= specifier has no effect if the pending data transfer operation is not a nonadvancing read.
             And END= specifier has no effect if the pending data transfer operation is not a READ.


22    9.6.2      Wait operation

23    A wait operation terminates a pending data transfer operation. Each wait operation terminates only a
24    single data transfer operation, although a single statement may perform multiple wait operations.

25    If the actual data transfer is not yet complete, the wait operation first waits for its completion. If the
26    data transfer operation is an input operation that completed without error, the storage units of the
27    input/output storage sequence then become defined with the values as described in 9.5.1.14 and 9.5.3.4.

28    If any error, end-of-file, or end-of-record conditions occur, the applicable actions specified by the IO-
29    STAT=, IOMSG=, ERR=, END=, and EOR= specifiers of the statement that performs the wait oper-
30    ation are taken.

31    If an error or end-of-file condition occurs during a wait operation for a unit, the processor performs a
32    wait operation for all pending data transfer operations for that unit.

             NOTE 9.51

             Error, end-of-file, and end-of-record conditions may be raised either during the data transfer state-
             ment that initiates asynchronous input/output, a subsequent asynchronous data transfer statement
             for the same unit, or during the wait operation. If such conditions are raised during a data transfer
             statement, they trigger actions according to the IOSTAT=, ERR=, END=, and EOR= specifiers
             of that statement; if they are raised during the wait operation, the actions are in accordance with
             the specifiers of the statement that performs the wait operation.




      204                                   WORKING DRAFT                                             SEP 2002


      SEP 2002                                WORKING DRAFT                                      J3/02-007R3



 1    After completion of the wait operation, the data transfer operation and its input/output storage sequence
 2    are no longer considered to be pending.


 3    9.7       File positioning statements

 4    R923      backspace-stmt                is    BACKSPACE file-unit-number
 5                                            or BACKSPACE ( position-spec-list )
 6    R924      endfile-stmt                   is    ENDFILE file-unit-number
 7                                            or ENDFILE ( position-spec-list )
 8    R925      rewind-stmt                   is    REWIND file-unit-number
 9                                            or REWIND ( position-spec-list )

10    A file that is connected for direct access shall not be referred to by a BACKSPACE, ENDFILE, or
11    REWIND statement. A file that is connected for unformatted stream access shall not be referred to by a
12    BACKSPACE statement. A file that is connected with an ACTION= specifier having the value READ
13    shall not be referred to by an ENDFILE statement.

14    R926      position-spec                 is    [ UNIT = ] file-unit-number
15                                            or IOMSG = iomsg-variable
16                                            or IOSTAT = scalar-int-variable
17                                            or ERR = label

18    C940      (R926) No specifier shall appear more than once in a given position-spec-list.

19    C941      (R926) A file-unit-number shall be specified; if the optional characters UNIT= are omitted, the
20              file-unit-number shall be the first item in the position-spec-list.

21    C942      (R926) The label in the ERR= specifier shall be the statement label of a branch target statement
22              that appears in the same scoping unit as the file positioning statement.

23    The IOSTAT=, ERR=, and IOMSG= specifiers are described in 9.10.

24    Execution of a file positioning statement performs a wait operation for all pending asynchronous data
25    transfer operations for the specified unit.


26    9.7.1      BACKSPACE statement

27    Execution of a BACKSPACE statement causes the file connected to the specified unit to be positioned
28    before the current record if there is a current record, or before the preceding record if there is no current
29    record. If the file is at its initial point, the position of the file is not changed.

             NOTE 9.52

             If the preceding record is an endfile record, the file is positioned before the endfile record.


30    If a BACKSPACE statement causes the implicit writing of an endfile record, the file is positioned before
31    the record that precedes the endfile record.

32    Backspacing a file that is connected but does not exist is prohibited.

33    Backspacing over records written using list-directed or namelist formatting is prohibited.

             NOTE 9.53

             An example of a BACKSPACE statement is:





      SEP 2002                                       WORKING DRAFT                                            205


      J3/02-007R3                                    WORKING DRAFT                                     SEP 2002



             NOTE 9.53 (cont.)

             BACKSPACE (10, ERR = 20)



 1    9.7.2        ENDFILE statement

 2    Execution of an ENDFILE statement for a file connected for sequential access writes an endfile record
 3    as the next record of the file. The file is then positioned after the endfile record, which becomes the last
 4    record of the file. If the file also may be connected for direct access, only those records before the endfile
 5    record are considered to have been written. Thus, only those records may be read during subsequent
 6    direct access connections to the file.

 7    After execution of an ENDFILE statement for a file connected for sequential access, a BACKSPACE
 8    or REWIND statement shall be used to reposition the file prior to execution of any data transfer
 9    input/output statement or ENDFILE statement.

10    Execution of an ENDFILE statement for a file connected for stream access causes the terminal point of
11    the file to become equal to the current file position. Only file storage units before the current position are
12    considered to have been written; thus only those file storage units may be subsequently read. Subsequent
13    stream output statements may be used to write further data to the file.

14    Execution of an ENDFILE statement for a file that is connected but does not exist creates the file; if
15    the file is connected for sequential access, it is created prior to writing the endfile record.

             NOTE 9.54

             An example of an ENDFILE statement is:


             ENDFILE K



16    9.7.3        REWIND statement

17    Execution of a REWIND statement causes the specified file to be positioned at its initial point.

             NOTE 9.55

             If the file is already positioned at its initial point, execution of this statement has no effect on the
             position of the file.


18    Execution of a REWIND statement for a file that is connected but does not exist is permitted and has
19    no effect.

             NOTE 9.56

             An example of a REWIND statement is:


             REWIND 10



20    9.8       FLUSH statement

21    The form of the FLUSH statement is:

22    R927      flush-stmt                      is    FLUSH file-unit-number
23                                             or FLUSH ( flush-spec-list )
24    R928      flush-spec                      is    [UNIT =] file-unit-number




      206                                   WORKING DRAFT                                              SEP 2002


      SEP 2002                               WORKING DRAFT                                      J3/02-007R3



 1                                           or IOSTAT = scalar-int-variable
 2                                           or IOMSG = iomsg-variable
 3                                           or ERR = label

 4    C943      (R928) No specifier shall appear more than once in a given flush-spec-list.

 5    C944      (R928) A file-unit-number shall be specified; if the optional characters UNIT= are omitted from
 6              the unit specifier, the file-unit-number shall be the first item in the flush-spec-list.

 7    C945      (R928) The label in the ERR= specifier shall be the statement label of a branch target statement
 8              that appears in the same scoping unit as the flush statement.

 9    The IOSTAT=, IOMSG= and ERR= specifiers are described in 9.10. The IOSTAT= variable shall be
10    set to a processor-dependent positive value if an error occurs, to zero if the processor-dependent flush
11    operation was successful, or to a processor-dependent negative value to indicate a processor-dependent
12    condition such as the flush operation is not appropriate for the unit specified.

             NOTE 9.57

             The negative values for the IOSTAT= variable allow a flush operation on a unit where it is
             ineffective or inappropriate to be treated as a "harmless condition" that does not require an error
             to occur.


13    Execution of a FLUSH statement causes data written to an external file to be available to other processes,
14    or causes data placed in an external file by means other than Fortran to be available to a READ
15    statement. The action is processor dependent.

16    Execution of a FLUSH statement for a file that is connected but does not exist is permitted and has no
17    effect. A FLUSH statement has no effect on file position.

             NOTE 9.58

             Since this standard does not specify the mechanism of file storage, the exact meaning of the flush
             operation is left vague. The intention is that the flush operation should make all data written
             to a file available to other processes or devices, or make data recently added to a file by other
             processes or devices available to the program via a subsequent read operation. This is commonly
             called "flushing I/O buffers".


             NOTE 9.59

             An example of a FLUSH statement is:


             FLUSH( 10, ERR=20)



18    9.9       File inquiry

19    The INQUIRE statement may be used to inquire about properties of a particular named file or of the
20    connection to a particular unit. There are three forms of the INQUIRE statement: inquire by file,
21    which uses the FILE= specifier, inquire by unit, which uses the UNIT= specifier, and inquire by
22    output list, which uses only the IOLENGTH= specifier. All specifier value assignments are performed
23    according to the rules for assignment statements.

24    An INQUIRE statement may be executed before, while, or after a file is connected to a unit. All values
25    assigned by an INQUIRE statement are those that are current at the time the statement is executed.

26    R929      inquire-stmt                 is    INQUIRE ( inquire-spec-list )




      SEP 2002                                      WORKING DRAFT                                          207


      J3/02-007R3                                 WORKING DRAFT                                    SEP 2002



 1                                          or INQUIRE ( IOLENGTH = scalar-int-variable )
 2                                                  output-item-list

             NOTE 9.60

             Examples of INQUIRE statements are:


             INQUIRE (IOLENGTH = IOL) A (1:N)
             INQUIRE (UNIT = JOAN, OPENED = LOG_01, NAMED = LOG_02, &
                FORM = CHAR_VAR, IOSTAT = IOS)



 3    9.9.1     Inquiry specifiers

 4    Unless constrained, the following inquiry specifiers may be used in either of the inquire by file or inquire
 5    by unit forms of the INQUIRE statement:

 6    R930      inquire-spec                is    [ UNIT = ] file-unit-number
 7                                          or FILE = file-name-expr
 8                                          or ACCESS = scalar-default-char-variable
 9                                          or ACTION = scalar-default-char-variable
10                                          or ASYNCHRONOUS = scalar-default-char-variable
11                                          or BLANK = scalar-default-char-variable
12                                          or DECIMAL = scalar-default-char-variable
13                                          or DELIM = scalar-default-char-variable
14                                          or DIRECT = scalar-default-char-variable
15                                          or ERR = label
16                                          or EXIST = scalar-default-logical-variable
17                                          or FORM = scalar-default-char-variable
18                                          or FORMATTED = scalar-default-char-variable
19                                          or ID = scalar-int-variable
20                                          or IOMSG = iomsg-variable
21                                          or IOSTAT = scalar-int-variable
22                                          or NAME = scalar-default-char-variable
23                                          or NAMED = scalar-default-logical-variable
24                                          or NEXTREC = scalar-int-variable
25                                          or NUMBER = scalar-int-variable
26                                          or OPENED = scalar-default-logical-variable
27                                          or PAD = scalar-default-char-variable
28                                          or PENDING = scalar-default-logical-variable
29                                          or POS = scalar-int-variable
30                                          or POSITION = scalar-default-char-variable
31                                          or READ = scalar-default-char-variable
32                                          or READWRITE = scalar-default-char-variable
33                                          or RECL = scalar-int-variable
34                                          or ROUND = scalar-default-char-variable
35                                          or SEQUENTIAL = scalar-default-char-variable
36                                          or SIGN = scalar-default-char-variable
37                                          or SIZE = scalar-int-variable
38                                          or STREAM = scalar-default-char-variable
39                                          or UNFORMATTED = scalar-default-char-variable
40                                          or WRITE = scalar-default-char-variable

41    C946      (R930) No specifier shall appear more than once in a given inquire-spec-list.

42    C947      (R930) An inquire-spec-list shall contain one FILE= specifier or one UNIT= specifier, but not




      208                                 WORKING DRAFT                                            SEP 2002


      SEP 2002                                WORKING DRAFT                                      J3/02-007R3



 1               both.

 2    C948       (R930) In the inquire by unit form of the INQUIRE statement, if the optional characters UNIT=
 3               are omitted, the file-unit-number shall be the first item in the inquire-spec-list.

 4    C949       (R930) If an ID= specifier appears, a PENDING= specifier shall also appear.

 5    The value of file-unit-number shall be nonnegative or equal to one of the named constants INPUT UNIT,
 6    OUTPUT UNIT, or ERROR UNIT of the ISO FORTRAN ENV intrinsic module (13.8.3.1).

 7    When a returned value of a specifier other than the NAME= specifier is of type character, the value
 8    returned is in upper case.

 9    If an error condition occurs during execution of an INQUIRE statement, all of the inquiry specifier
10    variables become undefined, except for variables in the IOSTAT= and IOMSG= specifiers (if any).

11    The IOSTAT=, ERR=, and IOMSG= specifiers are described in 9.10.


12    9.9.1.1     FILE= specifier in the INQUIRE statement

13    The value of the file-name-expr in the FILE= specifier specifies the name of the file being inquired about.
14    The named file need not exist or be connected to a unit. The value of the file-name-expr shall be of a
15    form acceptable to the processor as a file name. Any trailing blanks are ignored. The interpretation of
16    case is processor dependent.


17    9.9.1.2     ACCESS= specifier in the INQUIRE statement

18    The scalar-default-char-variable in the ACCESS= specifier is assigned the value SEQUENTIAL if the
19    file is connected for sequential access, DIRECT if the file is connected for direct access, or STREAM if
20    the file is connected for stream access. If there is no connection, it is assigned the value UNDEFINED.


21    9.9.1.3     ACTION= specifier in the INQUIRE statement

22    The scalar-default-char-variable in the ACTION= specifier is assigned the value READ if the file is
23    connected for input only, WRITE if the file is connected for output only, and READWRITE if it
24    is connected for both input and output. If there is no connection, the scalar-default-char-variable is
25    assigned the value UNDEFINED.


26    9.9.1.4     ASYNCHRONOUS= specifier in the INQUIRE statement

27    The scalar-default-char-variable in the ASYNCHRONOUS= specifier is assigned the value YES if the
28    file is connected and asynchronous input/output on the unit is allowed; it is assigned the value NO if the
29    file is connected and asynchronous input/output on the unit is not allowed. If there is no connection,
30    the scalar-default-char-variable is assigned the value UNDEFINED.


31    9.9.1.5     BLANK= specifier in the INQUIRE statement

32    The scalar-default-char-variable in the BLANK= specifier is assigned the value ZERO or NULL, corre-
33    sponding to the blank interpretation mode in effect for a connection for formatted input/output. If there
34    is no connection, or if the connection is not for formatted input/output, the scalar-default-char-variable
35    is assigned the value UNDEFINED.


36    9.9.1.6     DECIMAL= specifier in the INQUIRE statement

37    The scalar-default-char-variable in the DECIMAL= specifier is assigned the value COMMA or POINT,
38    corresponding to the decimal edit mode in effect for a connection for formatted input/output. If there




      SEP 2002                                      WORKING DRAFT                                          209


      J3/02-007R3                                 WORKING DRAFT                                    SEP 2002



 1    is no connection, or if the connection is not for formatted input/output, the scalar-default-char-variable
 2    is assigned the value UNDEFINED.


 3    9.9.1.7     DELIM= specifier in the INQUIRE statement

 4    The scalar-default-char-variable in the DELIM= specifier is assigned the value APOSTROPHE, QUOTE,
 5    or NONE, corresponding to the delimiter mode in effect for a connection for formatted input/output.
 6    If there is no connection or if the connection is not for formatted input/output, the scalar-default-char-
 7    variable is assigned the value UNDEFINED.


 8    9.9.1.8     DIRECT= specifier in the INQUIRE statement

 9    The scalar-default-char-variable in the DIRECT= specifier is assigned the value YES if DIRECT is
10    included in the set of allowed access methods for the file, NO if DIRECT is not included in the set of
11    allowed access methods for the file, and UNKNOWN if the processor is unable to determine whether or
12    not DIRECT is included in the set of allowed access methods for the file.


13    9.9.1.9     EXIST= specifier in the INQUIRE statement

14    Execution of an INQUIRE by file statement causes the scalar-default-logical-variable in the EXIST=
15    specifier to be assigned the value true if there exists a file with the specified name; otherwise, false is
16    assigned. Execution of an INQUIRE by unit statement causes true to be assigned if the specified unit
17    exists; otherwise, false is assigned.


18    9.9.1.10     FORM= specifier in the INQUIRE statement

19    The scalar-default-char-variable in the FORM= specifier is assigned the value FORMATTED if the
20    file is connected for formatted input/output, and is assigned the value UNFORMATTED if the file is
21    connected for unformatted input/output. If there is no connection, it is assigned the value UNDEFINED.


22    9.9.1.11     FORMATTED= specifier in the INQUIRE statement

23    The scalar-default-char-variable in the FORMATTED= specifier is assigned the value YES if FORMAT-
24    TED is included in the set of allowed forms for the file, NO if FORMATTED is not included in the set
25    of allowed forms for the file, and UNKNOWN if the processor is unable to determine whether or not
26    FORMATTED is included in the set of allowed forms for the file.


27    9.9.1.12     ID= specifier in the INQUIRE statement

28    The value of the variable specified in the ID= specifier shall be the identifier of a pending data transfer
29    operation for the specified unit. This specifier interacts with the PENDING= specifier (9.9.1.19).


30    9.9.1.13     NAME= specifier in the INQUIRE statement

31    The scalar-default-char-variable in the NAME= specifier is assigned the value of the name of the file if
32    the file has a name; otherwise, it becomes undefined.

             NOTE 9.61

             If this specifier appears in an INQUIRE by file statement, its value is not necessarily the same as
             the name given in the FILE= specifier. However, the value returned shall be suitable for use as
             the value of the file-name-expr in the FILE= specifier in an OPEN statement.

             The processor may return a file name qualified by a user identification, device, directory, or other
             relevant information.





      210                                      WORKING DRAFT                                       SEP 2002


      SEP 2002                              WORKING DRAFT                                       J3/02-007R3



 1    The case of the characters assigned to scalar-default-char-variable is processor dependent.


 2    9.9.1.14    NAMED= specifier in the INQUIRE statement

 3    The scalar-default-logical-variable in the NAMED= specifier is assigned the value true if the file has a
 4    name; otherwise, it is assigned the value false.


 5    9.9.1.15    NEXTREC= specifier in the INQUIRE statement

 6    The scalar-int-variable in the NEXTREC= specifier is assigned the value n + 1, where n is the record
 7    number of the last record read from or written to the file connected for direct access. If the file is con-
 8    nected but no records have been read or written since the connection, the scalar-int-variable is assigned
 9    the value 1. If the file is not connected for direct access or if the position of the file is indeterminate
10    because of a previous error condition, the scalar-int-variable becomes undefined. If there are pending
11    data transfer operations for the specified unit, the value assigned is computed as if all the pending data
12    transfers had already completed.


13    9.9.1.16    NUMBER= specifier in the INQUIRE statement

14    The scalar-int-variable in the NUMBER= specifier is assigned the value of the external unit number of
15    the unit that is connected to the file. If there is no unit connected to the file, the value �1 is assigned.


16    9.9.1.17    OPENED= specifier in the INQUIRE statement

17    Execution of an INQUIRE by file statement causes the scalar-default-logical-variable in the OPENED=
18    specifier to be assigned the value true if the file specified is connected to a unit; otherwise, false is
19    assigned. Execution of an INQUIRE by unit statement causes the scalar-default-logical-variable to be
20    assigned the value true if the specified unit is connected to a file; otherwise, false is assigned.


21    9.9.1.18    PAD= specifier in the INQUIRE statement

22    The scalar-default-char-variable in the PAD= specifier is assigned the value YES or NO, corresponding
23    to the pad mode in effect for a connection for formatted input/output. If there is no connection or if
24    the connection is not for formatted input/output, the scalar-default-char-variable is assigned the value
25    UNDEFINED.


26    9.9.1.19    PENDING= specifier in the INQUIRE statement

27    The PENDING= specifier is used to determine whether or not previously pending asynchronous data
28    transfers are complete. A data transfer operation is previously pending if it is pending at the beginning
29    of execution of the INQUIRE statement.

30    The value of the variable specified in the ID= specifier (9.9.1.12) shall be the identifier of a pending
31    data transfer operation for the specified unit. If an ID= specifier appears and the specified data transfer
32    operation is complete, then the variable specified in the PENDING= specifier is assigned the value false
33    and the INQUIRE statement performs the wait operation for the specified data transfer.

34    If the ID= specifier is omitted and all previously pending data transfer operations for the specified unit
35    are complete, then the variable specified in the PENDING= specifier is assigned the value false and the
36    INQUIRE statement performs wait operations for all previously pending data transfers for the specified
37    unit.

38    In all other cases, the variable specified in the PENDING= specifier is assigned the value true and no
39    wait operations are performed; in this case the previously pending data transfers remain pending after
40    the execution of the INQUIRE statement.




      SEP 2002                                    WORKING DRAFT                                             211


      J3/02-007R3                                 WORKING DRAFT                                      SEP 2002



             NOTE 9.62

             The processor has considerable flexibility in defining when it considers a transfer to be complete.
             Any of the following approaches could be used:

                   (1)    The INQUIRE statement could consider an asynchronous data transfer to be incom-
                          plete until after the corresponding wait operation. In this case PENDING= would
                          always return true unless there were no previously pending data transfers for the unit.

                   (2)    The INQUIRE statement could wait for all specified data transfers to complete and
                          then always return false for PENDING=.

                   (3)    The INQUIRE statement could actually test the state of the specified data transfer
                          operations.



 1    9.9.1.20    POS= specifier in the INQUIRE statement

 2    The scalar-int-variable in the POS= specifier is assigned the number of the file storage unit immediately
 3    following the current position of a file connected for stream access. If the file is positioned at its terminal
 4    position, the variable is assigned a value one greater than the number of the highest-numbered file storage
 5    unit in the file. If the file is not connected for stream access or if the position of the file is indeterminate
 6    because of previous error conditions, the variable becomes undefined.


 7    9.9.1.21    POSITION= specifier in the INQUIRE statement

 8    The scalar-default-char-variable in the POSITION= specifier is assigned the value REWIND if the file
 9    is connected by an OPEN statement for positioning at its initial point, APPEND if the file is connected
10    for positioning before its endfile record or at its terminal point, and ASIS if the file is connected without
11    changing its position. If there is no connection or if the file is connected for direct access, the scalar-
12    default-char-variable is assigned the value UNDEFINED. If the file has been repositioned since the
13    connection, the scalar-default-char-variable is assigned a processor-dependent value, which shall not be
14    REWIND unless the file is positioned at its initial point and shall not be APPEND unless the file is
15    positioned so that its endfile record is the next record or at its terminal point if it has no endfile record.


16    9.9.1.22    READ= specifier in the INQUIRE statement

17    The scalar-default-char-variable in the READ= specifier is assigned the value YES if READ is included
18    in the set of allowed actions for the file, NO if READ is not included in the set of allowed actions for
19    the file, and UNKNOWN if the processor is unable to determine whether or not READ is included in
20    the set of allowed actions for the file.


21    9.9.1.23    READWRITE= specifier in the INQUIRE statement

22    The scalar-default-char-variable in the READWRITE= specifier is assigned the value YES if READ-
23    WRITE is included in the set of allowed actions for the file, NO if READWRITE is not included in the
24    set of allowed actions for the file, and UNKNOWN if the processor is unable to determine whether or
25    not READWRITE is included in the set of allowed actions for the file.


26    9.9.1.24    RECL= specifier in the INQUIRE statement

27    The scalar-int-variable in the RECL= specifier is assigned the value of the record length of a file con-
28    nected for direct access, or the value of the maximum record length for a file connected for sequential
29    access. If the file is connected for formatted input/output, the length is the number of characters for all
30    records that contain only characters of type default character. If the file is connected for unformatted
31    input/output, the length is measured in file storage units. If there is no connection, or if the connection
32    is for stream access, the scalar-int-variable becomes undefined.




      212                                   WORKING DRAFT                                            SEP 2002


      SEP 2002                                   WORKING DRAFT                                 J3/02-007R3



 1    9.9.1.25    ROUND= specifier in the INQUIRE statement

 2    The scalar-default-char-variable in the ROUND= specifier is assigned the value UP, DOWN, ZERO,
 3    NEAREST, COMPATIBLE, or PROCESSOR DEFINED, corresponding to the I/O rounding mode in
 4    effect for a connection for formatted input/output. If there is no connection or if the connection is not
 5    for formatted input/output, the scalar-default-char-variable is assigned the value UNDEFINED. The
 6    processor shall return the value PROCESSOR DEFINED only if the I/O rounding mode currently in
 7    effect behaves differently than the UP, DOWN, ZERO, NEAREST, and COMPATIBLE modes.


 8    9.9.1.26    SEQUENTIAL= specifier in the INQUIRE statement

 9    The scalar-default-char-variable in the SEQUENTIAL= specifier is assigned the value YES if SEQUEN-
10    TIAL is included in the set of allowed access methods for the file, NO if SEQUENTIAL is not included
11    in the set of allowed access methods for the file, and UNKNOWN if the processor is unable to determine
12    whether or not SEQUENTIAL is included in the set of allowed access methods for the file.


13    9.9.1.27    SIGN= specifier in the INQUIRE statement

14    The scalar-default-char-variable in the SIGN= specifier is assigned the value PLUS, SUPPRESS, or
15    PROCESSOR DEFINED, corresponding to the sign mode in effect for a connection for formatted in-
16    put/output.    If there is no connection, or if the connection is not for formatted input/output, the
17    scalar-default-char-variable is assigned the value UNDEFINED.


18    9.9.1.28    SIZE= specifier in the INQUIRE statement

19    The scalar-int-variable in the SIZE= specifier is assigned the size of the file in file storage units. If the
20    file size cannot be determined, the variable is assigned the value -1.

21    For a file that may be connected for stream access, the file size is the number of the highest-numbered
22    file storage unit in the file.

23    For a file that may be connected for sequential or direct access, the file size may be different from the
24    number of storage units implied by the data in the records; the exact relationship is processor-dependent.


25    9.9.1.29    STREAM= specifier in the INQUIRE statement

26    The scalar-default-char-variable in the STREAM= specifier is assigned the value YES if STREAM is
27    included in the set of allowed access methods for the file, NO if STREAM is not included in the set of
28    allowed access methods for the file, and UNKNOWN if the processor is unable to determine whether or
29    not STREAM is included in the set of allowed access methods for the file.


30    9.9.1.30    UNFORMATTED= specifier in the INQUIRE statement

31    The scalar-default-char-variable in the UNFORMATTED= specifier is assigned the value YES if UN-
32    FORMATTED is included in the set of allowed forms for the file, NO if UNFORMATTED is not included
33    in the set of allowed forms for the file, and UNKNOWN if the processor is unable to determine whether
34    or not UNFORMATTED is included in the set of allowed forms for the file.


35    9.9.1.31    WRITE= specifier in the INQUIRE statement

36    The scalar-default-char-variable in the WRITE= specifier is assigned the value YES if WRITE is included
37    in the set of allowed actions for the file, NO if WRITE is not included in the set of allowed actions for
38    the file, and UNKNOWN if the processor is unable to determine whether or not WRITE is included in
39    the set of allowed actions for the file.





      SEP 2002                                      WORKING DRAFT                                          213


      J3/02-007R3                                  WORKING DRAFT                                     SEP 2002


 1    9.9.2         Restrictions on inquiry specifiers

 2    The inquire-spec-list in an INQUIRE by file statement shall contain exactly one FILE= specifier and
 3    shall not contain a UNIT= specifier. The inquire-spec-list in an INQUIRE by unit statement shall
 4    contain exactly one UNIT= specifier and shall not contain a FILE= specifier. The unit specified need
 5    not exist or be connected to a file. If it is connected to a file, the inquiry is being made about the
 6    connection and about the file connected.


 7    9.9.3         Inquire by output list

 8    The inquire by output list form of the INQUIRE statement has only an IOLENGTH= specifier and an
 9    output list.

10    The scalar-int-variable in the IOLENGTH= specifier is assigned the processor-dependent number of file
11    storage units that would be required to store the data of the output list in an unformatted file. The
12    value shall be suitable as a RECL= specifier in an OPEN statement that connects a file for unformatted
13    direct access when there are input/output statements with the same input/output list.

14    The output list in an INQUIRE statement shall not contain any derived-type list items that require a
15    user-defined derived-type input/output procedure as described in section 9.5.2. If a derived-type list item
16    appears in the output list, the value returned for the IOLENGTH specifier assumes that no user-defined
17    derived-type input/output procedure will be invoked.


18    9.10          Error, end-of-record, and end-of-file conditions

19    The set of input/output error conditions is processor dependent.

20    An end-of-record condition occurs when a nonadvancing input statement attempts to transfer data
21    from a position beyond the end of the current record, unless the file is a stream file and the current
22    record is at the end of the file (an end-of-file condition occurs instead).

23    An end-of-file condition occurs in the following cases:

24           (1)      When an endfile record is encountered during the reading of a file connected for sequential
25                    access.

26           (2)      When an attempt is made to read a record beyond the end of an internal file.

27           (3)      When an attempt is made to read beyond the end of a stream file.

28    An end-of-file condition may occur at the beginning of execution of an input statement. An end-of-file
29    condition also may occur during execution of a formatted input statement when more than one record
30    is required by the interaction of the input list and the format. An end-of-file condition also may occur
31    during execution of a stream input statement.


32    9.10.1         Error conditions and the ERR= specifier

33    If an error condition occurs during execution of an input/output statement, the position of the file
34    becomes indeterminate.

35    If an error condition occurs during execution of an input/output statement that contains neither an
36    ERR= nor IOSTAT= specifier, execution of the program is terminated. If an error condition occurs
37    during execution of an input/output statement that contains either an ERR= specifier or an IOSTAT=
38    specifier then

39           (1)      Processing of the input/output list, if any, terminates,





      214                                    WORKING DRAFT                                           SEP 2002


      SEP 2002                                WORKING DRAFT                                       J3/02-007R3



 1          (2)     If the statement is a data transfer statement or the error occurs during a wait operation,
 2                  all implied DO variables in the statement that initiated the transfer become undefined,

 3          (3)     If an IOSTAT= specifier appears, the scalar-int-variable in the IOSTAT= specifier becomes
 4                  defined as specified in 9.10.4,

 5          (4)     If an IOMSG= specifier appears, the iomsg-variable becomes defined as specified in 9.10.5,

 6          (5)     If the statement is a READ statement and it contains a SIZE= specifier, the scalar-int-
 7                  variable in the SIZE= specifier becomes defined as specified in 9.5.1.14,

 8          (6)     If the statement is a READ statement or the error condition occurs in a wait operation for
 9                  a transfer initiated by a READ statement, all input items or namelist group objects in the
10                  statement that initiated the transfer become undefined, and

11          (7)     If an ERR= specifier appears, execution continues with the statement labeled by the label
12                  in the ERR= specifier.


13    9.10.2       End-of-file conditions and the END= specifier

14    If an end-of-file condition occurs during execution of an input/output statement that contains neither
15    an END= specifier nor an IOSTAT= specifier, execution of the program is terminated. If an end-of-file
16    condition occurs during execution of an input/output statement that contains either an END= specifier
17    or an IOSTAT= specifier, and an error condition does not occur then

18          (1)     Processing of the input list, if any, terminates,

19          (2)     If the statement is a data transfer statement or the error occurs during a wait operation,
20                  all implied DO variables in the statement that initiated the transfer become undefined,

21          (3)     If the statement is a READ statement or the end-of-file condition occurs in a wait operation
22                  for a transfer initiated by a READ statement, all input list items or namelist group objects
23                  in the statement that initiated the transfer become undefined,

24          (4)     If the file specified in the input statement is an external record file, it is positioned after the
25                  endfile record,

26          (5)     If an IOSTAT= specifier appears, the scalar-int-variable in the IOSTAT= specifier becomes
27                  defined as specified in 9.10.4,

28          (6)     If an IOMSG= specifier appears, the iomsg-variable becomes defined as specified in 9.10.5,
29                  and

30          (7)     If an END= specifier appears, execution continues with the statement labeled by the label
31                  in the END= specifier.


32    9.10.3       End-of-record conditions and the EOR= specifier

33    If an end-of-record condition occurs during execution of an input/output statement that contains neither
34    an EOR= specifier nor an IOSTAT= specifier, execution of the program is terminated. If an end-of-
35    record condition occurs during execution of an input/output statement that contains either an EOR=
36    specifier or an IOSTAT= specifier, and an error condition does not occur then

37          (1)     If the pad mode has the value YES, the record is padded with blanks to satisfy the input
38                  list item (9.5.3.4.2) and corresponding data edit descriptor that requires more characters
39                  than the record contains. If the pad mode has the value NO, the input list item becomes
40                  undefined.

41          (2)     Processing of the input list, if any, terminates,

42          (3)     If the statement is a data transfer statement or the error occurs during a wait operation,
43                  all implied DO variables in the statement that initiated the transfer become undefined,

44          (4)     The file specified in the input statement is positioned after the current record,

45          (5)     If an IOSTAT= specifier appears, the scalar-int-variable in the IOSTAT= specifier becomes
46                  defined as specified in 9.10.4,




      SEP 2002                                       WORKING DRAFT                                             215


      J3/02-007R3                                   WORKING DRAFT                                       SEP 2002



 1            (6)      If an IOMSG= specifier appears, the iomsg-variable becomes defined as specified in 9.10.5,

 2            (7)      If a SIZE= specifier appears, the scalar-int-variable in the SIZE= specifier becomes defined
 3                     as specified in (9.5.1.14), and

 4            (8)      If an EOR= specifier appears, execution continues with the statement labeled by the label
 5                     in the EOR= specifier.


 6    9.10.4         IOSTAT= specifier

 7    Execution of an input/output statement containing the IOSTAT= specifier causes the scalar-int-variable
 8    in the IOSTAT= specifier to become defined

 9            (1)      With a zero value if neither an error condition, an end-of-file condition, nor an end-of-record
10                     condition occurs,

11            (2)      With a processor-dependent positive integer value if an error condition occurs,

12            (3)      With the processor-dependent negative integer value of the constant IOSTAT END (13.8.3.2.1)
13                     if an end-of-file condition occurs and no error condition occurs, or

14            (4)      With a processor-dependent negative integer value of the constant IOSTAT EOR (13.8.3.2.2)
15                     if an end-of-record condition occurs and no error condition or end-of-file condition occurs.

             NOTE 9.63

             An end-of-file condition may occur only for sequential or stream input and an end-of-record con-
             dition may occur only for nonadvancing input.

             Consider the example:


             READ (FMT = "(E8.3)", UNIT = 3, IOSTAT = IOSS) X
             IF (IOSS < 0) THEN
                ! Perform end-of-file processing on the file connected to unit 3.
                CALL END_PROCESSING
             ELSE IF (IOSS > 0) THEN
                ! Perform error processing
                CALL ERROR_PROCESSING
             END IF



16    9.10.5         IOMSG= specifier

17    If an error, end-of-file, or end-of-record condition occurs during execution of an input/output statement,
18    the processor shall assign an explanatory message to iomsg-variable. If no such condition occurs, the
19    processor shall not change the value of iomsg-variable.


20    9.11           Restrictions on input/output statements

21    If a unit, or a file connected to a unit, does not have all of the properties required for the execution of
22    certain input/output statements, those statements shall not refer to the unit.

23    An input/output statement that is executed while another input/output statement is being executed is
24    called a recursive input/output statement.

25    A recursive input/output statement shall not identify an external unit except that a child data transfer
26    statement may identify its parent data transfer statement external unit.

27    An input/output statement shall not cause the value of any established format specification to be
28    modified.




      216                                     WORKING DRAFT                                             SEP 2002


      SEP 2002                                WORKING DRAFT                                       J3/02-007R3



 1    A recursive input/output statement shall not modify the value of any internal unit except that a recursive
 2    WRITE statement may modify the internal unit identified by that recursive WRITE statement.

 3    The value of a specifier in an input/output statement shall not depend on any input-item, io-implied-
 4    do do-variable, or on the definition or evaluation of any other specifier in the io-control-spec-list or
 5    inquire-spec-list in that statement.

 6    The value of any subscript or substring bound of a variable that appears in a specifier in an input/output
 7    statement shall not depend on any input-item, io-implied-do do-variable, or on the definition or evalua-
 8    tion of any other specifier in the io-control-spec-list or inquire-spec-list in that statement.

 9    In a data transfer statement, the variable specified in an IOSTAT=, IOMSG=, or SIZE= specifier, if
10    any, shall not be associated with any entity in the data transfer input/output list (9.5.2) or namelist-
11    group-object -list, nor with a do-variable of an io-implied-do in the data transfer input/output list.

12    In a data transfer statement, if a variable specified in an IOSTAT=, IOMSG=, or SIZE= specifier is an
13    array element reference, its subscript values shall not be affected by the data transfer, the io-implied-do
14    processing, or the definition or evaluation of any other specifier in the io-control-spec-list.

15    A variable that may become defined or undefined as a result of its use in a specifier in an INQUIRE
16    statement, or any associated entity, shall not appear in another specifier in the same INQUIRE statement.

17    A STOP statement shall not be executed during execution of an input/output statement.

           NOTE 9.64

           Restrictions on the evaluation of expressions (7.1.8) prohibit certain side effects.





      SEP 2002                                     WORKING DRAFT                                                217


J3/02-007R3       WORKING DRAFT    SEP 2002





218            WORKING DRAFT       SEP 2002


      SEP 2002                                    WORKING DRAFT                                     J3/02-007R3





 1    Section 10: Input/output editing

 2    A format used in conjunction with an input/output statement provides information that directs the
 3    editing between the internal representation of data and the characters of a sequence of formatted records.

 4    A FMT= specifier (9.5.1.1) in an input/output statement may refer to a FORMAT statement or to a
 5    character expression that contains a format specification. A format specification provides explicit editing
 6    information. The FMT= specifier alternatively may be an asterisk (*), which indicates list-directed
 7    formatting (10.9). Namelist formatting (10.10) may be indicated by specifying a namelist-group-name
 8    instead of a format .


 9    10.1             Explicit format specification methods

10    Explicit format specification may be given

11              (1)     In a FORMAT statement or

12              (2)     In a character expression.


13    10.1.1           FORMAT statement

14    R1001 format-stmt                           is    FORMAT format-specification
15    R1002 format-specification                   is    ( [ format-item-list ] )

16    C1001       (R1001) The format-stmt shall be labeled.

17    C1002       (R1002) The comma used to separate format-items in a format-item-list may be omitted

18              (1)     Between a P edit descriptor and an immediately following F, E, EN, ES, D, or G edit
19                      descriptor (10.7.5),

20              (2)     Before a slash edit descriptor when the optional repeat specification is not present (10.7.2),

21              (3)     After a slash edit descriptor, or

22              (4)     Before or after a colon edit descriptor (10.7.3)

23    Blank characters may precede the initial left parenthesis of the format specification. Additional blank
24    characters may appear at any point within the format specification, with no effect on the interpretation
25    of the format specification, except within a character string edit descriptor (10.8).

           NOTE 10.1

           Examples of FORMAT statements are:


           5            FORMAT (1PE12.4, I10)
           9            FORMAT (I12, /, ' Dates: ', 2 (2I3, I5))



26    10.1.2           Character format specification

27    A character expression used as a format in a formatted input/output statement shall evaluate to a
28    character string whose leading part is a valid format specification.

           NOTE 10.2

           The format specification begins with a left parenthesis and ends with a right parenthesis.




      SEP 2002                                           WORKING DRAFT                                          219


      J3/02-007R3                                     WORKING DRAFT                                    SEP 2002



 1    All character positions up to and including the final right parenthesis of the format specification shall be
 2    defined at the time the input/output statement is executed, and shall not become redefined or undefined
 3    during the execution of the statement. Character positions, if any, following the right parenthesis that
 4    ends the format specification need not be defined and may contain any character data with no effect on
 5    the interpretation of the format specification.

 6    If the format is a character array, it is treated as if all of the elements of the array were specified in array
 7    element order and were concatenated. However, if a format is a character array element, the format
 8    specification shall be entirely within that array element.

             NOTE 10.3

             If a character constant is used as a format in an input/output statement, care shall be taken
             that the value of the character constant is a valid format specification. In particular, if a format
             specification delimited by apostrophes contains a character constant edit descriptor delimited with
             apostrophes, two apostrophes shall be written to delimit the edit descriptor and four apostrophes
             shall be written for each apostrophe that occurs within the edit descriptor. For example, the text:


              2 ISN'T 3


             may be written by various combinations of output statements and format specifications:


                 WRITE (6, 100) 2, 3
             100 FORMAT (1X, I1, 1X, 'ISN''T', 1X, I1)
                 WRITE (6, '(1X, I1, 1X, ''ISN''''T'', 1X, I1)') 2, 3
                 WRITE (6, '(A)') ' 2 ISN''T 3'


             Doubling of internal apostrophes usually can be avoided by using quotation marks to delimit the
             format specification and doubling of internal quotation marks usually can be avoided by using
             apostrophes as delimiters.



 9    10.2        Form of a format item list

10    R1003 format-item                         is    [ r ] data-edit-desc
11                                              or control-edit-desc
12                                              or char-string-edit-desc
13                                              or [ r ] ( format-item-list )
14    R1004 r                                   is    int-literal-constant

15    C1003     (R1004) r shall be positive.

16    C1004     (R1004) r shall not have a kind parameter specified for it.

17    The integer literal constant r is called a repeat specification.


18    10.2.1      Edit descriptors

19    An edit descriptor is a data edit descriptor, a control edit descriptor, or a character string
20    edit descriptor.

21    R1005 data-edit-desc                      is    I w [ . m ]
22                                              or B w [ . m ]
23                                              or O w [ . m ]
24                                              or Z w [ . m ]
25                                              or F w . d



      220                                  WORKING DRAFT                                               SEP 2002


      SEP 2002                                    WORKING DRAFT                                      J3/02-007R3



 1                                                or E w . d [ E e ]
 2                                                or EN w . d [ E e ]
 3                                                or ES w . d [ E e ]
 4                                                or G w . d [ E e ]
 5                                                or L w
 6                                                or A [ w ]
 7                                                or D w . d
 8                                                or DT [ char-literal-constant ] [ ( v -list ) ]
 9    R1006 w                                     is    int-literal-constant
10    R1007 m                                     is    int-literal-constant
11    R1008 d                                     is    int-literal-constant
12    R1009 e                                     is    int-literal-constant
13    R1010 v                                     is    signed-int-literal-constant

14    C1005    (R1009) e shall be positive.

15    C1006    (R1006) w shall be zero or positive for the I, B, O, Z, and F edit descriptors. w shall be positive
16             for all other edit descriptors.

17    C1007    (R1005) w , m, d , e, and v shall not have kind parameters specified for them.

18    C1008    (R1005) The char-literal-constant in the DT edit descriptor shall not have a kind parameter
19             specified for it.

20    I, B, O, Z, F, E, EN, ES, G, L, A, D, and DT indicate the manner of editing.

21    R1011 control-edit-desc                     is    position-edit-desc
22                                                or [ r ] /
23                                                or :
24                                                or sign-edit-desc
25                                                or k P
26                                                or blank-interp-edit-desc
27                                                or round-edit-desc
28                                                or decimal-edit-desc
29    R1012 k                                     is    signed-int-literal-constant

30    C1009    (R1012) k shall not have a kind parameter specified for it.

31    In k P, k is called the scale factor.

32    R1013 position-edit-desc                    is    T n
33                                                or TL n
34                                                or TR n
35                                                or n X
36    R1014 n                                     is    int-literal-constant

37    C1010    (R1014) n shall be positive.

38    C1011    (R1014) n shall not have a kind parameter specified for it.

39    R1015 sign-edit-desc                        is    SS
40                                                or SP
41                                                or S
42    R1016 blank-interp-edit-desc                is    BN
43                                                or BZ
44    R1017 round-edit-desc                       is    RU
45                                                or RD



      SEP 2002                                            WORKING DRAFT                                      221


      J3/02-007R3                                    WORKING DRAFT                                    SEP 2002



 1                                             or RZ
 2                                             or RN
 3                                             or RC
 4                                             or RP
 5    R1018 decimal-edit-desc                  is    DC
 6                                             or DP

 7    T, TL, TR, X, slash, colon, SS, SP, S, P, BN, BZ, RU, RD, RZ, RN, RC, RP, DC, and DP indicate the
 8    manner of editing.

 9    R1019 char-string-edit-desc              is    char-literal-constant

10    C1012     (R1019) The char-literal-constant shall not have a kind parameter specified for it.

11    Each rep-char in a character string edit descriptor shall be one of the characters capable of representation
12    by the processor.

13    The character string edit descriptors provide constant data to be output, and are not valid for input.

14    The edit descriptors are without regard to case except for the characters in the character constants.


15    10.2.2         Fields

16    A field is a part of a record that is read on input or written on output when format control encounters
17    a data edit descriptor or a character string edit descriptor. The field width is the size in characters of
18    the field.


19    10.3           Interaction between input/output list and format

20    The start of formatted data transfer using a format specification initiates format control (9.5.3.4.2).
21    Each action of format control depends on information jointly provided by

22            (1)     The next edit descriptor in the format specification and

23            (2)     The next effective item in the input/output list, if one exists.

24    If an input/output list specifies at least one effective list item, at least one data edit descriptor shall
25    exist in the format specification.

             NOTE 10.4

             An empty format specification of the form ( ) may be used only if the input/output list has no
             effective list items (9.5.3.4). Zero length character items are effective list items, but zero sized
             arrays and implied-DO lists with an iteration count of zero are not.


26    A format specification is interpreted from left to right. The exceptions are format items preceded by a
27    repeat specification r , and format reversion (described below).

28    A format item preceded by a repeat specification is processed as a list of r items, each identical to the
29    format item but without the repeat specification and separated by commas.

             NOTE 10.5

             An omitted repeat specification is treated in the same way as a repeat specification whose value is
             one.


30    To each data edit descriptor interpreted in a format specification, there corresponds one effective item
31    specified by the input/output list (9.5.2), except that an input/output list item of type complex requires



      222                                    WORKING DRAFT                                            SEP 2002


      SEP 2002                               WORKING DRAFT                                       J3/02-007R3



 1    the interpretation of two F, E, EN, ES, D, or G edit descriptors. For each control edit descriptor or
 2    character edit descriptor, there is no corresponding item specified by the input/output list, and format
 3    control communicates information directly with the record.

 4    Whenever format control encounters a data edit descriptor in a format specification, it determines
 5    whether there is a corresponding effective item specified by the input/output list. If there is such an
 6    item, it transmits appropriately edited information between the item and the record, and then format
 7    control proceeds. If there is no such item, format control terminates.

 8    If format control encounters a colon edit descriptor in a format specification and another effective in-
 9    put/output list item is not specified, format control terminates.

10    If format control encounters the rightmost parenthesis of a complete format specification and another
11    effective input/output list item is not specified, format control terminates. However, if another effective
12    input/output list item is specified, the file is positioned in a manner identical to the way it is positioned
13    when a slash edit descriptor is processed (10.7.2). Format control then reverts to the beginning of the
14    format item terminated by the last preceding right parenthesis that is not part of a DT edit descriptor.
15    If there is no such preceding right parenthesis, format control reverts to the first left parenthesis of the
16    format specification. If any reversion occurs, the reused portion of the format specification shall contain
17    at least one data edit descriptor. If format control reverts to a parenthesis that is preceded by a repeat
18    specification, the repeat specification is reused. Reversion of format control, of itself, has no effect on
19    the changeable modes (9.4.1).

           NOTE 10.6

           Example: The format specification:


           10 FORMAT (1X, 2(F10.3, I5))


           with an output list of


           WRITE (10,10) 10.1, 3, 4.7, 1, 12.4, 5, 5.2, 6


           produces the same output as the format specification:


           10 FORMAT (1X, F10.3, I5, F10.3, I5/F10.3, I5, F10.3, I5)



20    10.4         Positioning by format control

21    After each data edit descriptor or character string edit descriptor is processed, the file is positioned after
22    the last character read or written in the current record.

23    After each T, TL, TR, or X edit descriptor is processed, the file is positioned as described in 10.7.1.
24    After each slash edit descriptor is processed, the file is positioned as described in 10.7.2.

25    During formatted stream output, processing of an A edit descriptor may cause file positioning to occur
26    (10.6.3).

27    If format control reverts as described in 10.3, the file is positioned in a manner identical to the way it is
28    positioned when a slash edit descriptor is processed (10.7.2).

29    During a read operation, any unprocessed characters of the current record are skipped whenever the
30    next record is read.





      SEP 2002                                     WORKING DRAFT                                              223


      J3/02-007R3                                  WORKING DRAFT                                       SEP 2002


 1    10.5           Decimal symbol

 2    The decimal symbol is the character that separates the whole and fractional parts in the decimal
 3    representation of a real number in an internal or external file. When the decimal edit mode is POINT,
 4    the decimal symbol is a decimal point. When the decimal edit mode is COMMA, the decimal symbol is
 5    a comma.


 6    10.6           Data edit descriptors

 7    Data edit descriptors cause the conversion of data to or from its internal representation; during formatted
 8    stream output, the A data edit descriptor may also cause file positioning. Characters in the record shall
 9    be of default kind if they correspond to the value of a numeric, logical, or default character data entity,
10    and shall be of nondefault kind if they correspond to the value of a data entity of nondefault character
11    type. Characters transmitted to a record as a result of processing a character string edit descriptor
12    shall be of default kind. On input, the specified variable becomes defined unless an error condition,
13    an end-of-file condition, or an end-of-record condition occurs. On output, the specified expression is
14    evaluated.


15    10.6.1         Numeric editing

16    The I, B, O, Z, F, E, EN, ES, D, and G edit descriptors may be used to specify the input/output of
17    integer, real, and complex data. The following general rules apply:

18            (1)     On input, leading blanks are not significant. The interpretation of blanks, other than leading
19                    blanks, is determined by the blank interpretation mode (10.7.6). Plus signs may be omitted.
20                    A field containing only blanks is considered to be zero.

21            (2)     On input, with F, E, EN, ES, D, and G editing, a decimal symbol appearing in the input
22                    field overrides the portion of an edit descriptor that specifies the decimal symbol location.
23                    The input field may have more digits than the processor uses to approximate the value of
24                    the datum.

25            (3)     On output with I, F, E, EN, ES, D, and G editing, the representation of a positive or zero
26                    internal value in the field may be prefixed with a plus sign, as controlled by the S, SP, and
27                    SS edit descriptors or the processor. The representation of a negative internal value in the
28                    field shall be prefixed with a minus sign.

29            (4)     On output, the representation is right-justified in the field. If the number of characters
30                    produced by the editing is smaller than the field width, leading blanks are inserted in the
31                    field.

32            (5)     On output, if the number of characters produced exceeds the field width or if an exponent
33                    exceeds its specified length using the Ew.d Ee, ENw.d Ee, ESw.d Ee, or Gw.d Ee edit
34                    descriptor, the processor shall fill the entire field of width w with asterisks.      However,
35                    the processor shall not produce asterisks if the field width is not exceeded when optional
36                    characters are omitted.

             NOTE 10.7

             When an SP edit descriptor is in effect, a plus sign is not optional.

37            (6)     On output, with I, B, O, Z, and F editing, the specified value of the field width w may be
38                    zero. In such cases, the processor selects the smallest positive actual field width that does
39                    not result in a field filled with asterisks. The specified value of w shall not be zero on input.


40    10.6.1.1       Integer editing

41    The Iw, Iw.m, Bw, Bw.m, Ow, Ow.m, Zw, and Zw.m edit descriptors indicate that the field to be edited
42    occupies w positions, except when w is zero. When w is zero, the processor selects the field width. On



      224                                    WORKING DRAFT                                             SEP 2002


      SEP 2002                                WORKING DRAFT                                        J3/02-007R3



 1    input, w shall not be zero. The specified input/output list item shall be of type integer. The G edit
 2    descriptor also may be used to edit integer data (10.6.4.1.1).

 3    On input, m has no effect.

 4    In the input field for the I edit descriptor, the character string shall be a signed-digit-string (R405),
 5    except for the interpretation of blanks. For the B, O, and Z edit descriptors, the character string shall
 6    consist of binary, octal, or hexadecimal digits (as in R409, R410, R411) in the respective input field. The
 7    lower-case hexadecimal digits a through f in a hexadecimal input field are equivalent to the corresponding
 8    upper-case hexadecimal digits.

 9    The output field for the Iw edit descriptor consists of zero or more leading blanks followed by a minus
10    sign if the value of the internal datum is negative, or an optional plus sign otherwise, followed by the
11    magnitude of the internal value as a digit-string without leading zeros.

           NOTE 10.8

           A digit-string always consists of at least one digit.


12    The output field for the Bw, Ow, and Zw descriptors consists of zero or more leading blanks followed by
13    the internal value in a form identical to the digits of a binary, octal, or hexadecimal constant, respectively,
14    with the same value and without leading zeros.

           NOTE 10.9

           A binary, octal, or hexadecimal constant always consists of at least one digit.


15    The output field for the Iw.m, Bw.m, Ow.m, and Zw.m edit descriptor is the same as for the Iw, Bw,
16    Ow, and Zw edit descriptor, respectively, except that the digit-string consists of at least m digits. If
17    necessary, sufficient leading zeros are included to achieve the minimum of m digits. The value of m shall
18    not exceed the value of w , except when w is zero. If m is zero and the value of the internal datum is
19    zero, the output field consists of only blank characters, regardless of the sign control in effect. When m
20    and w are both zero, and the value of the internal datum is zero, one blank character is produced.


21    10.6.1.2      Real and complex editing

22    The F, E, EN, ES, and D edit descriptors specify the editing of real and complex data. An input/output
23    list item corresponding to an F, E, EN, ES, or D edit descriptor shall be real or complex. The G edit
24    descriptor also may be used to edit real and complex data (10.6.4.1.2).

25    A lower-case letter is equivalent to the corresponding upper-case letter in the exponent in a numeric
26    input field.


27    10.6.1.2.1     F editing

28    The Fw.d edit descriptor indicates that the field occupies w positions, the fractional part of which
29    consists of d digits. When w is zero, the processor selects the field width. On input, w shall not be zero.

30    The input field consists of an optional sign, followed by a string of one or more digits optionally containing
31    a decimal symbol, including any blanks interpreted as zeros. The d has no effect on input if the input
32    field contains a decimal symbol. If the decimal symbol is omitted, the rightmost d digits of the string,
33    with leading zeros assumed if necessary, are interpreted as the fractional part of the value represented.
34    The string of digits may contain more digits than a processor uses to approximate the value. The basic
35    form may be followed by an exponent of one of the following forms:

36          (1)      A sign followed by a digit-string

37          (2)      E followed by zero or more blanks, followed by a signed-digit-string



      SEP 2002                                      WORKING DRAFT                                               225


      J3/02-007R3                                  WORKING DRAFT                                     SEP 2002



 1            (3)    D followed by zero or more blanks, followed by a signed-digit-string

 2    An exponent containing a D is processed identically to an exponent containing an E.

             NOTE 10.10

             If the input field does not contain an exponent, the effect is as if the basic form were followed by
             an exponent with a value of -k, where k is the established scale factor (10.7.5).


 3    The output field consists of blanks, if necessary, followed by a minus sign if the internal value is negative,
 4    or an optional plus sign otherwise, followed by a string of digits that contains a decimal symbol and
 5    represents the magnitude of the internal value, as modified by the established scale factor and rounded
 6    to d fractional digits. Leading zeros are not permitted except for an optional zero immediately to the
 7    left of the decimal symbol if the magnitude of the value in the output field is less than one. The optional
 8    zero shall appear if there would otherwise be no digits in the output field.


 9    10.6.1.2.2     E and D editing

10    The Ew.d, Dw.d, and Ew.d Ee edit descriptors indicate that the external field occupies w positions, the
11    fractional part of which consists of d digits, unless a scale factor greater than one is in effect, and the
12    exponent part consists of e digits. The e has no effect on input.

13    The form and interpretation of the input field is the same as for Fw.d editing (10.6.1.2.1).

14    The form of the output field for a scale factor of zero is:

15        [ � ] [0].x1x2 . . . xdexp

16    where:

17                   � signifies a plus sign or a minus sign.

18                   . signifies a decimal symbol (10.5).

19                   x1x2 . . . xd are the d most significant digits of the datum value after rounding.
20                   exp is a decimal exponent having one of the following forms:


                                        Edit      Absolute Value          Form of
                                   Descriptor       of Exponent          Exponent

                                        Ew.d         |exp|  99       E�z1z2 or �0z1z2
                                                  99 < |exp|  999        �z1z2z3
                                   Ew.d Ee        |exp|  10e - 1       E�z1z2 . . . ze
                                        Dw.d         |exp|  99       D�z1z2 or E�z1z2
                                                                         or �0z1z2
                                                  99 < |exp|  999        �z1z2z3


21                   where each z is a digit.

22    The sign in the exponent is produced. A plus sign is produced if the exponent value is zero. The edit
23    descriptor forms Ew.d and Dw.d shall not be used if |exp| > 999.

24    The scale factor k controls the decimal normalization (10.2.1, 10.7.5). If -d < k  0, the output field
25    contains exactly |k| leading zeros and d - |k| significant digits after the decimal symbol. If 0 < k < d + 2,
26    the output field contains exactly k significant digits to the left of the decimal symbol and d - k + 1
27    significant digits to the right of the decimal symbol. Other values of k are not permitted.





      226                                       WORKING DRAFT                                        SEP 2002


      SEP 2002                                   WORKING DRAFT                                  J3/02-007R3



 1    10.6.1.2.3    EN editing

 2    The EN edit descriptor produces an output field in the form of a real number in engineering notation
 3    such that the decimal exponent is divisible by three and the absolute value of the significand (R415) is
 4    greater than or equal to 1 and less than 1000, except when the output value is zero. The scale factor
 5    has no effect on output.

 6    The forms of the edit descriptor are ENw.d and ENw.d Ee indicating that the external field occupies w
 7    positions, the fractional part of which consists of d digits and the exponent part consists of e digits.

 8    The form and interpretation of the input field is the same as for Fw.d editing (10.6.1.2.1).

 9    The form of the output field is:

10        [ � ] yyy . x1x2 . . . xdexp

11    where:

12                  � signifies a plus sign or a minus sign.

13                  yyy are the 1 to 3 decimal digits representative of the most significant digits of the value
14                  of the datum after rounding (yyy is an integer such that 1  yyy < 1000 or, if the output
15                  value is zero, yyy = 0).

16                  . signifies a decimal symbol (10.5).

17                  x1x2 . . . xd are the d next most significant digits of the value of the datum after rounding.
18                  exp is a decimal exponent, divisible by three, of one of the following forms:


                                      Edit        Absolute Value            Form of
                                   Descriptor       of Exponent            Exponent

                                      ENw.d          |exp|  99         E�z1z2 or �0z1z2
                                                  99 < |exp|  999          �z1z2z3
                                   ENw.d Ee       |exp|  10e - 1         E�z1z2 . . . ze

19                  where each z is a digit.

20    The sign in the exponent is produced. A plus sign is produced if the exponent value is zero. The edit
21    descriptor form ENw.d shall not be used if |exp| > 999.

           NOTE 10.11

           Examples:

                    Internal Value                     Output field Using SS, EN12.3
                        6.421                              6.421E+00
                        �.5                            �500.000E�03
                         .00217                            2.170E-03
                    4721.3                                 4.721E+03


22    10.6.1.2.4    ES editing

23    The ES edit descriptor produces an output field in the form of a real number in scientific notation such
24    that the absolute value of the significand (R415) is greater than or equal to 1 and less than 10, except
25    when the output value is zero. The scale factor has no effect on output.

26    The forms of the edit descriptor are ESw.d and ESw.d Ee indicating that the external field occupies w
27    positions, the fractional part of which consists of d digits and the exponent part consists of e digits.

28    The form and interpretation of the input field is the same as for Fw.d editing (10.6.1.2.1).



      SEP 2002                                       WORKING DRAFT                                           227


      J3/02-007R3                                   WORKING DRAFT                                   SEP 2002



 1    The form of the output field is:

 2        [ � ] y . x1x2 . . . xdexp

 3    where:

 4                  � signifies a plus sign or a minus sign.

 5                  y is a decimal digit representative of the most significant digit of the value of the datum
 6                  after rounding.

 7                  . signifies a decimal symbol (10.5).

 8                  x1x2 . . . xd are the d next most significant digits of the value of the datum after rounding.
 9                  exp is a decimal exponent having one of the following forms:


                                        Edit       Absolute Value           Form of
                                     Descriptor      of Exponent           Exponent

                                        ESw.d         |exp|  99        E�z1z2 or �0z1z2
                                                   99 < |exp|  999         �z1z2z3
                                     ESw.d Ee      |exp|  10e - 1        E�z1z2 . . . ze


10                  where each z is a digit.

11    The sign in the exponent is produced. A plus sign is produced if the exponent value is zero. The edit
12    descriptor form ESw.d shall not be used if |exp| > 999.

             NOTE 10.12

             Examples:

                    Internal Value                      Output field Using SS, ES12.3
                          6.421                            6.421E+00
                          �.5                             �5.000E�01
                           .00217                          2.170E-03
                    4721.3                                 4.721E+03


13    10.6.1.2.5    Complex editing

14    A complex datum consists of a pair of separate real data. The editing of a scalar datum of complex type
15    is specified by two edit descriptors each of which specifies the editing of real data. The first of the edit
16    descriptors specifies the real part; the second specifies the imaginary part. The two edit descriptors may
17    be different. Control and character string edit descriptors may be processed between the edit descriptor
18    for the real part and the edit descriptor for the imaginary part.


19    10.6.1.2.6    Rounding mode

20    The rounding mode can be specified by an OPEN statement (9.4.1), a data transfer input/output
21    statement (9.5.1.12), or an edit descriptor (10.7.7).

22    In what follows, the term "decimal value" means the exact decimal number as given by the character
23    string, while the term "internal value" means the number actually stored (typically in binary form) in
24    the processor. For example, in dealing with the decimal constant 0.1, the decimal value is the exact
25    mathematical quantity 1/10, which has no exact representation on most processors. Formatted output
26    of real data involves conversion from an internal value to a decimal value; formatted input involves
27    conversion from a decimal value to an internal value.

28    When the I/O rounding mode is UP, the value resulting from conversion shall be the smallest repre-
29    sentable value that is greater than or equal to the original value. When the I/O rounding mode is



      228                                        WORKING DRAFT                                      SEP 2002


      SEP 2002                               WORKING DRAFT                                     J3/02-007R3



 1    DOWN, the value resulting from conversion shall be the largest representable value that is less than or
 2    equal to the original value. When the I/O rounding mode is ZERO, the value resulting from conversion
 3    shall be the value closest to the original value and no greater in magnitude than the original value. When
 4    the I/O rounding mode is NEAREST, the value resulting from conversion shall be the closer of the two
 5    nearest representable values if one is closer than the other. If the two nearest representable values are
 6    equidistant from the original value, it is processor dependent which one of them is chosen. When the
 7    I/O rounding mode is COMPATIBLE, the value resulting from conversion shall be the closer of the
 8    two nearest representable values or the value away from zero if halfway between them. When the I/O
 9    rounding mode is PROCESSOR DEFINED, rounding during conversion shall be a processor dependent
10    default mode, which may correspond to one of the other modes.

11    On processors that support IEEE rounding on conversions, NEAREST shall correspond to round to
12    nearest, as specified in the IEEE standard.

           NOTE 10.13

           On processors that support IEEE rounding on conversions, the I/O rounding modes COMPATI-
           BLE and NEAREST will produce the same results except when the datum is halfway between the
           two representable values. In that case, NEAREST will pick the even value, but COMPATIBLE
           will pick the value away from zero. The I/O rounding modes UP, DOWN, and ZERO have the
           same effect as those specified in the IEEE standard for round toward +, round toward -, and
           round toward 0, respectively.


13    10.6.2        Logical editing

14    The Lw edit descriptor indicates that the field occupies w positions. The specified input/output list
15    item shall be of type logical. The G edit descriptor also may be used to edit logical data (10.6.4.2).

16    The input field consists of optional blanks, optionally followed by a period, followed by a T for true or
17    F for false. The T or F may be followed by additional characters in the field, which are ignored.

18    A lower-case letter is equivalent to the corresponding upper-case letter in a logical input field.

           NOTE 10.14

           The logical constants .TRUE. and .FALSE. are acceptable input forms.


19    The output field consists of w - 1 blanks followed by a T or F, depending on whether the value of the
20    internal datum is true or false, respectively.


21    10.6.3        Character editing

22    The A[w ] edit descriptor is used with an input/output list item of type character. The G edit descriptor
23    also may be used to edit character data (10.6.4.3). The kind type parameter of all characters transferred
24    and converted under control of one A or G edit descriptor is implied by the kind of the corresponding
25    list item.

26    If a field width w is specified with the A edit descriptor, the field consists of w characters. If a field
27    width w is not specified with the A edit descriptor, the number of characters in the field is the length of
28    the corresponding list item, regardless of the value of the kind type parameter.

29    Let len be the length of the input/output list item. If the specified field width w for an A edit descriptor
30    corresponding to an input item is greater than or equal to len, the rightmost len characters will be
31    taken from the input field. If the specified field width w is less than len, the w characters will appear
32    left-justified with len-w trailing blanks in the internal representation.





      SEP 2002                                      WORKING DRAFT                                          229


      J3/02-007R3                                    WORKING DRAFT                                      SEP 2002



 1    If the specified field width w for an A edit descriptor corresponding to an output item is greater than
 2    len, the output field will consist of w - len blanks followed by the len characters from the internal
 3    representation. If the specified field width w is less than or equal to len, the output field will consist of
 4    the leftmost w characters from the internal representation.

             NOTE 10.15

             For nondefault character types, the blank padding character is processor dependent.


 5    If the file is connected for stream access, the output may be split across more than one record if it
 6    contains newline characters. A newline character is the character returned by the intrinsic function
 7    reference ACHAR(10). Beginning with the first character of the output field, each character that is
 8    not a newline is written to the current record in successive positions; each newline character causes file
 9    positioning at that point as if by slash editing (the current record is terminated at that point, a new
10    empty record is created following the current record, this new record becomes the last and current record
11    of the file, and the file is positioned at the beginning of this new record).

             NOTE 10.16

             Output field splitting by newline characters can occur only on those processors that can represent
             the character in position 10 of the ASCII collating sequence.


12    10.6.4         Generalized editing

13    The Gw.d and Gw.d Ee edit descriptors are used with an input/output list item of any intrinsic type.
14    These edit descriptors indicate that the external field occupies w positions, the fractional part of which
15    consists of a maximum of d digits and the exponent part consists of e digits. When these edit descriptors
16    are used to specify the input/output of integer, logical, or character data, d and e have no effect.


17    10.6.4.1       Generalized numeric editing

18    When used to specify the input/output of integer, real, and complex data, the Gw.d and Gw.d Ee edit
19    descriptors follow the general rules for numeric editing (10.6.1).

             NOTE 10.17

             The Gw.d Ee edit descriptor follows any additional rules for the Ew.d Ee edit descriptor.


20    10.6.4.1.1      Generalized integer editing

21    When used to specify the input/output of integer data, the Gw.d and Gw.d Ee edit descriptors follow
22    the rules for the Iw edit descriptor (10.6.1.1), except that w shall not be zero.


23    10.6.4.1.2      Generalized real and complex editing

24    The form and interpretation of the input field is the same as for Fw.d editing (10.6.1.2.1).

25    The method of representation in the output field depends on the magnitude of the datum being edited.
26    Let N be the magnitude of the internal datum and r be the rounded value defined in the table below.
27    If 0 < N < 0.1 - r � 10-d-1 or N  10d - r, or N is identically 0 and d is 0, Gw.d output editing is
28    the same as k PEw.d output editing and Gw.d Ee output editing is the same as k PEw.d Ee output
29    editing, where k is the scale factor (10.7.5) currently in effect. If 0.1 - r � 10-d-1  N < 10d - r or N is
30    identically 0 and d is not zero, the scale factor has no effect, and the value of N determines the editing
31    as follows:

                       Magnitude of Datum                                   Equivalent Conversion

                       N = 0                                                F(w - n).(d - 1), n('b')



      230                                    WORKING DRAFT                                              SEP 2002


      SEP 2002                              WORKING DRAFT                                      J3/02-007R3


                    Magnitude of Datum                                   Equivalent Conversion

                    0.1 - r � 10-d-1  N < 1 - r � 10-d                  F(w - n).d, n('b')
                    1 - r � 10-d  N < 10 - r � 10-d+1                   F(w - n).(d - 1), n('b')
                    10 - r � 10-d+1  N < 100 - r � 10-d+2               F(w - n).(d - 2), n('b')
                    �                                                    �
                    �                                                    �
                    �                                                    �
                    10d-2 - r � 10-2  N < 10d-1 - r � 10-1              F(w - n).1, n('b')
                    10d-1 - r � 10-1  N < 10d - r                       F(w - n).0, n('b')



 1    where b is a blank, n is 4 for Gw.d and e + 2 for Gw.d Ee, w - n shall be positive, and r is defined for
 2    each rounding mode as follows:


                            I/O Rounding Mode           r

                            COMPATIBLE                  0.5
                                                        0.5 if the higher value is even
                            NEAREST                     -0.5 if the lower value is even
                            UP                          1
                            DOWN                        0
                                                        1 if datum is negative
                            ZERO                        0 if datum is positive



           NOTE 10.18

           The scale factor has no effect on output unless the magnitude of the datum to be edited is outside
           the range that permits effective use of F editing.


 3    10.6.4.2    Generalized logical editing

 4    When used to specify the input/output of logical data, the Gw.d and Gw.d Ee edit descriptors follow
 5    the rules for the Lw edit descriptor (10.6.2).


 6    10.6.4.3    Generalized character editing

 7    When used to specify the input/output of character data, the Gw.d and Gw.d Ee edit descriptors follow
 8    the rules for the Aw edit descriptor (10.6.3).


 9    10.6.5      User-defined derived-type editing

10    The DT edit descriptor allows a user-provided procedure to be used instead of the processor's default
11    input/output formatting for processing a list item of derived type.

12    The DT edit descriptor may include a character literal constant. The character value "DT" concatenated
13    with the character literal constant is passed to the user-defined derived-type input/output procedure as
14    the iotype argument (9.5.3.7). The v values of the edit descriptor are passed to the user-defined
15    derived-type input/output procedure as the v list array argument.

           NOTE 10.19

           For the edit descriptor DT'Link List'(10, 4, 2), iotype is "DTLink List" and v list is
           (/10, 4, 2/).


16    If a derived-type variable or value corresponds to a DT edit descriptor, there shall be an accessible




      SEP 2002                                     WORKING DRAFT                                        231


      J3/02-007R3                                WORKING DRAFT                                       SEP 2002



 1    interface to a corresponding derived-type input/output procedure for that derived type (9.5.3.7). A DT
 2    edit descriptor shall not correspond with a list item that is not of a derived type.


 3    10.7          Control edit descriptors

 4    A control edit descriptor does not cause the transfer of data or the conversion of data to or from internal
 5    representation, but may affect the conversions performed by subsequent data edit descriptors.


 6    10.7.1        Position editing

 7    The T, TL, TR, and X edit descriptors specify the position at which the next character will be transmitted
 8    to or from the record. If any character skipped by a T, TL, TR, or X edit descriptor is of type nondefault
 9    character, the result of that position editing is processor dependent.

10    The position specified by a T edit descriptor may be in either direction from the current position. On
11    input, this allows portions of a record to be processed more than once, possibly with different editing.

12    The position specified by an X edit descriptor is forward from the current position. On input, a position
13    beyond the last character of the record may be specified if no characters are transmitted from such
14    positions.

             NOTE 10.20

             An nX edit descriptor has the same effect as a TRn edit descriptor.


15    On output, a T, TL, TR, or X edit descriptor does not by itself cause characters to be transmitted and
16    therefore does not by itself affect the length of the record. If characters are transmitted to positions at
17    or after the position specified by a T, TL, TR, or X edit descriptor, positions skipped and not previously
18    filled are filled with blanks. The result is as if the entire record were initially filled with blanks.

19    On output, a character in the record may be replaced. However, a T, TL, TR, or X edit descriptor never
20    directly causes a character already placed in the record to be replaced. Such edit descriptors may result
21    in positioning such that subsequent editing causes a replacement.


22    10.7.1.1      T, TL, and TR editing

23    The left tab limit affects file positioning by the T and TL edit descriptors. Immediately prior to data
24    transfer, the left tab limit becomes defined as the character position of the current record or the current
25    position of the stream file. If, during data transfer, the file is positioned to another record, the left tab
26    limit becomes defined as character position one of that record.

27    The Tn edit descriptor indicates that the transmission of the next character to or from a record is to
28    occur at the nth character position of the record, relative to the left tab limit.

29    The TLn edit descriptor indicates that the transmission of the next character to or from the record is
30    to occur at the character position n characters backward from the current position. However, if n is
31    greater than the difference between the current position and the left tab limit, the TLn edit descriptor
32    indicates that the transmission of the next character to or from the record is to occur at the left tab
33    limit.

34    The TRn edit descriptor indicates that the transmission of the next character to or from the record is
35    to occur at the character position n characters forward from the current position.

             NOTE 10.21

             The n in a Tn, TLn, or TRn edit descriptor shall be specified and shall be greater than zero.




      232                                    WORKING DRAFT                                           SEP 2002


      SEP 2002                                 WORKING DRAFT                                      J3/02-007R3



 1    10.7.1.2      X editing

 2    The nX edit descriptor indicates that the transmission of the next character to or from a record is to
 3    occur at the position n characters forward from the current position.

              NOTE 10.22

              The n in an nX edit descriptor shall be specified and shall be greater than zero.


 4    10.7.2        Slash editing

 5    The slash edit descriptor indicates the end of data transfer to or from the current record.

 6    On input from a file connected for sequential or stream access, the remaining portion of the current
 7    record is skipped and the file is positioned at the beginning of the next record. This record becomes
 8    the current record. On output to a file connected for sequential or stream access, a new empty record
 9    is created following the current record; this new record then becomes the last and current record of the
10    file and the file is positioned at the beginning of this new record.

11    For a file connected for direct access, the record number is increased by one and the file is positioned
12    at the beginning of the record that has that record number, if there is such a record, and this record
13    becomes the current record.

              NOTE 10.23

              A record that contains no characters may be written on output. If the file is an internal file or a
              file connected for direct access, the record is filled with blank characters.

              An entire record may be skipped on input.


14    The repeat specification is optional in the slash edit descriptor. If it is not specified, the default value is
15    one.


16    10.7.3        Colon editing

17    The colon edit descriptor terminates format control if there are no more effective items in the in-
18    put/output list (9.5.2). The colon edit descriptor has no effect if there are more effective items in the
19    input/output list.


20    10.7.4        SS, SP, and S editing

21    The SS, SP, and S edit descriptors temporarily change (9.4.1) the sign mode (9.4.5.13, 9.5.1.13) for the
22    connection. The edit descriptors SS, SP, and S set the sign mode corresponding to the SIGN= specifier
23    values SUPPRESS, PLUS, and PROCESSOR DEFINED, respectively.

24    The sign mode controls optional plus characters in numeric output fields. When the sign mode is PLUS,
25    the processor shall produce a plus sign in any position that normally contains an optional plus sign.
26    When the sign mode is SUPPRESS, the processor shall not produce a plus sign in such positions. When
27    the sign mode is PROCESSOR DEFINED, the processor has the option of producing a plus sign or not
28    in such positions, subject to 10.6.1(5).

29    The SS, SP, and S edit descriptors affect only I, F, E, EN, ES, D, and G editing during the execution of
30    an output statement. The SS, SP, and S edit descriptors have no effect during the execution of an input
31    statement.





      SEP 2002                                       WORKING DRAFT                                            233


      J3/02-007R3                                 WORKING DRAFT                                       SEP 2002


 1    10.7.5        P editing

 2    The k P edit descriptor temporarily changes (9.4.1) the scale factor for the connection to k . The scale
 3    factor affects the editing of F, E, EN, ES, D, and G edit descriptors for numeric quantities.

 4    The scale factor k affects the appropriate editing in the following manner:

 5           (1)     On input, with F, E, EN, ES, D, and G editing (provided that no exponent exists in the
 6                   field) and F output editing, the scale factor effect is that the externally represented number
 7                   equals the internally represented number multiplied by 10k.

 8           (2)     On input, with F, E, EN, ES, D, and G editing, the scale factor has no effect if there is an
 9                   exponent in the field.

10           (3)     On output, with E and D editing, the significand (R415) part of the quantity to be produced
11                   is multiplied by 10k and the exponent is reduced by k.

12           (4)     On output, with G editing, the effect of the scale factor is suspended unless the magnitude
13                   of the datum to be edited is outside the range that permits the use of F editing. If the use
14                   of E editing is required, the scale factor has the same effect as with E output editing.

15           (5)     On output, with EN and ES editing, the scale factor has no effect.

16    If UP, DOWN, ZERO, or NEAREST I/O rounding mode is in effect then

17           (1)     On input, the scale factor is applied to the external decimal value and then this is converted
18                   using the current I/O rounding mode, and

19           (2)     On output, the internal value is converted using the current I/O rounding mode and then
20                   the scale factor is applied to the converted decimal value.


21    10.7.6        BN and BZ editing

22    The BN and BZ edit descriptors temporarily change (9.4.1) the blank interpretation mode (9.4.5.4,
23    9.5.1.5) for the connection. The edit descriptors BN and BZ set the blank interpretation mode corre-
24    sponding to the BLANK= specifier values NULL and ZERO, respectively.

25    The blank interpretation mode controls the interpretation of nonleading blanks in numeric input fields.
26    Such blank characters are interpreted as zeros when the blank interpretation mode has the value ZERO;
27    they are ignored when the blank interpretation mode has the value NULL. The effect of ignoring blanks
28    is to treat the input field as if blanks had been removed, the remaining portion of the field right-justified,
29    and the blanks replaced as leading blanks. However, a field containing only blanks has the value zero.

30    The blank interpretation mode affects only numeric editing (10.6.1) and generalized numeric editing
31    (10.6.4.1) on input. It has no effect on output.


32    10.7.7        RU, RD, RZ, RN, RC, and RP editing

33    The round edit descriptors temporarily change (9.4.1) the connection's I/O rounding mode (9.4.5.12,
34    9.5.1.12, 10.6.1.2.6). The round edit descriptors RU, RD, RZ, RN, RC, and RP set the I/O rounding
35    mode corresponding to the ROUND= specifier values UP, DOWN, ZERO, NEAREST, COMPATIBLE,
36    and PROCESSOR DEFINED, respectively. The I/O rounding mode affects the conversion of real and
37    complex values in formatted input/output. It affects only D, E, EN, ES, F, and G editing.


38    10.7.8        DC and DP editing

39    The decimal edit descriptors temporarily change (9.4.1) the decimal edit mode (9.4.5.5, 9.5.1.6) for the
40    connection. The edit descriptors DC and DP set the decimal edit mode corresponding to the DECIMAL=
41    specifier values COMMA and POINT, respectively.





      234                                     WORKING DRAFT                                           SEP 2002


      SEP 2002                                 WORKING DRAFT                                        J3/02-007R3



 1    The decimal edit mode controls the representation of the decimal symbol (10.5) during conversion of
 2    real and complex values in formatted input/output. The decimal edit mode affects only D, E, EN, ES,
 3    F, and G editing.


 4    10.8          Character string edit descriptors

 5    A character string edit descriptor shall not be used on input.

 6    The character string edit descriptor causes characters to be written from the enclosed characters of the
 7    edit descriptor itself, including blanks. For a character string edit descriptor, the width of the field is
 8    the number of characters between the delimiting characters. Within the field, two consecutive delimiting
 9    characters are counted as a single character.

           NOTE 10.24

           A delimiter for a character string edit descriptor is either an apostrophe or quote.



10    10.9          List-directed formatting

11    List-directed input/output allows data editing according to the type of the list item instead of by a
12    format specification. It also allows data to be free-field, that is, separated by commas (or semicolons)
13    or blanks.

14    The characters in one or more list-directed records constitute a sequence of values and value separators.
15    The end of a record has the same effect as a blank character, unless it is within a character constant. Any
16    sequence of two or more consecutive blanks is treated as a single blank, unless it is within a character
17    constant.

18    Each value is either a null value or one of the forms:

              c
              r *c
19            r *

20    where c is a literal constant, optionally signed if integer or real, or a nondelimited character constant
21    and r is an unsigned, nonzero, integer literal constant. Neither c nor r shall have kind type parameters
22    specified. The constant c is interpreted as though it had the same kind type parameter as the corre-
23    sponding list item. The r *c form is equivalent to r successive appearances of the constant c, and the
24    r * form is equivalent to r successive appearances of the null value. Neither of these forms may contain
25    embedded blanks, except where permitted within the constant c.

26    A value separator is

27          (1)       A comma optionally preceded by one or more contiguous blanks and optionally followed by
28                    one or more contiguous blanks, unless the decimal edit mode is COMMA, in which case a
29                    semicolon is used in place of the comma,

30          (2)       A slash optionally preceded by one or more contiguous blanks and optionally followed by
31                    one or more contiguous blanks, or

32          (3)       One or more contiguous blanks between two nonblank values or following the last nonblank
33                    value, where a nonblank value is a constant, an r *c form, or an r * form.

           NOTE 10.25

           Although a slash encountered in an input record is referred to as a separator, it actually causes
           termination of list-directed and namelist input statements; it does not actually separate two values.




      SEP 2002                                       WORKING DRAFT                                          235


      J3/02-007R3                                  WORKING DRAFT                                     SEP 2002



             NOTE 10.26

             If no list items are specified in a list-directed input/output statement, one input record is skipped
             or one empty output record is written.


 1    10.9.1         List-directed input

 2    Input forms acceptable to edit descriptors for a given type are acceptable for list-directed formatting,
 3    except as noted below. The form of the input value shall be acceptable for the type of the next effective
 4    item in the list. Blanks are never used as zeros, and embedded blanks are not permitted in constants,
 5    except within character constants and complex constants as specified below.

 6    For the r *c form of an input value, the constant c is interpreted as a nondelimited character constant if
 7    the first list item corresponding to this value is of type default character, there is a nonblank character
 8    immediately after r *, and that character is not an apostrophe or a quotation mark; otherwise, c is
 9    interpreted as a literal constant.

             NOTE 10.27

             The end of a record has the effect of a blank, except when it appears within a character constant.


10    When the next effective item is of type integer, the value in the input record is interpreted as if an Iw
11    edit descriptor with a suitable value of w were used.

12    When the next effective item is of type real, the input form is that of a numeric input field. A numeric
13    input field is a field suitable for F editing (10.6.1.2.1) that is assumed to have no fractional digits unless
14    a decimal symbol appears within the field.

15    When the next effective item is of type complex, the input form consists of a left parenthesis followed
16    by an ordered pair of numeric input fields separated by a separator, and followed by a right parenthesis.
17    The first numeric input field is the real part of the complex constant and the second is the imaginary
18    part. Each of the numeric input fields may be preceded or followed by any number of blanks and ends of
19    records. The separator is a comma if the decimal edit mode is POINT; it is a semicolon if the decimal
20    edit mode is COMMA. The end of a record may occur between the real part and the separator or between
21    the separator and the imaginary part.

22    When the next effective item is of type logical, the input form shall not include value separators among
23    the optional characters permitted for L editing.

24    When the next effective item is of type character, the input form consists of a possibly delimited sequence
25    of zero or more rep-char s whose kind type parameter is implied by the kind of the effective list item.
26    Character sequences may be continued from the end of one record to the beginning of the next record,
27    but the end of record shall not occur between a doubled apostrophe in an apostrophe-delimited character
28    sequence, nor between a doubled quote in a quote-delimited character sequence. The end of the record
29    does not cause a blank or any other character to become part of the character sequence. The character
30    sequence may be continued on as many records as needed. The characters blank, comma, and slash may
31    appear in default character sequences.

32    If the next effective item is of type default character and

33            (1)     The character sequence does not contain value separators,

34            (2)     The character sequence does not cross a record boundary,

35            (3)     The first nonblank character is not a quotation mark or an apostrophe,

36            (4)     The leading characters are not digit s followed by an asterisk, and

37            (5)     The character sequence contains at least one character,





      236                                    WORKING DRAFT                                           SEP 2002


      SEP 2002                                WORKING DRAFT                                     J3/02-007R3




 1    the delimiting apostrophes or quotation marks are not required. If the delimiters are omitted, the
 2    character sequence is terminated by the first blank, comma, slash, or end of record; apostrophes and
 3    quotation marks within the datum are not to be doubled.

 4    Let len be the length of the next effective item, and let w be the length of the character sequence. If
 5    len is less than or equal to w, the leftmost len characters of the sequence are transmitted to the next
 6    effective item. If len is greater than w, the sequence is transmitted to the leftmost w characters of the
 7    next effective item and the remaining len-w characters of the next effective item are filled with blanks.
 8    The effect is as though the sequence were assigned to the next effective item in a character assignment
 9    statement (7.4.1.3).


10    10.9.1.1     Null values

11    A null value is specified by

12          (1)      The r * form,

13          (2)      No characters between consecutive value separators, or

14          (3)      No characters before the first value separator in the first record read by each execution of a
15                   list-directed input statement.

           NOTE 10.28

           The end of a record following any other value separator, with or without separating blanks, does
           not specify a null value in list-directed input.


16    A null value has no effect on the definition status of the next effective item. A null value shall not be
17    used for either the real or imaginary part of a complex constant, but a single null value may represent
18    an entire complex constant.

19    A slash encountered as a value separator during execution of a list-directed input statement causes
20    termination of execution of that input statement after the assignment of the previous value.          Any
21    characters remaining in the current record are ignored. If there are additional items in the input list,
22    the effect is as if null values had been supplied for them. Any implied-DO variable in the input list is
23    defined as though enough null values had been supplied for any remaining input list items.

           NOTE 10.29

           All blanks in a list-directed input record are considered to be part of some value separator except
           for the following:

                    (1)    Blanks embedded in a character sequence

                    (2)    Embedded blanks surrounding the real or imaginary part of a complex constant

                    (3)    Leading blanks in the first record read by each execution of a list-directed input
                           statement, unless immediately followed by a slash or comma



           NOTE 10.30

           List-directed input example:


           INTEGER I; REAL X (8); CHARACTER (11) P;
           COMPLEX Z; LOGICAL G
             ...
           READ *, I, X, P, Z, G





      SEP 2002                                         WORKING DRAFT                                        237


      J3/02-007R3                                 WORKING DRAFT                                   SEP 2002



             NOTE 10.30 (cont.)
               ...


             The input data records are:


             12345,12345,,2*1.5,4*
             ISN'T_BOB'S,(123,0),.TEXAS$


             The results are:

                      Variable                       Value
                      I                              12345
                      X (1)                          12345.0
                      X (2)                          unchanged
                      X (3)                          1.5
                      X (4)                          1.5
                      X (5) � X (8)                  unchanged
                      P                              ISN'T BOB'S
                      Z                              (123.0,0.0)
                      G                              true



 1    10.9.2         List-directed output

 2    The form of the values produced is the same as that required for input, except as noted otherwise. With
 3    the exception of adjacent nondelimited character sequences, the values are separated by one or more
 4    blanks or by a comma, or a semicolon if the decimal edit mode is comma, optionally preceded by one or
 5    more blanks and optionally followed by one or more blanks.

 6    The processor may begin new records as necessary, but the end of record shall not occur within a
 7    constant except for complex constants and character sequences. The processor shall not insert blanks
 8    within character sequences or within constants, except for complex constants.

 9    Logical output values are T for the value true and F for the value false.

10    Integer output constants are produced with the effect of an Iw edit descriptor.

11    Real constants are produced with the effect of either an F edit descriptor or an E edit descriptor,
12    depending on the magnitude x of the value and a range 10d1  x < 10d2 , where d1 and d2 are processor-
13    dependent integers. If the magnitude x is within this range or is zero, the constant is produced using
14    0PFw.d ; otherwise, 1PEw.d Ee is used.

15    For numeric output, reasonable processor-dependent values of w , d , and e are used for each of the
16    numeric constants output.

17    Complex constants are enclosed in parentheses with a separator between the real and imaginary parts,
18    each produced as defined above for real constants. The separator is a comma if the decimal edit mode is
19    POINT; it is a semicolon if the decimal edit mode is COMMA. The end of a record may occur between
20    the separator and the imaginary part only if the entire constant is as long as, or longer than, an entire
21    record. The only embedded blanks permitted within a complex constant are between the separator and
22    the end of a record and one blank at the beginning of the next record.

23    Character sequences produced when the delimiter mode has a value of NONE

24            (1)     Are not delimited by apostrophes or quotation marks,

25            (2)     Are not separated from each other by value separators,

26            (3)     Have each internal apostrophe or quotation mark represented externally by one apostrophe



      238                                   WORKING DRAFT                                         SEP 2002


      SEP 2002                                      WORKING DRAFT                                     J3/02-007R3



 1                        or quotation mark, and

 2              (4)       Have a blank character inserted by the processor at the beginning of any record that begins
 3                        with the continuation of a character sequence from the preceding record.

 4    Character sequences produced when the delimiter mode has a value of QUOTE are delimited by quotes,
 5    are preceded and followed by a value separator, and have each internal quote represented on the external
 6    medium by two contiguous quotes.

 7    Character sequences produced when the delimiter mode has a value of APOSTROPHE are delimited
 8    by apostrophes, are preceded and followed by a value separator, and have each internal apostrophe
 9    represented on the external medium by two contiguous apostrophes.

10    If two or more successive values in an output record have identical values, the processor has the option
11    of producing a repeated constant of the form r *c instead of the sequence of identical values.

12    Slashes, as value separators, and null values are not produced as output by list-directed formatting.

13    Except for continuation of delimited character sequences, each output record begins with a blank char-
14    acter.

           NOTE 10.31

           The length of the output records is not specified exactly and may be processor dependent.



15    10.10               Namelist formatting

16    Namelist input/output allows data editing with NAME=value subsequences. This facilitates documen-
17    tation of input and output files and more flexibility on input.

18    The characters in one or more namelist records constitute a sequence of name-value subsequences,
19    each of which consists of an object designator followed by an equals and followed by one or more values
20    and value separators. The equals may optionally be preceded or followed by one or more contiguous
21    blanks. The end of a record has the same effect as a blank character, unless it is within a character
22    constant. Any sequence of two or more consecutive blanks is treated as a single blank, unless it is within
23    a character constant.

24    The name may be any name in the namelist-group-object -list (5.4).

25    Each value is either a null value (10.10.1.4) or one of the forms

                  c
                  r *c
26                r *

27    where c is a literal constant, optionally signed if integer or real, and r is an unsigned, nonzero, integer
28    literal constant. Neither c nor r may have kind type parameters specified. The constant c is interpreted
29    as though it had the same kind type parameter as the corresponding list item. The r *c form is equivalent
30    to r successive appearances of the constant c, and the r * form is equivalent to r successive null values.
31    Neither of these forms may contain embedded blanks, except where permitted within the constant c.

32    A value separator for namelist formatting is the same as for list-directed formatting (10.9).


33    10.10.1             Namelist input

34    Input for a namelist input statement consists of

35              (1)       Optional blanks and namelist comments,



      SEP 2002                                          WORKING DRAFT                                           239


      J3/02-007R3                                WORKING DRAFT                                       SEP 2002



 1            (2)    The character & followed immediately by the namelist-group-name as specified in the
 2                   NAMELIST statement,

 3            (3)    One or more blanks,

 4            (4)    A sequence of zero or more name-value subsequences separated by value separators, and

 5            (5)    A slash to terminate the namelist input.

             NOTE 10.32

             A slash encountered in a namelist input record causes the input statement to terminate. A slash
             may not be used to separate two values in a namelist input statement.


 6    In each name-value subsequence, the name shall be the name of a namelist group object list item with
 7    an optional qualification and the name with the optional qualification shall not be a zero-sized array, a
 8    zero-sized array section, or a zero-length character string. The optional qualification, if any, shall not
 9    contain a vector subscript.

10    A group name or object name is without regard to case.


11    10.10.1.1      Namelist group object names

12    Within the input data, each name shall correspond to a particular namelist group object name. Sub-
13    scripts, strides, and substring range expressions used to qualify group object names shall be optionally
14    signed integer literal constants with no kind type parameters specified. If a namelist group object is
15    an array, the input record corresponding to it may contain either the array name or the designator of
16    a subobject of that array, using the syntax of object designators (R603). If the namelist group object
17    name is the name of a variable of derived type, the name in the input record may be either the name of
18    the variable or the designator of one of its components, indicated by qualifying the variable name with
19    the appropriate component name. Successive qualifications may be applied as appropriate to the shape
20    and type of the variable represented.

21    The order of names in the input records need not match the order of the namelist group object items.
22    The input records need not contain all the names of the namelist group object items. The definition
23    status of any names from the namelist-group-object -list that do not occur in the input record remains
24    unchanged. In the input record, each object name or subobject designator may be preceded and followed
25    by one or more optional blanks but shall not contain embedded blanks.


26    10.10.1.2      Namelist input values

27    The datum c (10.10) is any input value acceptable to format specifications for a given type, except for a
28    restriction on the form of input values corresponding to list items of types logical, integer, and character
29    as specified in 10.10.1.3. The form of a real or complex value is dependent on the decimal edit mode
30    in effect (10.7.8). The form of an input value shall be acceptable for the type of the namelist group
31    object list item. The number and forms of the input values that may follow the equals in a name-value
32    subsequence depend on the shape and type of the object represented by the name in the input record.
33    When the name in the input record is that of a scalar variable of an intrinsic type, the equals shall
34    not be followed by more than one value. Blanks are never used as zeros, and embedded blanks are not
35    permitted in constants except within character constants and complex constants as specified in 10.10.1.3.

36    The name-value subsequences are evaluated serially, in left-to-right order. A namelist group object
37    designator may appear in more than one name-value sequence.

38    When the name in the input record represents an array variable or a variable of derived type, the effect
39    is as if the variable represented were expanded into a sequence of scalar list items of intrinsic data types,
40    in the same way that formatted input/output list items are expanded (9.5.2). Each input value following
41    the equals shall then be acceptable to format specifications for the intrinsic type of the list item in the




      240                                     WORKING DRAFT                                          SEP 2002


      SEP 2002                               WORKING DRAFT                                       J3/02-007R3



 1    corresponding position in the expanded sequence, except as noted in 10.10.1.3. The number of values
 2    following the equals shall not exceed the number of list items in the expanded sequence, but may be less;
 3    in the latter case, the effect is as if sufficient null values had been appended to match any remaining list
 4    items in the expanded sequence.

           NOTE 10.33

           For example, if the name in the input record is the name of an integer array of size 100, at most
           100 values, each of which is either a digit string or a null value, may follow the equals; these values
           would then be assigned to the elements of the array in array element order.


 5    A slash encountered as a value separator during the execution of a namelist input statement causes
 6    termination of execution of that input statement after assignment of the previous value. If there are
 7    additional items in the namelist group object being transferred, the effect is as if null values had been
 8    supplied for them.

 9    A namelist comment may appear after any value separator except a slash. A namelist comment is also
10    permitted to start in the first nonblank position of an input record except within a character literal
11    constant.

12    Successive namelist records are read by namelist input until a slash is encountered; the remainder of the
13    record is ignored and need not follow the rules for namelist input values.


14    10.10.1.3    Namelist group object list items

15    When the next effective namelist group object list item is of type real, the input form of the input value
16    is that of a numeric input field. A numeric input field is a field suitable for F editing (10.6.1.2.1) that is
17    assumed to have no fractional digits unless a decimal symbol appears within the field.

18    When the next effective item is of type complex, the input form of the input value consists of a left
19    parenthesis followed by an ordered pair of numeric input fields separated by a comma and followed by a
20    right parenthesis. The first numeric input field is the real part of the complex constant and the second
21    part is the imaginary part. Each of the numeric input fields may be preceded or followed by any number
22    of blanks and ends of records. The end of a record may occur between the real part and the comma or
23    between the comma and the imaginary part.

24    When the next effective item is of type logical, the input form of the input value shall not include equals
25    or value separators among the optional characters permitted for L editing (10.6.2).

26    When the next effective item is of type integer, the value in the input record is interpreted as if an Iw
27    edit descriptor with a suitable value of w were used.

28    When the next effective item is of type character, the input form consists of a delimited sequence of zero
29    or more rep-char s whose kind type parameter is implied by the kind of the corresponding list item. Such
30    a sequence may be continued from the end of one record to the beginning of the next record, but the
31    end of record shall not occur between a doubled apostrophe in an apostrophe-delimited sequence, nor
32    between a doubled quote in a quote-delimited sequence. The end of the record does not cause a blank
33    or any other character to become part of the sequence. The sequence may be continued on as many
34    records as needed. The characters blank, comma, and slash may appear in such character sequences.

           NOTE 10.34

           A character sequence corresponding to a namelist input item of character type shall be delimited
           either with apostrophes or with quotes. The delimiter is required to avoid ambiguity between
           undelimited character sequences and object names. The value of the DELIM= specifier, if any, in
           the OPEN statement for an external file is ignored during namelist input (9.4.5.6).





      SEP 2002                                     WORKING DRAFT                                              241


      J3/02-007R3                                 WORKING DRAFT                                     SEP 2002



 1    Let len be the length of the next effective item, and let w be the length of the character sequence. If
 2    len is less than or equal to w, the leftmost len characters of the sequence are transmitted to the next
 3    effective item. If len is greater than w, the constant is transmitted to the leftmost w characters of the
 4    next effective item and the remaining len-w characters of the next effective item are filled with blanks.
 5    The effect is as though the sequence were assigned to the next effective item in a character assignment
 6    statement (7.4.1.3).


 7    10.10.1.4      Null values

 8    A null value is specified by

 9            (1)    The r * form,

10            (2)    Blanks between two consecutive value separators following an equals,

11            (3)    Zero or more blanks preceding the first value separator and following an equals, or

12            (4)    Two consecutive nonblank value separators.

13    A null value has no effect on the definition status of the corresponding input list item. If the namelist
14    group object list item is defined, it retains its previous value; if it is undefined, it remains undefined. A
15    null value shall not be used as either the real or imaginary part of a complex constant, but a single null
16    value may represent an entire complex constant.

             NOTE 10.35

             The end of a record following a value separator, with or without intervening blanks, does not
             specify a null value in namelist input.


17    10.10.1.5      Blanks

18    All blanks in a namelist input record are considered to be part of some value separator except for

19            (1)    Blanks embedded in a character constant,

20            (2)    Embedded blanks surrounding the real or imaginary part of a complex constant,

21            (3)    Leading blanks following the equals unless followed immediately by a slash or comma, or a
22                   semicolon if the decimal edit mode is comma, and

23            (4)    Blanks between a name and the following equals.


24    10.10.1.6      Namelist Comments

25    Except within a character literal constant, a "!" character after a value separator or in the first nonblank
26    position of a namelist input record initiates a comment. The comment extends to the end of the current
27    input record and may contain any graphic character in the processor-dependent character set. The
28    comment is ignored. A slash within the namelist comment does not terminate execution of the namelist
29    input statement. Namelist comments are not allowed in stream input because comments depend on
30    record structure.

             NOTE 10.36

             Namelist input example:


             INTEGER I; REAL X (8); CHARACTER (11) P; COMPLEX Z;
             LOGICAL G
             NAMELIST / TODAY / G, I, P, Z, X
             READ (*, NML = TODAY)


             The input data records are:





      242                                   WORKING DRAFT                                           SEP 2002


      SEP 2002                                WORKING DRAFT                                   J3/02-007R3



           NOTE 10.36 (cont.)

          &TODAY I = 12345, X(1) = 12345, X(3:4) = 2*1.5, I=6, ! This is a comment.
          P = ''ISN'T_BOB'S'', Z = (123,0)/


          The results stored are:

                   Variable                        Value
                   I                               6
                   X (1)                           12345.0
                   X (2)                           unchanged
                   X (3)                           1.5
                   X (4)                           1.5
                   X (5) � X (8)                   unchanged
                   P                               ISN'T BOB'S
                   Z                               (123.0,0.0)
                   G                               unchanged



 1    10.10.2      Namelist output

 2    The form of the output produced is the same as that required for input, except for the forms of real,
 3    character, and logical values. The name in the output is in upper case. With the exception of adjacent
 4    nondelimited character values, the values are separated by one or more blanks or by a comma, or a
 5    semicolon if the decimal edit mode is COMMA, optionally preceded by one or more blanks and optionally
 6    followed by one or more blanks.

 7    Namelist output shall not include namelist comments.

 8    The processor may begin new records as necessary. However, except for complex constants and character
 9    values, the end of a record shall not occur within a constant, character value, or name, and blanks shall
10    not appear within a constant, character value, or name.

           NOTE 10.37

          The length of the output records is not specified exactly and may be processor dependent.


11    10.10.2.1    Namelist output editing

12    Logical output values are T for the value true and F for the value false.

13    Integer output constants are produced with the effect of an Iw edit descriptor.

14    Real constants are produced with the effect of either an F edit descriptor or an E edit descriptor,
15    depending on the magnitude x of the value and a range 10d1  x < 10d2 , where d1 and d2 are processor-
16    dependent integers. If the magnitude x is within this range or is zero, the constant is produced using
17    0PFw.d ; otherwise, 1PEw.d Ee is used.

18    For numeric output, reasonable processor-dependent integer values of w, d, and e are used for each of
19    the numeric constants output.

20    Complex constants are enclosed in parentheses with a separator between the real and imaginary parts,
21    each produced as defined above for real constants. The separator is a comma if the decimal edit mode is
22    POINT; it is a semicolon if the decimal edit mode is COMMA. The end of a record may occur between
23    the separator and the imaginary part only if the entire constant is as long as, or longer than, an entire
24    record. The only embedded blanks permitted within a complex constant are between the separator and
25    the end of a record and one blank at the beginning of the next record.




      SEP 2002                                   WORKING DRAFT                                            243


      J3/02-007R3                                  WORKING DRAFT                                     SEP 2002



 1    Character sequences produced when the delimiter mode has a value of NONE

 2              (1)    Are not delimited by apostrophes or quotation marks,

 3              (2)    Are not separated from each other by value separators,

 4              (3)    Have each internal apostrophe or quotation mark represented externally by one apostrophe
 5                     or quotation mark, and

 6              (4)    Have a blank character inserted by the processor at the beginning of any record that begins
 7                     with the continuation of a character sequence from the preceding record.

             NOTE 10.38

             Namelist output records produced with a DELIM= specifier with a value of NONE and which
             contain a character sequence may not be acceptable as namelist input records.


 8    Character sequences produced when the delimiter mode has a value of QUOTE are delimited by quotes,
 9    are preceded and followed by a value separator, and have each internal quote represented on the external
10    medium by two contiguous quotes.

11    Character sequences produced when the delimiter mode has a value of APOSTROPHE are delimited
12    by apostrophes, are preceded and followed by a value separator, and have each internal apostrophe
13    represented on the external medium by two contiguous apostrophes.


14    10.10.2.2        Namelist output records

15    If two or more successive values in an array in an output record produced have identical values, the
16    processor has the option of producing a repeated constant of the form r *c instead of the sequence of
17    identical values.

18    The name of each namelist group object list item is placed in the output record followed by an equals
19    and a list of values of the namelist group object list item.

20    An ampersand character followed immediately by a namelist-group-name will be produced by namelist
21    formatting at the start of the first output record to indicate which particular group of data objects is
22    being output. A slash is produced by namelist formatting to indicate the end of the namelist formatting.

23    A null value is not produced by namelist formatting.

24    Except for continuation of delimited character sequences, each output record begins with a blank char-
25    acter.





      244                                    WORKING DRAFT                                           SEP 2002


      SEP 2002                             WORKING DRAFT                                     J3/02-007R3





 1    Section 11: Program units

 2    The terms and basic concepts of program units were introduced in 2.2. A program unit is a main
 3    program, an external subprogram, a module, or a block data program unit.

 4    This section describes main programs, modules, and block data program units. Section 12 describes
 5    external subprograms.


 6    11.1      Main program

 7    A Fortran main program is a program unit that does not contain a SUBROUTINE, FUNCTION,
 8    MODULE, or BLOCK DATA statement as its first statement.

 9    R1101 main-program                   is     [ program-stmt ]
10                                                    [ specification-part ]
11                                                    [ execution-part ]
12                                                    [ internal-subprogram-part ]
13                                                    end-program-stmt
14    R1102 program-stmt                   is     PROGRAM program-name
15    R1103 end-program-stmt               is     END [ PROGRAM [ program-name ] ]

16    C1101    (R1101) In a main-program, the execution-part shall not contain a RETURN statement or an
17             ENTRY statement.

18    C1102    (R1101) The program-name may be included in the end-program-stmt only if the optional
19             program-stmt is used and, if included, shall be identical to the program-name specified in the
20             program-stmt .

21    C1103    (R1101) An automatic object shall not appear in the specification-part (R204) of a main program.

          NOTE 11.1

          The program name is global to the program (16.1). For explanatory information about uses for
          the program name, see section C.8.1.


          NOTE 11.2

          An example of a main program is:


          PROGRAM ANALYZE
               REAL A, B, C (10,10)          !    Specification part
               CALL FIND                     !    Execution part
          CONTAINS
               SUBROUTINE FIND               !    Internal subprogram
                    ...
               END SUBROUTINE FIND
          END PROGRAM ANALYZE



22    The main program may be defined by means other than Fortran; in that case, the program shall not
23    contain a main-program program unit.

24    A reference to a Fortran main-program shall not appear in any program unit in the program, including



      SEP 2002                                     WORKING DRAFT                                         245


      J3/02-007R3                                   WORKING DRAFT                                   SEP 2002



 1    itself.


 2    11.2        Modules

 3    A module contains specifications and definitions that are to be accessible to other program units. A
 4    module that is provided as an inherent part of the processor is an intrinsic module. A nonintrinsic
 5    module is defined by a module program unit or a means other than Fortran.

 6    Procedures and types defined in an intrinsic module are not themselves intrinsic.

 7    R1104 module                            is    module-stmt
 8                                                      [ specification-part ]
 9                                                      [ module-subprogram-part ]
10                                                      end-module-stmt
11    R1105 module-stmt                       is    MODULE module-name
12    R1106 end-module-stmt                   is    END [ MODULE [ module-name ] ]
13    R1107 module-subprogram-part            is    contains-stmt
14                                                      module-subprogram
15                                                      [ module-subprogram ] ...
16    R1108 module-subprogram                 is    function-subprogram
17                                            or subroutine-subprogram

18    C1104      (R1104) If the module-name is specified in the end-module-stmt , it shall be identical to the
19               module-name specified in the module-stmt .

20    C1105      (R1104) A module specification-part shall not contain a stmt-function-stmt , an entry-stmt , or a
21               format-stmt .

22    C1106      (R1104) An automatic object shall not appear in the specification-part of a module.

23    C1107      (R1104) If an object of a type for which component-initialization is specified (R435) appears
24               in the specification-part of a module and does not have the ALLOCATABLE or POINTER
25               attribute, the object shall have the SAVE attribute.

             NOTE 11.3

             The module name is global to the program (16.1).


             NOTE 11.4

             Although statement function definitions, ENTRY statements, and FORMAT statements shall not
             appear in the specification part of a module, they may appear in the specification part of a module
             subprogram in the module.

             A module is host to any module subprograms (12.1.2.2) it contains, and the entities in the module
             are therefore accessible in the module subprograms through host association.


             NOTE 11.5

             For a discussion of the impact of modules on dependent compilation, see section C.8.2.


             NOTE 11.6

             For examples of the use of modules, see section C.8.3.





      246                                   WORKING DRAFT                                           SEP 2002


      SEP 2002                                  WORKING DRAFT                                      J3/02-007R3


 1    11.2.1       Module reference

 2    A USE statement specifying a module name is a module reference. At the time a module reference is
 3    processed, the public portions of the specified module shall be available. A module shall not reference
 4    itself, either directly or indirectly.

 5    The accessibility, public or private, of specifications and definitions in a module to a scoping unit mak-
 6    ing reference to the module may be controlled in both the module and the scoping unit making the
 7    reference. In the module, the PRIVATE statement, the PUBLIC statement (5.2.1), their equivalent
 8    attributes (5.1.2.1), and the PRIVATE statement in a derived-type definition (4.5.1) are used to control
 9    the accessibility of module entities outside the module. The PROTECTED statement (5.2.11) and the
10    PROTECTED attribute (5.1.2.12) are used to control the definability of module entities outside the
11    module.

           NOTE 11.7

           For a discussion of the impact of accessibility on dependent compilation, see section C.8.2.2.


12    In a scoping unit making reference to a module, the ONLY option in the USE statement may be used
13    to further limit the accessibility, in that referencing scoping unit, of the public entities in the module.


14    11.2.2       The USE statement and use association

15    The USE statement provides the means by which a scoping unit accesses named data objects, derived
16    types, type aliases, interface blocks, procedures, abstract interfaces, generic identifiers (12.3.2.1), and
17    namelist groups in a module. The entities in the scoping unit are said to be use associated with the
18    entities in the module. The accessed entities have the attributes specified in the module. The entities
19    made accessible are identified by the names or generic identifiers used to identify them in the module.
20    By default, they are identified by the same identifiers in the scoping unit containing the USE statement,
21    but it is possible to specify that different local identifiers be used.

22    R1109 use-stmt                            is    USE [ [ , module-nature ] :: ] module-name [ , rename-list ]
23                                              or USE [ [ , module-nature ] :: ] module-name ,
24                                                      ONLY : [ only-list ]
25    R1110 module-nature                       is    INTRINSIC
26                                              or NON INTRINSIC
27    R1111 rename                              is    local-name => use-name
28                                              or OPERATOR (local-defined-operator ) =>
29                                                      OPERATOR (use-defined-operator )
30    R1112 only                                is    generic-spec
31                                              or only-use-name
32                                              or rename
33    R1113 only-use-name                       is    use-name

34    C1108      (R1109) If module-nature is INTRINSIC, module-name shall be the name of an intrinsic module.

35    C1109      (R1109) If module-nature is NON INTRINSIC, module-name shall be the name of a nonintrinsic
36               module.

37    C1110      (R1111) OPERATOR(use-defined-operator ) shall not identify a generic-binding.

38    C1111      (R1112) The generic-spec shall not identify a generic-binding.

           NOTE 11.8

           The above two constraints do not prevent accessing a generic-spec that is declared by an interface
           block, even if a generic-binding has the same generic-spec.




      SEP 2002                                         WORKING DRAFT                                           247


      J3/02-007R3                                    WORKING DRAFT                                    SEP 2002



 1    C1112      (R1112) Each generic-spec shall be a public entity in the module.

 2    C1113      (R1113) Each use-name shall be the name of a public entity in the module.

 3    R1114 local-defined-operator              is    defined-unary-op
 4                                             or defined-binary-op
 5    R1115 use-defined-operator                is    defined-unary-op
 6                                             or defined-binary-op

 7    C1114      (R1115) Each use-defined-operator shall be a public entity in the module.

 8    A use-stmt without a module-nature provides access either to an intrinsic or to a nonintrinsic module.
 9    If the module-name is the name of both an intrinsic and a nonintrinsic module, the nonintrinsic module
10    is accessed.

11    The USE statement without the ONLY option provides access to all public entities in the specified
12    module.

13    A USE statement with the ONLY option provides access only to those entities that appear as generic-
14    specs, use-names, or use-defined-operator s in the only-list.

15    More than one USE statement for a given module may appear in a scoping unit. If one of the USE
16    statements is without an ONLY qualifier, all public entities in the module are accessible. If all the USE
17    statements have ONLY qualifiers, only those entities in one or more of the only-list s are accessible.

18    An accessible entity in the referenced module has one or more local identifiers. These identifiers are

19            (1)     The identifier of the entity in the referenced module if that identifier appears as an only-
20                    use-name or as the defined-operator of a generic-spec in any only for that module,

21            (2)     Each of the local-names or local-defined-operator s that the entity is given in any rename for
22                    that module, and

23            (3)     The identifier of the entity in the referenced module if that identifier does not appear as a
24                    use-name or use-defined-operator in any rename for that module.

25    Two or more accessible entities, other than generic interfaces or defined operators, may have the same
26    identifier only if the identifier is not used to refer to an entity in the scoping unit. Generic interfaces and
27    defined operators are handled as described in section 16.2.3. Except for these cases, the local identifier
28    of any entity given accessibility by a USE statement shall differ from the local identifiers of all other
29    entities accessible to the scoping unit through USE statements and otherwise.

             NOTE 11.9

             There is no prohibition against a use-name or use-defined-operator appearing multiple times in
             one USE statement or in multiple USE statements involving the same module. As a result, it is
             possible for one use-associated entity to be accessible by more than one local identifier.


30    The local identifier of an entity made accessible by a USE statement shall not appear in any other
31    nonexecutable statement that would cause any attribute (5.1.2) of the entity to be specified in the
32    scoping unit that contains the USE statement, except that it may appear in a PUBLIC or PRIVATE
33    statement in the scoping unit of a module and it may be given the ASYNCHRONOUS or VOLATILE
34    attribute.

35    The appearance of such a local identifier in a PUBLIC statement in a module causes the entity accessible
36    by the USE statement to be a public entity of that module. If the identifier appears in a PRIVATE
37    statement in a module, the entity is not a public entity of that module. If the local identifier does not
38    appear in either a PUBLIC or PRIVATE statement, it assumes the default accessibility attribute (5.2.1)
39    of that scoping unit.



      248                                    WORKING DRAFT                                            SEP 2002


      SEP 2002                              WORKING DRAFT                                     J3/02-007R3



           NOTE 11.10

           The constraints in sections 5.5.1, 5.5.2, and 5.4 prohibit the local-name from appearing as a
           common-block-object in a COMMON statement, an equivalence-object in an EQUIVALENCE state-
           ment, or a namelist-group-name in a NAMELIST statement, respectively. There is no prohibition
           against the local-name appearing as a common-block-name or a namelist-group-object .


 1    If a procedure declared in the scoping unit of a module has an implicit interface, it shall explicitly be
 2    given the EXTERNAL attribute in that scoping unit; if it is a function, its type and type parameters
 3    shall be explicitly declared in a type declaration statement in that scoping unit.

 4    If an intrinsic procedure is declared in the scoping unit of a module, it shall explicitly be given the
 5    INTRINSIC attribute in that scoping unit or be used as an intrinsic procedure in that scoping unit.

           NOTE 11.11

           For a discussion of the impact of the ONLY clause and renaming on dependent compilation, see
           section C.8.2.1.


           NOTE 11.12

           Examples:


           USE STATS LIB


           provides access to all public entities in the module STATS LIB.


           USE MATH LIB; USE STATS LIB, SPROD => PROD


           makes all public entities in both MATH LIB and STATS LIB accessible. If MATH LIB contains
           an entity called PROD, it is accessible by its own name while the entity PROD of STATS LIB is
           accessible by the name SPROD.


           USE STATS LIB, ONLY: YPROD; USE STATS LIB, ONLY : PROD


           makes public entities YPROD and PROD in STATS LIB accessible.


           USE STATS LIB, ONLY : YPROD; USE STATS LIB


           makes all public entities in STATS LIB accessible.



 6    11.3      Block data program units

 7    A block data program unit is used to provide initial values for data objects in named common blocks.

 8    R1116 block-data                      is    block-data-stmt
 9                                                    [ specification-part ]
10                                                    end-block-data-stmt
11    R1117 block-data-stmt                 is    BLOCK DATA [ block-data-name ]
12    R1118 end-block-data-stmt             is    END [ BLOCK DATA [ block-data-name ] ]

13    C1115    (R1116) The block-data-name may be included in the end-block-data-stmt only if it was provided
14             in the block-data-stmt and, if included, shall be identical to the block-data-name in the block-
15             data-stmt .




      SEP 2002                                     WORKING DRAFT                                          249


      J3/02-007R3                                WORKING DRAFT                                    SEP 2002



 1    C1116     (R1116) A block-data specification-part may contain only USE statements, type declaration
 2              statements, IMPLICIT statements, PARAMETER statements, derived-type definitions, and
 3              the following specification statements: COMMON, DATA, DIMENSION, EQUIVALENCE, IN-
 4              TRINSIC, POINTER, SAVE, and TARGET.

 5    C1117     (R1116) A type declaration statement in a block-data specification-part shall not contain AL-
 6              LOCATABLE, EXTERNAL, or BIND attribute specifiers.

             NOTE 11.13

             For explanatory information about the uses for the block-data-name, see section C.8.1.


 7    If an object in a named common block is initially defined, all storage units in the common block storage
 8    sequence shall be specified even if they are not all initially defined. More than one named common block
 9    may have objects initially defined in a single block data program unit.

             NOTE 11.14

             In the example


                  BLOCK DATA INIT
                      REAL A, B, C, D, E, F
                      COMMON /BLOCK1/ A, B, C, D
                      DATA A /1.2/, C /2.3/
                      COMMON /BLOCK2/ E, F
                      DATA F /6.5/
                  END BLOCK DATA INIT


             common blocks BLOCK1 and BLOCK2 both have objects that are being initialized in a single
             block data program unit. B, D, and E are not initialized but they need to be specified as part of
             the common blocks.


10    Only an object in a named common block may be initially defined in a block data program unit.

             NOTE 11.15

             Objects associated with an object in a common block are considered to be in that common block.


11    The same named common block shall not be specified in more than one block data program unit in a
12    program.

13    There shall not be more than one unnamed block data program unit in a program.

             NOTE 11.16

             An example of a block data program unit is:


             BLOCK DATA WORK
                COMMON /WRKCOM/ A, B, C (10, 10)
                REAL :: A, B, C
                DATA A /1.0/, B /2.0/, C /100 * 0.0/
             END BLOCK DATA WORK





      250                                  WORKING DRAFT                                          SEP 2002


      SEP 2002                              WORKING DRAFT                                      J3/02-007R3





 1    Section 12: Procedures

 2    The concept of a procedure was introduced in 2.2.3. This section contains a complete description of
 3    procedures. The actions specified by a procedure are performed when the procedure is invoked by
 4    execution of a reference to it.

 5    The sequence of actions encapsulated by a procedure has access to entities in the invoking scoping
 6    unit by way of argument association (12.4.1). A dummy argument is a name that appears in the
 7    SUBROUTINE, FUNCTION, or ENTRY statement in the declaration of a procedure (R1232). Dummy
 8    arguments are also specified for intrinsic procedures and procedures in intrinsic modules in Sections 13,
 9    14, and 15.

10    The entities in the invoking scoping unit are specified by actual arguments. An actual argument is an
11    entity that appears in a procedure reference (R1221).

12    A procedure may also have access to entities in other scoping units, not necessarily the invoking scoping
13    unit, by use association (16.4.1.2), host association (16.4.1.3), linkage association (16.4.1.4), storage
14    association (16.4.3), or by reference to external procedures (5.1.2.6).


15    12.1          Procedure classifications

16    A procedure is classified according to the form of its reference and the way it is defined.


17    12.1.1        Procedure classification by reference

18    The definition of a procedure specifies it to be a function or a subroutine. A reference to a function either
19    appears explicitly as a primary within an expression, or is implied by a defined operation (7.1.3) within
20    an expression. A reference to a subroutine is a CALL statement or a defined assignment statement
21    (7.4.1.4).

22    A procedure is classified as elemental if it is a procedure that may be referenced elementally (12.7).


23    12.1.2        Procedure classification by means of definition

24    A procedure is either an intrinsic procedure, an external procedure, a module procedure, an internal
25    procedure, a dummy procedure (which may be a dummy procedure pointer), a nondummy procedure
26    pointer, or a statement function.


27    12.1.2.1      Intrinsic procedures

28    A procedure that is provided as an inherent part of the processor is an intrinsic procedure.


29    12.1.2.2      External, internal, and module procedures

30    An external procedure is a procedure that is defined by an external subprogram or by a means other
31    than Fortran.

32    An internal procedure is a procedure that is defined by an internal subprogram. Internal subprograms
33    may appear in the main program, in an external subprogram, or in a module subprogram. Internal
34    subprograms shall not appear in other internal subprograms. Internal subprograms are the same as
35    external subprograms except that the name of the internal procedure is not a global entity, an internal



      SEP 2002                                    WORKING DRAFT                                             251


      J3/02-007R3                                   WORKING DRAFT                                         SEP 2002



 1    subprogram shall not contain an ENTRY statement, the internal procedure name shall not be argument
 2    associated with a dummy procedure (12.4.1.3), and the internal subprogram has access to host entities
 3    by host association.

 4    A module procedure is a procedure that is defined by a module subprogram.

 5    A subprogram defines a procedure for the SUBROUTINE or FUNCTION statement. If the subprogram
 6    has one or more ENTRY statements, it also defines a procedure for each of them.


 7    12.1.2.3    Dummy procedures

 8    A dummy argument that is specified to be a procedure or appears in a procedure reference is a dummy
 9    procedure. A dummy procedure with the POINTER attribute is a dummy procedure pointer.


10    12.1.2.4    Procedure pointers

11    A procedure pointer is a procedure that has the EXTERNAL and POINTER attributes; it may be
12    pointer associated with an external procedure, a module procedure, an intrinsic procedure, or a dummy
13    procedure that is not a procedure pointer. A procedure pointer may be a dummy argument, a structure
14    component, or a local entity.


15    12.1.2.5    Statement functions


16    A function that is defined by a single statement is a statement function (12.5.4).



17    12.2        Characteristics of procedures

18    The characteristics of a procedure are the classification of the procedure as a function or subroutine,
19    whether it is pure, whether it is elemental, whether it has the BIND attribute, the characteristics of its
20    dummy arguments, and the characteristics of its result value if it is a function.


21    12.2.1      Characteristics of dummy arguments

22    Each dummy argument has the characteristic that it is a dummy data object, a dummy procedure, a
23    dummy procedure pointer, or an asterisk (alternate return indicator). A dummy argument other than an asterisk
24    may be specified to have the OPTIONAL attribute. This attribute means that the dummy argument
25    need not be associated with an actual argument for any particular reference to the procedure.


26    12.2.1.1    Characteristics of dummy data objects

27    The characteristics of a dummy data object are its type, its type parameters (if any), its shape, its
28    intent (5.1.2.7, 5.2.7), whether it is optional (5.1.2.9, 5.2.8), whether it is allocatable (5.1.2.5.3), whether
29    it has the VALUE (5.1.2.15), ASYNCHRONOUS (5.1.2.3), or VOLATILE (5.1.2.16) attributes, whether
30    it is polymorphic, and whether it is a pointer (5.1.2.11, 5.2.10) or a target (5.1.2.14, 5.2.13). If a type
31    parameter of an object or a bound of an array is not an initialization expression, the exact dependence
32    on the entities in the expression is a characteristic. If a shape, size, or type parameter is assumed or
33    deferred, it is a characteristic.


34    12.2.1.2    Characteristics of dummy procedures and dummy procedure pointers

35    The characteristics of a dummy procedure are the explicitness of its interface (12.3.1), its characteristics
36    as a procedure if the interface is explicit, whether it is a pointer, and whether it is optional (5.1.2.9, 5.2.8).





      252                                     WORKING DRAFT                                               SEP 2002


      SEP 2002                                        WORKING DRAFT                                 J3/02-007R3



 1    12.2.1.3      Characteristics of asterisk dummy arguments


 2    An asterisk as a dummy argument has no characteristics.


 3    12.2.2        Characteristics of function results

 4    The characteristics of a function result are its type, type parameters (if any), rank, whether it is poly-
 5    morphic, whether it is allocatable, whether it is a pointer, and whether it is a procedure pointer. If a
 6    function result is an array that is not allocatable or a pointer, its shape is a characteristic. If a type
 7    parameter of a function result or a bound of a function result array is not an initialization expression, the
 8    exact dependence on the entities in the expression is a characteristic. If type parameters of a function
 9    result are deferred, which parameters are deferred is a characteristic. If the length of a character function

10    result is assumed, this is a characteristic.



11    12.3          Procedure interface

12    An abstract interface consists of procedure characteristics and the names of dummy arguments.

13    The interface of a procedure determines the forms of reference through which it may be invoked.
14    The procedure's interface consists of its abstract interface, its name, its binding label if any, and the
15    procedure's generic identifiers, if any. The characteristics of a procedure are fixed, but the remainder of
16    the interface may differ in different scoping units.

            NOTE 12.1

            For more explanatory information on procedure interfaces, see C.9.3.


17    12.3.1        Implicit and explicit interfaces

18    If a procedure is accessible in a scoping unit, its interface is either explicit or implicit in that scoping
19    unit. The interface of an internal procedure, module procedure, or intrinsic procedure is always explicit
20    in such a scoping unit. The interface of a subroutine or a function with a separate result name is explicit
21    within the subprogram that defines it. The interface of a statement function is always implicit. The interface of
22    an external procedure or dummy procedure is explicit in a scoping unit other than its own if an interface
23    body (12.3.2.1) for the procedure is supplied or accessible, and implicit otherwise.

            NOTE 12.2

            For example, the subroutine LLS of C.8.3.5 has an explicit interface.


24    12.3.1.1      Explicit interface

25    A procedure other than a statement function shall have an explicit interface if it is referenced and

26           (1)     A reference to the procedure appears

27                   (a)     With an argument keyword (12.4.1),

28                   (b)     As a reference by its generic name (12.3.2.1),

29                   (c)     As a defined assignment (subroutines only),

30                   (d)     In an expression as a defined operator (functions only), or

31                   (e)     In a context that requires it to be pure,

32           (2)     The procedure has a dummy argument that

33                   (a)     has the ALLOCATABLE, ASYNCHRONOUS, OPTIONAL, POINTER, TARGET,
34                           VALUE, or VOLATILE attribute,




      SEP 2002                                           WORKING DRAFT                                           253


      J3/02-007R3                                      WORKING DRAFT                                       SEP 2002



 1                    (b)    is an assumed-shape array,

 2                    (c)    is of a parameterized derived type, or

 3                    (d)    is polymorphic,

 4            (3)     The procedure has a result that

 5                    (a)    is an array,

 6                    (b)    is a pointer or is allocatable, or

 7                    (c)    has a nonassumed type parameter value that is not an initialization expression,

 8            (4)     The procedure is elemental, or

 9            (5)     The procedure has the BIND attribute.


10    12.3.2         Specification of the procedure interface

11    The interface for an internal, external, module, or dummy procedure is specified by a FUNCTION,
12    SUBROUTINE, or ENTRY statement and by specification statements for the dummy arguments and
13    the result of a function. These statements may appear in the procedure definition, in an interface body,
14    or both, except that the ENTRY statement shall not appear in an interface body.

             NOTE 12.3

             An interface body cannot be used to describe the interface of an internal procedure, a module
             procedure, or an intrinsic procedure because the interfaces of such procedures are already explicit.
             However, the name of a procedure may appear in a PROCEDURE statement in an interface block
             (12.3.2.1).


15    12.3.2.1       Interface block

16    R1201 interface-block                      is    interface-stmt
17                                                         [ interface-specification ] ...
18                                                         end-interface-stmt
19    R1202 interface-specification               is    interface-body
20                                               or procedure-stmt
21    R1203 interface-stmt                       is    INTERFACE [ generic-spec ]
22                                               or ABSTRACT INTERFACE
23    R1204 end-interface-stmt                   is    END INTERFACE [ generic-spec ]
24    R1205 interface-body                       is    function-stmt
25                                                         [ specification-part ]
26                                                         end-function-stmt
27                                               or subroutine-stmt
28                                                         [ specification-part ]
29                                                         end-subroutine-stmt

30    C1201     (R1201) An interface-block in a subprogram shall not contain an interface-body for a procedure
31              defined by that subprogram.

32    C1202     (R1201) The generic-spec may be included in the end-interface-stmt only if it was provided in the
33              interface-stmt . If the end-interface-stmt includes generic-name, the interface-stmt shall specify
34              the same generic-name. If the end-interface-stmt includes ASSIGNMENT(=), the interface-
35              stmt shall specify ASSIGNMENT(=).                  If the end-interface-stmt includes dtio-generic-spec,
36              the interface-stmt shall specify the same dtio-generic-spec. If the end-interface-stmt includes
37              OPERATOR(defined-operator ), the interface-stmt shall specify the same defined-operator . If
38              one defined-operator is .LT., .LE., .GT., .GE., .EQ., or .NE., the other is permitted to be the
39              corresponding operator <, <=, >, >=, ==, or /=.





      254                                       WORKING DRAFT                                              SEP 2002


      SEP 2002                                 WORKING DRAFT                                   J3/02-007R3



 1    C1203     (R1203) If the interface-stmt is ABSTRACT INTERFACE, then the function-name in the
 2              function-stmt or the subroutine-name in the subroutine-stmt shall not be the same as a keyword
 3              that specifies an intrinsic type.

 4    C1204     (R1202) A procedure-stmt is allowed only in an interface block that has a generic-spec.

 5    C1205     (R1205) An interface-body of a pure procedure shall specify the intents of all dummy arguments
 6              except pointer, alternate return, and procedure arguments.

 7    C1206     (R1205) An interface-body shall not contain an entry-stmt , data-stmt , format-stmt , or stmt-

 8              function-stmt .


 9    R1206 procedure-stmt                     is    [ MODULE ] PROCEDURE procedure-name-list
10    R1207 generic-spec                       is    generic-name
11                                             or OPERATOR ( defined-operator )
12                                             or ASSIGNMENT ( = )
13                                             or dtio-generic-spec
14    R1208 dtio-generic-spec                  is    READ (FORMATTED)
15                                             or READ (UNFORMATTED)
16                                             or WRITE (FORMATTED)
17                                             or WRITE (UNFORMATTED)

18    C1207     (R1206) A procedure-name shall have an explicit interface and shall refer to an accessible pro-
19              cedure pointer, external procedure, dummy procedure, or module procedure.

20    C1208     (R1206) If MODULE appears in a procedure-stmt , each procedure-name in that statement shall
21              be accessible in the current scope as a module procedure.

22    C1209     (R1206) A procedure-name shall not specify a procedure that is specified previously in any
23              procedure-stmt in any accessible interface with the same generic identifier.

24    R1209 import-stmt                        is    IMPORT [[ :: ] import-name-list ]

25    C1210     (R1209) The IMPORT statement is allowed only in an interface-body.

26    C1211     (R1209) Each import-name shall be the name of an entity in the host scoping unit.

27    An external or module subprogram specifies a specific interface for the procedures defined in that
28    subprogram. Such a specific interface is explicit for module procedures and implicit for external proce-
29    dures.

30    An interface block introduced by ABSTRACT INTERFACE is an abstract interface block. An
31    interface body in an abstract interface block specifies an abstract interface. An interface block with
32    a generic specification is a generic interface block. An interface block without a generic specification
33    is a specific interface block.

34    The name of the entity declared by an interface body is the function-name in the function-stmt or the
35    subroutine-name in the subroutine-stmt that begins the interface body.

36    An interface body in a generic or specific interface block specifies the EXTERNAL attribute and an
37    explicit specific interface for an external procedure or a dummy procedure. If the name of the declared
38    procedure is that of a dummy argument in the subprogram containing the interface body, the procedure
39    is a dummy procedure; otherwise, it is an external procedure. An interface body in an abstract interface
40    block specifies an abstract interface.

41    An interface body specifies all of the characteristics of the explicit interface or abstract interface. The
42    specification part of an interface body may specify attributes or define values for data entities that do
43    not determine characteristics of the procedure. Such specifications have no effect.



      SEP 2002                                        WORKING DRAFT                                        255


      J3/02-007R3                                WORKING DRAFT                                   SEP 2002



 1    If an explicit specific interface is specified by an interface body or a procedure declaration statement
 2    (12.3.2.3) for an external procedure, the characteristics shall be consistent with those specified in the
 3    procedure definition, except that the interface may specify a procedure that is not pure if the procedure
 4    is defined to be pure. An interface for a procedure named by an ENTRY statement may be specified by
 5    using the entry name as the procedure name in the interface body. An explicit specific interface may
 6    be specified by an interface body for an external procedure that does not exist in the program if the
 7    procedure is never used in any way. A procedure shall not have more than one explicit specific interface
 8    in a given scoping unit.

             NOTE 12.4

             The dummy argument names may be different because the name of a dummy argument is not a
             characteristic.


 9    The IMPORT statement specifies that the named entities from the host scoping unit are accessible in
10    the interface body by host association. An entity that is imported in this manner and is defined in the
11    host scoping unit shall be explicitly declared prior to the interface body. The name of an entity made
12    accessible by an IMPORT statement shall not appear in any of the contexts described in 16.4.1.3 that
13    cause the host entity of that name to be inaccessible.

14    Within an interface body, if an IMPORT statement with no import-name-list appears, each host entity
15    not named in an IMPORT statement also is made accessible by host association if its name does not
16    appear in any of the contexts described in 16.4.1.3 that cause the host entity of that name to be
17    inaccessible.

             NOTE 12.5

             An example of an interface block without a generic specification is:


             INTERFACE
                SUBROUTINE EXT1 (X, Y, Z)
                       REAL, DIMENSION (100, 100) :: X, Y, Z
                END SUBROUTINE EXT1
                SUBROUTINE EXT2 (X, Z)
                       REAL X
                       COMPLEX (KIND = 4) Z (2000)
                END SUBROUTINE EXT2
                FUNCTION EXT3 (P, Q)
                       LOGICAL EXT3
                       INTEGER P (1000)
                       LOGICAL Q (1000)
                END FUNCTION EXT3
             END INTERFACE


             This interface block specifies explicit interfaces for the three external procedures EXT1, EXT2,
             and EXT3. Invocations of these procedures may use argument keywords (12.4.1); for example:


             EXT3 (Q = P_MASK (N+1 : N+1000), P = ACTUAL_P)



             NOTE 12.6

             The IMPORT statement can be used to allow module procedures to have dummy arguments that
             are procedures with assumed-shape arguments of an opaque type. For example:





      256                                  WORKING DRAFT                                         SEP 2002


      SEP 2002                               WORKING DRAFT                                    J3/02-007R3



           NOTE 12.6 (cont.)

           MODULE M
             TYPE T
                PRIVATE       ! T is an opaque type
                ...
             END TYPE
           CONTAINS
             SUBROUTINE PROCESS(X,Y,RESULT,MONITOR)
                TYPE(T),INTENT(IN) :: X(:,:),Y(:,:)
                TYPE(T),INTENT(OUT) :: RESULT(:,:)
                INTERFACE
                  SUBROUTINE MONITOR(ITERATION_NUMBER,CURRENT_ESTIMATE)
                       IMPORT T
                       INTEGER,INTENT(IN) :: ITERATION_NUMBER
                       TYPE(T),INTENT(IN) :: CURRENT_ESTIMATE(:,:)
                  END SUBROUTINE
                END INTERFACE
                ...
             END SUBROUTINE
           END MODULE


           The MONITOR dummy procedure requires an explicit interface because it has an assumed-shape
           array argument, but TYPE(T) would not be available inside the interface body without the IM-
           PORT statement.


 1    A generic interface block specifies a generic interface for each of the procedures in the interface
 2    block. The PROCEDURE statement lists procedure pointers, external procedures, dummy procedures,
 3    or module procedures that have this generic interface. The characteristics of module procedures are
 4    not given in interface blocks, but are assumed from the module subprograms. The characteristics of a
 5    procedure pointer are defined by a procedure declaration statement (12.3.2.3). A generic interface is
 6    always explicit.

 7    Any procedure may be referenced via its specific interface if the specific interface is accessible. It also
 8    may be referenced via a generic interface. The generic-spec in an interface-stmt is a generic identifier
 9    for all the procedures in the interface block. The rules specifying how any two procedures with the same
10    generic identifier shall differ are given in 16.2.3. They ensure that any generic invocation applies to at
11    most one specific procedure.

12    A generic name specifies a single name to reference all of the procedure names in the interface block.
13    A generic name may be the same as any one of the procedure names in the interface block, or the same
14    as any accessible generic name.

15    A generic name may be the same as a derived-type name, in which case all of the procedures in the
16    interface block shall be functions.

           NOTE 12.7

           An example of a generic procedure interface is:


           INTERFACE SWITCH
              SUBROUTINE INT_SWITCH (X, Y)
                  INTEGER, INTENT (INOUT) :: X, Y
              END SUBROUTINE INT_SWITCH





      SEP 2002                                   WORKING DRAFT                                            257


      J3/02-007R3                                 WORKING DRAFT                                    SEP 2002



             NOTE 12.7 (cont.)

                SUBROUTINE REAL_SWITCH (X, Y)
                    REAL, INTENT (INOUT) :: X, Y
                END SUBROUTINE REAL_SWITCH
                SUBROUTINE COMPLEX_SWITCH (X, Y)
                    COMPLEX, INTENT (INOUT) :: X, Y
                END SUBROUTINE COMPLEX_SWITCH
             END INTERFACE SWITCH


             Any of these three subroutines (INT SWITCH, REAL SWITCH, COMPLEX SWITCH) may be
             referenced with the generic name SWITCH, as well as by its specific name. For example, a reference
             to INT SWITCH could take the form:


             CALL SWITCH (MAX_VAL, LOC_VAL) ! MAX_VAL and LOC_VAL are of type INTEGER



 1    An interface-stmt having a dtio-generic-spec is an interface for a user-defined derived-type input/output
 2    procedure (9.5.3.7)


 3    12.3.2.1.1     Defined operations

 4    If OPERATOR is specified in a generic specification, all of the procedures specified in the generic interface
 5    shall be functions that may be referenced as defined operations (7.1.3,7.1.8.7, 7.2, 12.4). In the case of
 6    functions of two arguments, infix binary operator notation is implied. In the case of functions of one
 7    argument, prefix operator notation is implied. OPERATOR shall not be specified for functions with no
 8    arguments or for functions with more than two arguments. The dummy arguments shall be nonoptional
 9    dummy data objects and shall be specified with INTENT (IN). The function result shall not have assumed

10    character length. If the operator is an intrinsic-operator (R310), the number of function arguments shall
11    be consistent with the intrinsic uses of that operator.

12    A defined operation is treated as a reference to the function. For a unary defined operation, the operand
13    corresponds to the function's dummy argument; for a binary operation, the left-hand operand corre-
14    sponds to the first dummy argument of the function and the right-hand operand corresponds to the
15    second dummy argument.

             NOTE 12.8

             An example of the use of the OPERATOR generic specification is:


             INTERFACE OPERATOR ( * )
                FUNCTION BOOLEAN_AND (B1, B2)
                    LOGICAL, INTENT (IN) :: B1 (:), B2 (SIZE (B1))
                    LOGICAL :: BOOLEAN_AND (SIZE (B1))
                END FUNCTION BOOLEAN_AND
             END INTERFACE OPERATOR ( * )


             This allows, for example


             SENSOR (1:N) * ACTION (1:N)


             as an alternative to the function call


             BOOLEAN_AND (SENSOR (1:N), ACTION (1:N))            ! SENSOR and ACTION are
                                                                 ! of type LOGICAL





      258                                   WORKING DRAFT                                          SEP 2002


      SEP 2002                              WORKING DRAFT                                      J3/02-007R3



 1    A given defined operator may, as with generic names, apply to more than one function, in which case
 2    it is generic in exact analogy to generic procedure names. For intrinsic operator symbols, the generic
 3    properties include the intrinsic operations they represent. Because both forms of each relational operator
 4    have the same interpretation (7.2), extending one form (such as <=) has the effect of defining both forms
 5    (<= and .LE.).

           NOTE 12.9

           In Fortran 90 and Fortran 95, it was not possible to define operators on pointers because pointer
           dummy arguments were disallowed from having an INTENT attribute. The restriction against
           INTENT for pointer dummy arguments is now lifted, so defined operators on pointers are now
           possible.

           However, the POINTER attribute cannot be used to resolve generic procedures (16.2.3), so it is
           not possible to define a generic operator that has one procedure for pointers and another procedure
           for nonpointers.


 6    12.3.2.1.2    Defined assignments

 7    If ASSIGNMENT ( = ) is specified in a generic specification, all the procedures in the generic interface
 8    shall be subroutines that may be referenced as defined assignments (7.4.1.4). Defined assignment may,
 9    as with generic names, apply to more than one subroutine, in which case it is generic in exact analogy
10    to generic procedure names. Each of these subroutines shall have exactly two dummy arguments. Each
11    argument shall be nonoptional. The first argument shall have INTENT (OUT) or INTENT (INOUT)
12    and the second argument shall have INTENT (IN). A defined assignment is treated as a reference to the
13    subroutine, with the left-hand side as the first argument and the right-hand side enclosed in parentheses
14    as the second argument. The ASSIGNMENT generic specification specifies that the assignment operation
15    is extended or redefined.

           NOTE 12.10

           An example of the use of the ASSIGNMENT generic specification is:


           INTERFACE ASSIGNMENT ( = )


              SUBROUTINE LOGICAL_TO_NUMERIC (N, B)
                    INTEGER, INTENT (OUT) :: N
                    LOGICAL, INTENT (IN)     :: B
              END SUBROUTINE LOGICAL_TO_NUMERIC
              SUBROUTINE CHAR_TO_STRING (S, C)
                    USE STRING_MODULE           ! Contains definition of type STRING
                    TYPE (STRING), INTENT (OUT) :: S         ! A variable-length string
                    CHARACTER (*), INTENT (IN) ::       C
              END SUBROUTINE CHAR_TO_STRING
           END INTERFACE ASSIGNMENT ( = )


           Example assignments are:


           KOUNT = SENSOR (J)        ! CALL LOGICAL_TO_NUMERIC (KOUNT, (SENSOR (J)))
           NOTE     = '89AB'         ! CALL CHAR_TO_STRING (NOTE, ('89AB'))



16    12.3.2.1.3    User-defined derived-type input/output procedure interfaces

17    All of the procedures specified in an interface block for a user-defined derived-type input/output proce-
18    dure shall be subroutines that have interfaces as described in 9.5.3.7.2.




      SEP 2002                                    WORKING DRAFT                                            259


      J3/02-007R3                                   WORKING DRAFT                                        SEP 2002



 1    12.3.2.2         EXTERNAL statement

 2    An EXTERNAL statement specifies the EXTERNAL attribute (5.1.2.6) for a list of names.

 3    R1210 external-stmt                     is    EXTERNAL [ :: ] external-name-list

 4    Each external-name shall be the name of an external procedure, a dummy argument, a procedure
 5    pointer, an abstract interface, or a block data program unit. In an external subprogram, an EXTERNAL
 6    statement shall not specify the name of a procedure defined by the subprogram.

 7    The appearance of the name of a block data program unit in an EXTERNAL statement confirms that
 8    the block data program unit is a part of the program.

             NOTE 12.11

             For explanatory information on potential portability problems with external procedures, see section
             C.9.1.


             NOTE 12.12

             An example of an EXTERNAL statement is:


                  EXTERNAL FOCUS



 9    12.3.2.3         Procedure declaration statement

10    A procedure declaration statement declares procedure pointers, dummy procedures, and external pro-
11    cedures. It specifies the EXTERNAL attribute (5.1.2.6) for all procedure entities in the proc-decl -list.

12    R1211 procedure-declaration-stmt        is    PROCEDURE ( [ proc-interface ] )
13                                                    [ [ , proc-attr-spec ] ... :: ] proc-decl -list
14    R1212 proc-interface                    is    interface-name
15                                            or declaration-type-spec
16    R1213 proc-attr-spec                    is    access-spec
17                                            or proc-language-binding-spec
18                                            or INTENT ( intent-spec )
19                                            or OPTIONAL
20                                            or POINTER
21                                            or SAVE
22    R1214 proc-decl                         is    procedure-entity-name[ => null-init ]
23    R1215 interface-name                    is    name

24    C1212     (R1215) The name shall be the name of an abstract interface or of a procedure that has an
25              explicit interface. If name is declared by a procedure-declaration-stmt it shall be previously
26              declared. If name denotes an intrinsic procedure it shall be one that is listed in 13.6 and not
27              marked with a bullet (�).

28    C1213     (R1215) The name shall not be the same as a keyword that specifies an intrinsic type.

29    C1214     If a procedure entity has the INTENT attribute or SAVE attribute, it shall also have the
30              POINTER attribute.

31    C1215     (R1211) If a proc-interface describes an elemental procedure, each procedure-entity-name shall
32              specify an external procedure.

33    C1216     (R1214) If => appears in proc-decl , the procedure entity shall have the POINTER attribute.

34    C1217     (R1211) If proc-language-binding-spec with a NAME= is specified, then proc-decl -list shall con-



      260                                    WORKING DRAFT                                               SEP 2002


      SEP 2002                               WORKING DRAFT                                        J3/02-007R3



 1             tain exactly one proc-decl , which shall neither have the POINTER attribute nor be a dummy
 2             procedure.

 3    C1218    (R1211) If proc-language-binding-spec is specified, the proc-interface shall appear, it shall be an
 4             interface-name, and interface-name shall be declared with a proc-language-binding-spec.

 5    If proc-interface appears and consists of interface-name, it specifies an explicit specific interface (12.3.2.1)
 6    for the declared procedures or procedure pointers. The abstract interface (12.3) is that specified by the
 7    interface named by interface-name.

 8    If proc-interface appears and consists of declaration-type-spec, it specifies that the declared procedures
 9    or procedure pointers are functions having implicit interfaces and the specified result type. If a type is
10    specified for an external function, its function definition (12.5.2.1) shall specify the same result type and
11    type parameters.

12    If proc-interface does not appear, the procedure declaration statement does not specify whether the
13    declared procedures or procedure pointers are subroutines or functions.

           NOTE 12.13

           In contrast to the EXTERNAL statement, it is not possible to use the PROCEDURE statement
           to identify a BLOCK DATA subprogram.


           NOTE 12.14


           ABSTRACT INTERFACE
               FUNCTION REAL_FUNC (X)
                REAL, INTENT (IN) :: X
                REAL :: REAL_FUNC
               END FUNCTION REAL_FUNC
           END INTERFACE


           INTERFACE
               SUBROUTINE SUB (X)
                REAL, INTENT (IN) :: X
               END SUBROUTINE SUB
           END INTERFACE


           !-- Some external or dummy procedures with explicit interface.
           PROCEDURE (REAL_FUNC) :: BESSEL, GAMMA
           PROCEDURE (SUB) :: PRINT_REAL
           !-- Some procedure pointers with explicit interface,
           !-- one initialized to NULL().
           PROCEDURE (REAL_FUNC), POINTER :: P, R => NULL()
           PROCEDURE (REAL_FUNC), POINTER :: PTR_TO_GAMMA
           !-- A derived type with a procedure pointer component ...
           TYPE STRUCT_TYPE
                PROCEDURE (REAL_FUNC), POINTER :: COMPONENT
           END TYPE STRUCT_TYPE
           !-- ... and a variable of that type.
           TYPE(STRUCT_TYPE) :: STRUCT
           !-- An external or dummy function with implicit interface
           PROCEDURE (REAL) :: PSI





      SEP 2002                                     WORKING DRAFT                                               261


      J3/02-007R3                                        WORKING DRAFT                                        SEP 2002



              NOTE 12.15

              A procedure pointer is not interoperable with a C pointer. However, it is possible to pass a
              C pointer to a procedure from Fortran to C through the use of the C LOC function from the
              ISO C BINDING module (15.1.2). For such application, the argument of the C LOC function
              would have to be a procedure with a BIND attribute.


 1    12.3.2.4      INTRINSIC statement

 2    An INTRINSIC statement specifies a list of names that have the INTRINSIC attribute (5.1.2.8).

 3    R1216 intrinsic-stmt                         is    INTRINSIC [ :: ] intrinsic-procedure-name-list

 4    C1219      (R1216) Each intrinsic-procedure-name shall be the name of an intrinsic procedure.

              NOTE 12.16

              A name shall not be explicitly specified to have both the EXTERNAL and INTRINSIC attributes
              in the same scoping unit.


 5    12.3.2.5      Implicit interface specification

 6    In a scoping unit where the interface of a function is implicit, the type and type parameters of the
 7    function result are specified by an implicit or explicit type specification of the function name. The type,
 8    type parameters, and shape of dummy arguments of a procedure referenced from a scoping unit where
 9    the interface of the procedure is implicit shall be such that the actual arguments are consistent with the
10    characteristics of the dummy arguments.


11    12.4         Procedure reference

12    The form of a procedure reference is dependent on the interface of the procedure or procedure pointer,
13    but is independent of the means by which the procedure is defined. The forms of procedure references
14    are:

15    R1217 function-reference                     is    procedure-designator ( [ actual-arg-spec-list ] )

16    C1220      (R1217) The procedure-designator shall designate a function.

17    C1221      (R1217) The actual-arg-spec-list shall not contain an alt-return-spec.


18    R1218 call-stmt                              is    CALL procedure-designator [ ( [ actual-arg-spec-list ] ) ]

19    C1222      (R1218) The procedure-designator shall designate a subroutine.

20    R1219 procedure-designator                   is    procedure-name
21                                                 or data-ref % procedure-component-name
22                                                 or data-ref % binding-name

23    C1223      (R1219) A procedure-name shall be the name of a procedure or procedure pointer.

24    C1224      (R1219) A procedure-component-name shall be the name of a procedure pointer component of
25               the declared type of data-ref .

26    C1225      (R1219) A binding-name shall be the name of a procedure binding (4.5.1.5) of the declared type
27               of data-ref .

28    For type-bound procedure references, the declared binding is the binding in the declared type of the




      262                                        WORKING DRAFT                                                SEP 2002


      SEP 2002                                 WORKING DRAFT                                            J3/02-007R3



 1    data-ref whose name is binding-name, and the dynamic binding is the binding in the dynamic type
 2    of the data-ref with that name.

 3    If the declared binding is nongeneric, the procedure identified by the dynamic binding is referenced.

 4    If the declared binding is generic, then

 5          (1)    If the reference is consistent with one of the specific interfaces in the declared binding, the
 6                 corresponding specific interface in the dynamic binding is selected.

 7          (2)    Otherwise, the reference shall be consistent with an elemental reference to one of the spe-
 8                 cific interfaces in the declared binding; the corresponding specific interface in the dynamic
 9                 binding is selected.

10    The reference is to the procedure identified by that interface.

11    A function may also be referenced as a defined operation (12.3.2.1.1). A subroutine may also be referenced
12    as a defined assignment (12.3.2.1.2).

13    R1220 actual-arg-spec                    is    [ keyword = ] actual-arg
14    R1221 actual-arg                         is    expr
15                                             or variable
16                                             or procedure-name
17                                             or alt-return-spec
18    R1222 alt-return-spec                    is    * label


19    C1226    (R1220) The keyword = shall not appear if the interface of the procedure is implicit in the
20             scoping unit.

21    C1227    (R1220) The keyword = may be omitted from an actual-arg-spec only if the keyword = has been
22             omitted from each preceding actual-arg-spec in the argument list.

23    C1228    (R1220) Each keyword shall be the name of a dummy argument in the explicit interface of the
24             procedure.

25    C1229    (R1221) A nonintrinsic elemental procedure shall not be used as an actual argument.

26    C1230    (R1221) A procedure-name shall be the name of an external procedure, a dummy procedure, a
27             module procedure, a procedure pointer, or a specific intrinsic function that is listed in 13.6 and
28             not marked with a bullet(�).

           NOTE 12.17

           This standard does not allow internal procedures to be used as actual arguments, in part to simplify
           the problem of ensuring that internal procedures with recursive hosts access entities from the
           correct instance (12.5.2.3) of the host. If, as an extension, a processor allows internal procedures to
           be used as actual arguments, the correct instance in this case is the instance in which the procedure
           is supplied as an actual argument, even if the corresponding dummy argument is eventually invoked
           from a different instance.


29    C1231    (R1221) In a reference to a pure procedure, a procedure-name actual-arg shall be the name of a
30             pure procedure (12.6).

           NOTE 12.18

           This constraint ensures that the purity of a procedure cannot be undermined by allowing it to call
           a nonpure procedure.


31    C1232    (R1222) The label used in the alt-return-spec shall be the statement label of a branch target statement that




      SEP 2002                                         WORKING DRAFT                                                 263


      J3/02-007R3                                      WORKING DRAFT                                   SEP 2002



 1              appears in the same scoping unit as the call-stmt .


             NOTE 12.19

             Successive commas shall not be used to omit optional arguments.


             NOTE 12.20

             Examples of procedure reference using procedure pointers:


             P => BESSEL
             WRITE (*, *) P(2.5)              !-- BESSEL(2.5)


             S => PRINT_REAL
             CALL S(3.14)



 2    12.4.1       Actual arguments, dummy arguments, and argument association

 3    In either a subroutine reference or a function reference, the actual argument list identifies the corre-
 4    spondence between the actual arguments supplied and the dummy arguments of the procedure. This
 5    correspondence may be established either by keyword or by position. If an argument keyword appears,
 6    the actual argument is associated with the dummy argument whose name is the same as the argument
 7    keyword (using the dummy argument names from the interface accessible in the scoping unit containing
 8    the procedure reference). In the absence of an argument keyword, an actual argument is associated
 9    with the dummy argument occupying the corresponding position in the reduced dummy argument list;
10    that is, the first actual argument is associated with the first dummy argument in the reduced list, the
11    second actual argument is associated with the second dummy argument in the reduced list, etc. The
12    reduced dummy argument list is either the full dummy argument list or, if there is a passed-object
13    dummy argument (4.5.1.6), the dummy argument list with the passed object dummy argument omitted.
14    Exactly one actual argument shall be associated with each nonoptional dummy argument. At most one
15    actual argument may be associated with each optional dummy argument. Each actual argument shall
16    be associated with a dummy argument.

             NOTE 12.21

             For example, the procedure defined by


             SUBROUTINE SOLVE (FUNCT, SOLUTION, METHOD, STRATEGY, PRINT)
                INTERFACE
                    FUNCTION FUNCT (X)
                        REAL FUNCT, X
                    END FUNCTION FUNCT
                END INTERFACE
                REAL SOLUTION
                INTEGER, OPTIONAL :: METHOD, STRATEGY, PRINT
                ...


             may be invoked with


             CALL SOLVE (FUN, SOL, PRINT = 6)


             provided its interface is explicit; if the interface is specified by an interface block, the name of the
             last argument shall be PRINT.





      264                                       WORKING DRAFT                                          SEP 2002


      SEP 2002                             WORKING DRAFT                                      J3/02-007R3



 1    12.4.1.1    The passed-object dummy argument and argument association

 2    In a reference to a type-bound procedure that has a passed-object dummy argument (4.5.1.6), the data-
 3    ref of the function-reference or call-stmt is associated, as an actual argument, with the passed-object
 4    dummy argument.


 5    12.4.1.2    Actual arguments associated with dummy data objects

 6    A dummy argument shall be type compatible (5.1.1.8) with the associated actual argument unless the
 7    dummy argument has INTENT(OUT) and is allocatable or a pointer. If the dummy argument is an
 8    allocatable or pointer that does not have INTENT(IN), the associated actual argument shall be type
 9    compatible with the dummy argument. If the dummy argument is allocatable or a pointer, the associated
10    actual argument shall be polymorphic if and only if the dummy argument is polymorphic.

11    The type parameter values of the actual argument shall agree with the corresponding ones of the dummy
12    argument that are not assumed or deferred, except for the case of the character length parameter of
13    an actual argument of type default character associated with a dummy argument that is not assumed
14    shape.

15    If a scalar dummy argument is of type default character, the length len of the dummy argument shall
16    be less than or equal to the length of the actual argument. The dummy argument becomes associated
17    with the leftmost len characters of the actual argument. If an array dummy argument is of type default
18    character and is not assumed shape, it becomes associated with the leftmost characters of the actual
19    argument element sequence (12.4.1.5) and it shall not extend beyond the end of that sequence.

20    The values of assumed type parameters of a dummy argument are assumed from the corresponding type
21    parameters of the associated actual argument.

22    An actual argument associated with a dummy argument that is allocatable or a pointer shall have
23    deferred the same type parameters as the dummy argument.

24    If the dummy argument is a pointer, the actual argument shall be a pointer and the nondeferred type
25    parameters and ranks shall agree. If a dummy argument is allocatable, the actual argument shall be
26    allocatable and the nondeferred type parameters and ranks shall agree. It is permissible for the actual
27    argument to have an allocation status of unallocated.

28    At the invocation of the procedure, the pointer association status of an actual argument associated with
29    a pointer dummy argument becomes undefined if the dummy argument has INTENT(OUT).

30    Except in references to intrinsic inquiry functions, if the dummy argument is not a pointer and the
31    corresponding actual argument is a pointer, the actual argument shall be associated with a target and
32    the dummy argument becomes argument associated with that target.

33    Except in references to intrinsic inquiry functions, if the dummy argument is not allocatable and the
34    actual argument is allocatable, the actual argument shall be allocated.

35    If the dummy argument has the VALUE attribute it becomes associated with a definable anonymous
36    data object whose initial value is that of the actual argument. Subsequent changes to the value or
37    definition status of the dummy argument do not affect the actual argument.

          NOTE 12.22

          Fortran argument association is usually similar to call by reference and call by value-result. If the
          VALUE attribute is specified, the effect is as if the actual argument is assigned to a temporary,
          and the temporary is then argument associated with the dummy argument. The actual mechanism
          by which this happens is determined by the processor.





      SEP 2002                                   WORKING DRAFT                                             265


      J3/02-007R3                                WORKING DRAFT                                      SEP 2002



 1    If the dummy argument does not have the TARGET or POINTER attribute, any pointers associated
 2    with the actual argument do not become associated with the corresponding dummy argument on in-
 3    vocation of the procedure. If such a dummy argument is associated with an actual argument that is
 4    a dummy argument with the TARGET attribute, whether any pointers associated with the original
 5    actual argument become associated with the dummy argument with the TARGET attribute is processor
 6    dependent.

 7    If the dummy argument has the TARGET attribute, does not have the VALUE attribute, and is either
 8    a scalar or an assumed-shape array, and the corresponding actual argument has the TARGET attribute
 9    but is not an array section with a vector subscript then

10            (1)    Any pointers associated with the actual argument become associated with the corresponding
11                   dummy argument on invocation of the procedure and

12            (2)    When execution of the procedure completes, any pointers that do not become undefined
13                   (16.4.2.1.3) and are associated with the dummy argument remain associated with the actual
14                   argument.

15    If the dummy argument has the TARGET attribute and is an explicit-shape array or is an assumed-size
16    array, and the corresponding actual argument has the TARGET attribute but is not an array section
17    with a vector subscript then

18            (1)    On invocation of the procedure, whether any pointers associated with the actual argument
19                   become associated with the corresponding dummy argument is processor dependent and

20            (2)    When execution of the procedure completes, the pointer association status of any pointer
21                   that is pointer associated with the dummy argument is processor dependent.

22    If the dummy argument has the TARGET attribute and the corresponding actual argument does not
23    have the TARGET attribute or is an array section with a vector subscript, any pointers associated with
24    the dummy argument become undefined when execution of the procedure completes.

25    If the dummy argument has the TARGET attribute and the VALUE attribute, any pointers associated
26    with the dummy argument become undefined when execution of the procedure completes.

27    If the actual argument is scalar, the corresponding dummy argument shall be scalar unless the actual
28    argument is of type default character, of type character with the C character kind (15.1), or is an element
29    or substring of an element of an array that is not an assumed-shape or pointer array. If the procedure
30    is nonelemental and is referenced by a generic name or as a defined operator or defined assignment, the
31    ranks of the actual arguments and corresponding dummy arguments shall agree.

32    If a dummy argument is an assumed-shape array, the rank of the actual argument shall be the same as
33    the rank of the dummy argument; the actual argument shall not be an assumed-size array (including an
34    array element designator or an array element substring designator).

35    Except when a procedure reference is elemental (12.7), each element of an array actual argument or of
36    a sequence in a sequence association (12.4.1.5) is associated with the element of the dummy array that
37    has the same position in array element order (6.2.2.2).

             NOTE 12.23

             For type default character sequence associations, the interpretation of element is provided in
             12.4.1.5.


38    A scalar dummy argument of a nonelemental procedure may be associated only with a scalar actual
39    argument.

40    If a nonpointer dummy argument has INTENT (OUT) or INTENT (INOUT), the actual argument shall
41    be definable. If a dummy argument has INTENT (OUT), the corresponding actual argument becomes
42    undefined at the time the association is established. If the dummy argument is not polymorphic and the



      266                                  WORKING DRAFT                                            SEP 2002


      SEP 2002                                WORKING DRAFT                                    J3/02-007R3



 1    type of the actual argument is an extension type of the type of the dummy argument, only the part of
 2    the actual argument that is of the same type as the dummy argument becomes undefined.

 3    If the actual argument is an array section having a vector subscript, the dummy argument is not defin-
 4    able and shall not have the INTENT (OUT), INTENT (INOUT), VOLATILE, or ASYNCHRONOUS
 5    attributes.

           NOTE 12.24

           Argument intent specifications serve several purposes. See Note 5.16.


           NOTE 12.25

           For more explanatory information on argument association and evaluation, see section C.9.4. For
           more explanatory information on pointers and targets as dummy arguments, see section C.9.5.


 6    C1233    (R1221) If an actual argument is an array section or an assumed-shape array, and the corre-
 7             sponding dummy argument has either the VOLATILE or ASYNCHRONOUS attribute, that
 8             dummy argument shall be an assumed-shape array.

 9    C1234    (R1221) If an actual argument is a pointer array, and the corresponding dummy argument
10             has either the VOLATILE or ASYNCHRONOUS attribute, that dummy argument shall be an
11             assumed-shape array or a pointer array.

           NOTE 12.26

           The constraints on actual arguments that correspond to a dummy argument with either the ASYN-
           CHRONOUS or VOLATILE attribute are designed to avoid forcing a processor to use the so-called
           copy-in/copy-out argument passing mechanism. Making a copy of actual arguments whose values
           are likely to change due to an asynchronous I/O operation completing or in some unpredictable
           manner will cause those new values to be lost when a called procedure returns and the copy-out
           overwrites the actual argument.


12    12.4.1.3       Actual arguments associated with dummy procedure entities

13    If a dummy argument is a procedure pointer, the associated actual argument shall be a procedure pointer,
14    a reference to a function that returns a procedure pointer, or a reference to the NULL intrinsic function.

15    If a dummy argument is a dummy procedure, the associated actual argument shall be the specific name
16    of an external, module, dummy, or intrinsic procedure, a procedure pointer, or a reference to a function
17    that returns a procedure pointer. The only intrinsic procedures permitted are those listed in 13.6 and
18    not marked with a bullet (�). If the specific name is also a generic name, only the specific procedure is
19    associated with the dummy argument.

20    If an external procedure name or a dummy procedure name is used as an actual argument, its interface
21    shall be explicit or it shall be explicitly declared to have the EXTERNAL attribute.

22    If the interface of the dummy argument is explicit, the characteristics listed in 12.2 shall be the same
23    for the associated actual argument and the corresponding dummy argument, except that a pure actual
24    argument may be associated with a dummy argument that is not pure and an elemental intrinsic actual
25    procedure may be associated with a dummy procedure (which is prohibited from being elemental).

26    If the interface of the dummy argument is implicit and either the name of the dummy argument is
27    explicitly typed or it is referenced as a function, the dummy argument shall not be referenced as a
28    subroutine and the actual argument shall be a function, function procedure pointer, or dummy procedure.

29    If the interface of the dummy argument is implicit and a reference to it appears as a subroutine reference,




      SEP 2002                                    WORKING DRAFT                                             267


      J3/02-007R3                                      WORKING DRAFT                                              SEP 2002



 1    the actual argument shall be a subroutine, subroutine procedure pointer, or dummy procedure.


 2    12.4.1.4       Actual arguments associated with alternate return indicators


 3    If a dummy argument is an asterisk (12.5.2.2), the associated actual argument shall be an alternate return specifier (12.4).


 4    12.4.1.5       Sequence association

 5    An actual argument represents an element sequence if it is an array expression, an array element
 6    designator, a scalar of type default character, or a scalar of type character with the C character kind
 7    (15.1). If the actual argument is an array expression, the element sequence consists of the elements
 8    in array element order. If the actual argument is an array element designator, the element sequence
 9    consists of that array element and each element that follows it in array element order.

10    If the actual argument is of type default character or of type character with the C character kind, and is
11    an array expression, array element, or array element substring designator, the element sequence consists
12    of the storage units beginning with the first storage unit of the actual argument and continuing to the
13    end of the array. The storage units of an array element substring designator are viewed as array elements
14    consisting of consecutive groups of storage units having the character length of the dummy array.

15    If the actual argument is of type default character or of type character with the C character kind, and
16    is a scalar that is not an array element or array element substring designator, the element sequence
17    consists of the storage units of the actual argument.

             NOTE 12.27

             Some of the elements in the element sequence may consist of storage units from different elements
             of the original array.


18    An actual argument that represents an element sequence and corresponds to a dummy argument that is
19    an array is sequence associated with the dummy argument if the dummy argument is an explicit-shape
20    or assumed-size array. The rank and shape of the actual argument need not agree with the rank and
21    shape of the dummy argument, but the number of elements in the dummy argument shall not exceed
22    the number of elements in the element sequence of the actual argument. If the dummy argument is
23    assumed-size, the number of elements in the dummy argument is exactly the number of elements in the
24    element sequence.


25    12.4.1.6       Restrictions on dummy arguments not present

26    A dummy argument or an entity that is host associated with a dummy argument is not present if the
27    dummy argument

28            (1)     is not associated with an actual argument, or

29            (2)     is associated with an actual argument that is not present.

30    Otherwise, it is present. A dummy argument that is not optional shall be present. An optional dummy
31    argument that is not present is subject to the following restrictions:

32            (1)     If it is a data object, it shall not be referenced or be defined. If it is of a type for which
33                    default initialization is specified for some component, the initialization has no effect.

34            (2)     It shall not be used as the data-target or proc-target of a pointer assignment.

35            (3)     If it is a procedure or procedure pointer, it shall not be invoked.

36            (4)     It shall not be supplied as an actual argument corresponding to a nonoptional dummy
37                    argument other than as the argument of the PRESENT intrinsic function or as an argument
38                    of a function reference that meets the requirements of (6) or (8) in 7.1.7.




      268                                      WORKING DRAFT                                                      SEP 2002


      SEP 2002                                      WORKING DRAFT                                         J3/02-007R3



 1          (5)          A designator with it as the base object and with at least one subobject selector shall not
 2                       be supplied as an actual argument.

 3          (6)          If it is an array, it shall not be supplied as an actual argument to an elemental procedure
 4                       unless an array of the same rank is supplied as an actual argument corresponding to a
 5                       nonoptional dummy argument of that elemental procedure.

 6          (7)          If it is a pointer, it shall not be allocated, deallocated, nullified, pointer-assigned, or supplied
 7                       as an actual argument corresponding to an optional nonpointer dummy argument.

 8          (8)          If it is allocatable, it shall not be allocated, deallocated, or supplied as an actual argument
 9                       corresponding to an optional nonallocatable dummy argument.

10          (9)          If it has nonkind type parameters, they shall not be the subject of an inquiry.

11          (10)         It shall not be used as the selector in a SELECT TYPE or ASSOCIATE construct.

12    Except as noted in the list above, it may be supplied as an actual argument corresponding to an optional
13    dummy argument, which is then also considered not to be associated with an actual argument.


14    12.4.1.7      Restrictions on entities associated with dummy arguments

15    While an entity is associated with a dummy argument, the following restrictions hold:

16          (1)          Action that affects the allocation status of the entity or a subobject thereof shall be taken
17                       through the dummy argument. Action that affects the value of the entity or any subobject
18                       of it shall be taken only through the dummy argument unless

19                       (a)    the dummy argument has the POINTER attribute or

20                       (b)    the dummy argument has the TARGET attribute, the dummy argument does not
21                              have INTENT (IN), the dummy argument is a scalar object or an assumed-shape
22                              array, and the actual argument is a target other than an array section with a vector
23                              subscript.

          NOTE 12.28

          In


          SUBROUTINE OUTER
                  REAL, POINTER :: A (:)
                  ...
                  ALLOCATE (A (1:N))
                  ...
                  CALL INNER (A)
                  ...
          CONTAINS
                  SUBROUTINE INNER (B)
                     REAL :: B (:)
                     ...
                  END SUBROUTINE INNER
                  SUBROUTINE SET (C, D)
                     REAL, INTENT (OUT) :: C
                     REAL, INTENT (IN) :: D
                     C = D
                  END SUBROUTINE SET
          END SUBROUTINE OUTER


          an assignment statement such as





      SEP 2002                                            WORKING DRAFT                                                269


J3/02-007R3                                 WORKING DRAFT                                     SEP 2002



       NOTE 12.28 (cont.)

       A (1) = 1.0


       would not be permitted during the execution of INNER because this would be changing A without
       using B, but statements such as


       B (1) = 1.0


       or


       CALL SET (B (1), 1.0)


       would be allowed. Similarly,


       DEALLOCATE (A)


       would not be allowed because this affects the allocation of B without using B. In this case,


       DEALLOCATE (B)


       also would not be permitted. If B were declared with the POINTER attribute, either of the
       statements


       DEALLOCATE (A)


       and


       DEALLOCATE (B)


       would be permitted, but not both.


       NOTE 12.29

       If there is a partial or complete overlap between the actual arguments associated with two different
       dummy arguments of the same procedure and the dummy arguments have neither the POINTER
       nor TARGET attribute, the overlapped portions shall not be defined, redefined, or become unde-
       fined during the execution of the procedure. For example, in


       CALL SUB (A (1:5), A (3:9))


       A (3:5) shall not be defined, redefined, or become undefined through the first dummy argument
       because it is part of the argument associated with the second dummy argument and shall not be
       defined, redefined, or become undefined through the second dummy argument because it is part of
       the argument associated with the first dummy argument. A (1:2) remains definable through the
       first dummy argument and A (6:9) remains definable through the second dummy argument.


       NOTE 12.30

       This restriction applies equally to pointer targets. In


       REAL, DIMENSION (10), TARGET :: A
       REAL, DIMENSION (:), POINTER :: B, C





270                                    WORKING DRAFT                                          SEP 2002


      SEP 2002                               WORKING DRAFT                                    J3/02-007R3



         NOTE 12.30 (cont.)

         B => A (1:5)
         C => A (3:9)
         CALL SUB (B, C)         ! The dummy arguments of SUB are neither pointers nor targets.


         B (3:5) cannot be defined because it is part of the argument associated with the second dummy
         argument. C (1:3) cannot be defined because it is part of the argument associated with the first
         dummy argument. A (1:2) [which is B (1:2)] remains definable through the first dummy argument
         and A (6:9) [which is C (4:7)] remains definable through the second dummy argument.


         NOTE 12.31

         Since a nonpointer dummy argument declared with INTENT(IN) shall not be used to change
         the associated actual argument, the associated actual argument remains constant throughout the
         execution of the procedure.


 1        (2)     If the allocation status of the entity or a subobject thereof is affected through the dummy
 2                argument, then at any time during the execution of the procedure, either before or after
 3                the allocation or deallocation, it may be referenced only through the dummy argument. If
 4                the value the entity or any subobject of it is affected through the dummy argument, then
 5                at any time during the execution of the procedure, either before or after the definition, it
 6                may be referenced only through that dummy argument unless

 7                (a)      the dummy argument has the POINTER attribute or

 8                (b)      the dummy argument has the TARGET attribute, the dummy argument does not
 9                         have INTENT (IN), the dummy argument is a scalar object or an assumed-shape
10                         array, and the actual argument is a target other than an array section with a vector
11                         subscript.

         NOTE 12.32

         In


         MODULE DATA
               REAL :: W, X, Y, Z
         END MODULE DATA


         PROGRAM MAIN
               USE DATA
                 ...
               CALL INIT (X)
                 ...
         END PROGRAM MAIN
         SUBROUTINE INIT (V)
               USE DATA
                 ...
               READ (*, *) V
                 ...
         END SUBROUTINE INIT


         variable X shall not be directly referenced at any time during the execution of INIT because it is
         being defined through the dummy argument V. X may be (indirectly) referenced through V. W,
         Y, and Z may be directly referenced. X may, of course, be directly referenced once execution of
         INIT is complete.





      SEP 2002                                     WORKING DRAFT                                          271


      J3/02-007R3                                   WORKING DRAFT                                        SEP 2002



             NOTE 12.33

             The restrictions on entities associated with dummy arguments are intended to facilitate a variety
             of optimizations in the translation of the subprogram, including implementations of argument
             association in which the value of an actual argument that is neither a pointer nor a target is
             maintained in a register or in local storage.



 1    12.4.2         Function reference

 2    A function is invoked during expression evaluation by a function-reference or by a defined operation
 3    (7.1.3). When it is invoked, all actual argument expressions are evaluated, then the arguments are
 4    associated, and then the function is executed. When execution of the function is complete, the value
 5    of the function result is available for use in the expression that caused the function to be invoked. The
 6    characteristics of the function result (12.2.2) are determined by the interface of the function. A reference
 7    to an elemental function (12.7) is an elemental reference if one or more actual arguments are arrays and
 8    all array arguments have the same shape.


 9    12.4.3         Subroutine reference

10    A subroutine is invoked by execution of a CALL statement or defined assignment statement (7.4.1.4).
11    When a subroutine is invoked, all actual argument expressions are evaluated, then the arguments are
12    associated, and then the subroutine is executed. When the actions specified by the subroutine are
13    completed, execution of the CALL statement or defined assignment statement is also completed. If a

14    CALL statement includes one or more alternate return specifiers among its arguments, control may be transferred to

15    one of the statements indicated, depending on the action specified by the subroutine. A reference to an elemental
16    subroutine (12.7) is an elemental reference if there is at least one actual argument corresponding to an
17    INTENT(OUT) or INTENT(INOUT) dummy argument, all such actual arguments are arrays, and all
18    actual arguments are conformable.


19    12.4.4         Resolving procedure references

20    The rules for interpreting a procedure reference depend on whether the procedure name in the reference
21    is established by the available declarations and specifications to be generic in the scoping unit containing
22    the reference, is established to be specific only in the scoping unit containing the reference, or is not
23    established.

24            (1)     A procedure name is established to be generic in a scoping unit

25                    (a)    if that scoping unit contains an interface block with that name;

26                    (b)    if that scoping unit contains an INTRINSIC attribute specification for that name and
27                           it is the name of a generic intrinsic procedure;

28                    (c)    if that scoping unit contains a USE statement that makes that procedure name ac-
29                           cessible and the corresponding name in the module is established to be generic; or

30                    (d)    if that scoping unit contains no declarations of that name, that scoping unit has a
31                           host scoping unit, and that name is established to be generic in the host scoping unit.

32            (2)     A procedure name is established to be specific only in a scoping unit if it is established to
33                    be specific and not established to be generic. It is established to be specific

34                    (a)    if that scoping unit contains a module subprogram, internal subprogram, or statement

35                           function that defines a procedure with that name;

36                    (b)    if that scoping unit contains an INTRINSIC attribute specification for that name and
37                           if it is the name of a specific intrinsic procedure;

38                    (c)    if that scoping unit contains an explicit EXTERNAL attribute specification (5.1.2.6)
39                           for that name;




      272                                      WORKING DRAFT                                             SEP 2002


      SEP 2002                                 WORKING DRAFT                                      J3/02-007R3



 1                 (d)      if that scoping unit contains a USE statement that makes that procedure name ac-
 2                          cessible and the corresponding name in the module is established to be specific; or

 3                 (e)      if that scoping unit contains no declarations of that name, that scoping unit has a
 4                          host scoping unit, and that name is established to be specific in the host scoping unit.

 5         (3)     A procedure name is not established in a scoping unit if it is neither established to be generic
 6                 nor established to be specific.


 7    12.4.4.1    Resolving procedure references to names established to be generic
 8         (1)     If the reference is consistent with a nonelemental reference to one of the specific interfaces of
 9                 a generic interface that has that name and either is in the scoping unit in which the reference
10                 appears or is made accessible by a USE statement in the scoping unit, the reference is to
11                 the specific procedure in the interface block that provides that interface. The rules in 16.2.3
12                 ensure that there can be at most one such specific procedure.

13         (2)     If (1) does not apply, if the reference is consistent with an elemental reference to one of the
14                 specific interfaces of a generic interface that has that name and either is in the scoping unit
15                 in which the reference appears or is made accessible by a USE statement in the scoping unit,
16                 the reference is to the specific elemental procedure in the interface block that provides that
17                 interface. The rules in 16.2.3 ensure that there can be at most one such specific elemental
18                 procedure.

          NOTE 12.34

          These rules allow particular instances of a generic function to be used for particular array ranks
          and a general elemental version to be used for other ranks. Given an interface block such as:


          INTERFACE RANF
                  ELEMENTAL FUNCTION SCALAR_RANF(X)
                  REAL X
                  END FUNCTION SCALAR_RANF
                  FUNCTION VECTOR_RANDOM(X)
                  REAL X(:)
                  REAL VECTOR_RANDOM(SIZE(X))
                  END FUNCTION VECTOR_RANDOM
          END INTERFACE RANF


          and a declaration such as:


          REAL A(10,10), AA(10,10)


          then the statement


          A = RANF(AA)


          is an elemental reference to SCALAR RANF. The statement


          A = RANF(AA(6:10,2))


          is a nonelemental reference to VECTOR RANDOM.

19         (3)     If (1) and (2) do not apply, if the scoping unit contains either an INTRINSIC attribute
20                 specification for that name or a USE statement that makes that name accessible from a
21                 module in which the corresponding name is specified to have the INTRINSIC attribute, and
22                 if the reference is consistent with the interface of that intrinsic procedure, the reference is
23                 to that intrinsic procedure.




      SEP 2002                                       WORKING DRAFT                                            273


      J3/02-007R3                                  WORKING DRAFT                                       SEP 2002



             NOTE 12.35

             In the USE statement case, it is possible, because of the renaming facility, for the name in the
             reference to be different from the name of the intrinsic procedure.

 1            (4)     If (1), (2), and (3) do not apply, if the scoping unit has a host scoping unit, if the name
 2                    is established to be generic in that host scoping unit, and if there is agreement between
 3                    the scoping unit and the host scoping unit as to whether the name is a function name or
 4                    a subroutine name, the name is resolved by applying the rules in this section to the host
 5                    scoping unit.


 6    12.4.4.2       Resolving procedure references to names established to be specific
 7            (1)     If the scoping unit contains an interface body or EXTERNAL attribute specification for the
 8                    name, if the scoping unit is a subprogram, and if the name is the name of a dummy argument
 9                    of that subprogram, the dummy argument is a dummy procedure and the reference is to
10                    that dummy procedure. That is, the procedure invoked by executing that reference is the
11                    procedure supplied as the actual argument corresponding to that dummy procedure.

12            (2)     If the scoping unit contains an interface body or EXTERNAL attribute specification for the
13                    name and if (1) does not apply, the reference is to an external procedure with that name.

14            (3)     If the scoping unit contains a module subprogram, internal subprogram, or statement function
15                    that defines a procedure with the name, the reference is to the procedure so defined.

16            (4)     If the scoping unit contains an INTRINSIC attribute specification for the name, the reference
17                    is to the intrinsic with that name.

18            (5)     If the scoping unit contains a USE statement that makes a procedure accessible by the
19                    name, the reference is to that procedure.

             NOTE 12.36

             Because of the renaming facility of the USE statement, the name in the reference may be different
             from the original name of the procedure.

20            (6)     If none of the above apply, the scoping unit shall have a host scoping unit, and the reference
21                    is resolved by applying the rules in this section to the host scoping unit.


22    12.4.4.3       Resolving procedure references to names not established
23            (1)     If the scoping unit is a subprogram and if the name is the name of a dummy argument
24                    of that subprogram, the dummy argument is a dummy procedure and the reference is to
25                    that dummy procedure. That is, the procedure invoked by executing that reference is the
26                    procedure supplied as the actual argument corresponding to that dummy procedure.

27            (2)     If (1) does not apply, if the name is the name of an intrinsic procedure, and if there is
28                    agreement between the reference and the status of the intrinsic procedure as being a function
29                    or subroutine, the reference is to that intrinsic procedure.

30            (3)     If (1) and (2) do not apply, the reference is to an external procedure with that name.


31    12.5           Procedure definition

32    12.5.1         Intrinsic procedure definition

33    Intrinsic procedures are defined as an inherent part of the processor. A standard-conforming processor
34    shall include the intrinsic procedures described in Section 13, but may include others. However, a
35    standard-conforming program shall not make use of intrinsic procedures other than those described in
36    Section 13.





      274                                    WORKING DRAFT                                             SEP 2002


      SEP 2002                               WORKING DRAFT                                       J3/02-007R3


 1    12.5.2      Procedures defined by subprograms

 2    When a procedure defined by a subprogram is invoked, an instance (12.5.2.3) of the subprogram is
 3    created and executed. Execution begins with the first executable construct following the FUNCTION,
 4    SUBROUTINE, or ENTRY statement specifying the name of the procedure invoked.


 5    12.5.2.1    Function subprogram

 6    A function subprogram is a subprogram that has a FUNCTION statement as its first statement.

 7    R1223 function-subprogram              is    function-stmt
 8                                                      [ specification-part ]
 9                                                      [ execution-part ]
10                                                      [ internal-subprogram-part ]
11                                                      end-function-stmt
12    R1224 function-stmt                    is    [ prefix ] FUNCTION function-name
13                                                     ( [ dummy-arg-name-list ] )
14                                                     [, proc-language-binding-spec] [ RESULT ( result-name ) ]

15    C1235     (R1224) If RESULT is specified, result-name shall not be the same as function-name and shall
16              not be the same as the entry-name in any ENTRY statement in the subprogram.

17    C1236     (R1224) If RESULT is specified, the function-name shall not appear in any specification state-
18              ment in the scoping unit of the function subprogram.

19    R1225 proc-language-binding-spec       is    language-binding-spec

20    C1237     (R1225) A proc-language-binding-spec with a NAME= specifier shall not be specified in the
21              function-stmt or subroutine-stmt of an interface body for an abstract interface or a dummy
22              procedure.

23    C1238     (R1225) A proc-language-binding-spec shall not be specified for an internal procedure.

24    C1239     (R1225) If proc-language-binding-spec is specified for a procedure, each of the procedure's dummy
25              arguments shall be a nonoptional interoperable variable (15.2.4, 15.2.5) or an interoperable
26              procedure (15.2.6). If proc-language-binding-spec is specified for a function, the function result
27              shall be an interoperable variable.

28    R1226 dummy-arg-name                   is    name

29    C1240     (R1226) A dummy-arg-name shall be the name of a dummy argument.

30    R1227 prefix                            is    prefix-spec [ prefix-spec ] ...
31    R1228 prefix-spec                       is    declaration-type-spec
32                                           or RECURSIVE
33                                           or PURE
34                                           or ELEMENTAL

35    C1241     (R1227) A prefix shall contain at most one of each prefix-spec.

36    C1242     (R1227) A prefix shall not specify both ELEMENTAL and RECURSIVE.

37    C1243     (R1227) A prefix shall not specify ELEMENTAL if proc-language-binding-spec appears in the
38              function-stmt or subroutine-stmt .

39    R1229 end-function-stmt                is    END [ FUNCTION [ function-name ] ]

40    C1244     (R1229) FUNCTION shall appear in the end-function-stmt of an internal or module function.



      SEP 2002                                         WORKING DRAFT                                        275


      J3/02-007R3                                 WORKING DRAFT                                       SEP 2002



 1    C1245     (R1223) An internal function subprogram shall not contain an ENTRY statement.

 2    C1246     (R1223) An internal function subprogram shall not contain an internal-subprogram-part .

 3    C1247     (R1229) If a function-name appears in the end-function-stmt , it shall be identical to the function-
 4              name specified in the function-stmt .

 5    The type and type parameters (if any) of the result of the function defined by a function subprogram
 6    may be specified by a type specification in the FUNCTION statement or by the name of the result
 7    variable appearing in a type declaration statement in the declaration part of the function subprogram.
 8    They shall not be specified both ways. If they are not specified either way, they are determined by
 9    the implicit typing rules in force within the function subprogram. If the function result is an array,
10    allocatable, or a pointer, this shall be specified by specifications of the name of the result variable within
11    the function body. The specifications of the function result attributes, the specification of dummy
12    argument attributes, and the information in the procedure heading collectively define the characteristics
13    of the function (12.2).

14    The prefix-spec RECURSIVE shall appear if the function directly or indirectly invokes itself or a function
15    defined by an ENTRY statement in the same subprogram. Similarly, RECURSIVE shall appear if a
16    function defined by an ENTRY statement in the subprogram directly or indirectly invokes itself, another
17    function defined by an ENTRY statement in that subprogram, or the function defined by the FUNCTION
18    statement.

19    The name of the function is function-name.

20    If RESULT is specified, the name of the result variable of the function is result-name and all occurrences
21    of the function name in execution-part statements in the scoping unit refer to the function itself. If
22    RESULT is not specified, the result variable is function-name and all occurrences of the function name
23    in execution-part statements in the scoping unit are references to the result variable. The characteristics
24    (12.2.2) of the function result are those of the result variable. On completion of execution of a function,
25    the value returned is the value of its result variable. If the function result is a pointer, the shape of
26    the value returned by the function is determined by the shape of the result variable when the execution
27    of the function is completed. If the result variable is not a pointer, its value shall be defined by the
28    function. If the function result is a pointer, the function shall either associate a target with the result
29    variable pointer or cause the association status of this pointer to become defined as disassociated.

             NOTE 12.37

             The result variable is similar to any other variable local to a function subprogram. Its existence
             begins when execution of the function is initiated and ends when execution of the function is
             terminated. However, because the final value of this variable is used subsequently in the evaluation
             of the expression that invoked the function, an implementation may wish to defer releasing the
             storage occupied by that variable until after its value has been used in expression evaluation.


30    If the prefix-spec PURE or ELEMENTAL appears, the subprogram is a pure subprogram and shall meet
31    the additional constraints of 12.6.

32    If the prefix-spec ELEMENTAL appears, the subprogram is an elemental subprogram and shall meet
33    the additional constraints of 12.7.1.

             NOTE 12.38

             An example of a recursive function is:


             RECURSIVE FUNCTION CUMM_SUM (ARRAY) RESULT (C_SUM)





      276                                    WORKING DRAFT                                            SEP 2002


      SEP 2002                              WORKING DRAFT                                         J3/02-007R3



          NOTE 12.38 (cont.)

                  REAL, INTENT (IN), DIMENSION (:) :: ARRAY
                  REAL, DIMENSION (SIZE (ARRAY)) ::C_SUM
                  INTEGER N
                  N = SIZE (ARRAY)
                  IF (N <= 1) THEN
                     C_SUM = ARRAY
                  ELSE
                     N = N / 2
                     C_SUM (:N) = CUMM_SUM (ARRAY (:N))
                     C_SUM (N+1:) = C_SUM (N) + CUMM_SUM (ARRAY (N+1:))
                  END IF
          END FUNCTION CUMM_SUM



          NOTE 12.39

          The following is an example of the declaration of an interface body with the BIND attribute, and
          a reference to the procedure declared.


          USE, INTRINSIC :: ISO_C_BINDING


          INTERFACE
               FUNCTION JOE (I, J, R), BIND(C,NAME="FrEd")
                  USE, INTRINSIC :: ISO_C_BINDING
                  INTEGER(C_INT) :: JOE
                  INTEGER(C_INT), VALUE :: I, J
                  REAL(C_FLOAT), VALUE :: R
               END FUNCTION JOE
          END INTERFACE


          INT = JOE(1_C_INT, 3_C_INT, 4.0_C_FLOAT)
          END PROGRAM


          The invocation of the function JOE results in a reference to a function with a binding label "FrEd".
          FrEd may be a C function described by the C prototype


               int FrEd(int n, int m, float x);



 1    12.5.2.2     Subroutine subprogram

 2    A subroutine subprogram is a subprogram that has a SUBROUTINE statement as its first statement.

 3    R1230 subroutine-subprogram           is    subroutine-stmt
 4                                                    [ specification-part ]
 5                                                    [ execution-part ]
 6                                                    [ internal-subprogram-part ]
 7                                                    end-subroutine-stmt
 8    R1231 subroutine-stmt                 is    [ prefix ] SUBROUTINE subroutine-name
 9                                                  [ ( [ dummy-arg -list ] ) ] [, proc-language-binding-spec ]

10    C1248    (R1231) The prefix of a subroutine-stmt shall not contain a declaration-type-spec.

11    R1232 dummy-arg                       is    dummy-arg-name




      SEP 2002                                      WORKING DRAFT                                                  277


      J3/02-007R3                                     WORKING DRAFT                                        SEP 2002



 1                                              or *

 2    R1233 end-subroutine-stmt                 is    END [ SUBROUTINE [ subroutine-name ] ]

 3    C1249     (R1233) SUBROUTINE shall appear in the end-subroutine-stmt of an internal or module sub-
 4              routine.

 5    C1250     (R1230) An internal subroutine subprogram shall not contain an ENTRY statement.

 6    C1251     (R1230) An internal subroutine subprogram shall not contain an internal-subprogram-part .

 7    C1252     (R1233) If a subroutine-name appears in the end-subroutine-stmt , it shall be identical to the
 8              subroutine-name specified in the subroutine-stmt .

 9    The name of the subroutine is subroutine-name.

10    The prefix-spec RECURSIVE shall appear if the subroutine directly or indirectly invokes itself or a
11    subroutine defined by an ENTRY statement in the same subprogram. Similarly, RECURSIVE shall
12    appear if a subroutine defined by an ENTRY statement in the subprogram directly or indirectly invokes
13    itself, another subroutine defined by an ENTRY statement in that subprogram, or the subroutine defined
14    by the SUBROUTINE statement.

15    If the prefix-spec PURE or ELEMENTAL appears, the subprogram is a pure subprogram and shall meet
16    the additional constraints of 12.6.

17    If the prefix-spec ELEMENTAL appears, the subprogram is an elemental subprogram and shall meet
18    the additional constraints of 12.7.1.


19    12.5.2.3    Instances of a subprogram

20    When a function or subroutine defined by a subprogram is invoked, an instance of that subprogram is
21    created. When a statement function is invoked, an instance of that statement function is created.

22    Each instance has an independent sequence of execution and an independent set of dummy arguments
23    and local unsaved data objects. If an internal procedure or statement function in the subprogram is invoked
24    directly from an instance of the subprogram or from an internal subprogram or statement function that
25    has access to the entities of that instance, the created instance of the internal subprogram or statement

26    function also has access to the entities of that instance of the host subprogram.


27    All other entities are shared by all instances of the subprogram.

             NOTE 12.40

             The value of a saved data object appearing in one instance may have been defined in a previous
             instance or by initialization in a DATA statement or type declaration statement.


28    12.5.2.4    ENTRY statement

29    An ENTRY statement permits a procedure reference to begin with a particular executable statement
30    within the function or subroutine subprogram in which the ENTRY statement appears.

31    R1234 entry-stmt                          is    ENTRY entry-name [ ( [ dummy-arg -list ] )
32                                                      [, proc-language-binding-spec ]
33                                                      [ RESULT ( result-name ) ] ]
34                                              or ENTRY entry-name
35                                                      , proc-language-binding-spec [ RESULT ( result-name ) ]

36    C1253     (R1234) If RESULT is specified, the entry-name shall not appear in any specification or type-




      278                                     WORKING DRAFT                                                SEP 2002


      SEP 2002                                WORKING DRAFT                                          J3/02-007R3



 1             declaration statement in the scoping unit of the function program.

 2    C1254    (R1234) An entry-stmt may appear only in an external-subprogram or module-subprogram. An
 3             entry-stmt shall not appear within an executable-construct .

 4    C1255    (R1234) RESULT may appear only if the entry-stmt is in a function subprogram.

 5    C1256    (R1234) Within the subprogram containing the entry-stmt , the entry-name shall not appear
 6             as a dummy argument in the FUNCTION or SUBROUTINE statement or in another ENTRY
 7             statement nor shall it appear in an EXTERNAL, INTRINSIC, or PROCEDURE statement.

 8    C1257    (R1234) A dummy-arg may be an alternate return indicator only if the ENTRY statement is in a subroutine

 9             subprogram.


10    C1258    (R1234) If RESULT is specified, result-name shall not be the same as the function-name in the
11             FUNCTION statement and shall not be the same as the entry-name in any ENTRY statement
12             in the subprogram.

13    Optionally, a subprogram may have one or more ENTRY statements.

14    If the ENTRY statement is in a function subprogram, an additional function is defined by that subpro-
15    gram. The name of the function is entry-name and the name of its result variable is result-name or
16    is entry-name if no result-name is provided. The characteristics of the function result are specified by
17    specifications of the result variable. The dummy arguments of the function are those specified in the
18    ENTRY statement. If the characteristics of the result of the function named in the ENTRY statement
19    are the same as the characteristics of the result of the function named in the FUNCTION statement,
20    their result variables identify the same variable, although their names need not be the same. Otherwise,
21    they are storage associated and shall all be scalars without the POINTER attribute and one of the types:
22    default integer, default real, double precision real, default complex, or default logical.

23    If the ENTRY statement is in a subroutine subprogram, an additional subroutine is defined by that
24    subprogram. The name of the subroutine is entry-name. The dummy arguments of the subroutine are
25    those specified in the ENTRY statement.

26    The order, number, types, kind type parameters, and names of the dummy arguments in an ENTRY
27    statement may differ from the order, number, types, kind type parameters, and names of the dummy
28    arguments in the FUNCTION or SUBROUTINE statement in the containing subprogram.

29    Because an ENTRY statement defines an additional function or an additional subroutine, it is referenced
30    in the same manner as any other function or subroutine (12.4).

31    In a subprogram, a name that appears as a dummy argument in an ENTRY statement shall not appear
32    in an executable statement preceding that ENTRY statement, unless it also appears in a FUNCTION,
33    SUBROUTINE, or ENTRY statement that precedes the executable statement.


34    In a subprogram, a name that appears as a dummy argument in an ENTRY statement shall not appear in the expression

35    of a statement function unless the name is also a dummy argument of the statement function, appears in a FUNCTION

36    or SUBROUTINE statement, or appears in an ENTRY statement that precedes the statement function statement.


37    If a dummy argument appears in an executable statement, the execution of the executable statement is
38    permitted during the execution of a reference to the function or subroutine only if the dummy argument
39    appears in the dummy argument list of the procedure name referenced.

40    If a dummy argument is used in a specification expression to specify an array bound or character length
41    of an object, the appearance of the object in a statement that is executed during a procedure reference
42    is permitted only if the dummy argument appears in the dummy argument list of the procedure name
43    referenced and it is present (12.4.1.6).




      SEP 2002                                       WORKING DRAFT                                                 279


      J3/02-007R3                                        WORKING DRAFT                                             SEP 2002



 1    A scoping unit containing a reference to a procedure defined by an ENTRY statement may have access to
 2    an interface body for the procedure. The procedure header for the interface body shall be a FUNCTION
 3    statement for an entry in a function subprogram and shall be a SUBROUTINE statement for an entry
 4    in a subroutine subprogram.

 5    The keyword RECURSIVE is not used in an ENTRY statement. Instead, the presence or absence of
 6    RECURSIVE in the initial SUBROUTINE or FUNCTION statement controls whether the procedure
 7    defined by an ENTRY statement is permitted to reference itself.

 8    The keyword PURE is not used in an ENTRY statement. Instead, the procedure defined by an ENTRY
 9    statement is pure if and only if PURE or ELEMENTAL is specified in the SUBROUTINE or FUNCTION
10    statement.

11    The keyword ELEMENTAL is not used in an ENTRY statement. Instead, the procedure defined by
12    an ENTRY statement is elemental if and only if ELEMENTAL is specified in the SUBROUTINE or
13    FUNCTION statement.


14    12.5.2.5         RETURN statement

15    R1235 return-stmt                            is    RETURN [ scalar-int-expr ]

16    C1259     (R1235) The return-stmt shall be in the scoping unit of a function or subroutine subprogram.

17    C1260     (R1235) The scalar-int-expr is allowed only in the scoping unit of a subroutine subprogram.


18    Execution of the RETURN statement completes execution of the instance of the subprogram in which
19    it appears. If the expression appears and has a value n between 1 and the number of asterisks in the dummy argument

20    list, the CALL statement that invoked the subroutine transfers control to the statement identified by the nth alternate

21    return specifier in the actual argument list. If the expression is omitted or has a value outside the required range, there is

22    no transfer of control to an alternate return.


23    Execution of an end-function-stmt or end-subroutine-stmt is equivalent to executing a RETURN state-
24    ment with no expression.


25    12.5.2.6         CONTAINS statement

26    R1236 contains-stmt                          is    CONTAINS

27    The CONTAINS statement separates the body of a main program, module, or subprogram from any
28    internal or module subprograms it may contain, or it introduces the type-bound procedure part of a
29    derived-type definition (4.5.1). The CONTAINS statement is not executable.


30    12.5.3        Definition and invocation of procedures by means other than Fortran

31    A procedure may be defined by means other than Fortran. The interface of a procedure defined by means
32    other than Fortran may be specified in an interface block. If the interface of such a procedure does not
33    have a proc-language-binding-spec, the means by which the procedure is defined are processor dependent.
34    A reference to such a procedure is made as though it were defined by an external subprogram.

35    If the interface of a procedure has a proc-language-binding-spec, the procedure is interoperable (15.4).

36    Interoperation with C functions is described in 15.4.

             NOTE 12.41

             For explanatory information on definition of procedures by means other than Fortran, see section
             C.9.2.




      280                                       WORKING DRAFT                                                      SEP 2002


      SEP 2002                                     WORKING DRAFT                                               J3/02-007R3


 1    12.5.4        Statement function

 2    A statement function is a function defined by a single statement.


 3    R1237 stmt-function-stmt                     is    function-name ( [ dummy-arg-name-list ] ) = scalar-expr


 4    C1261     (R1237) The primaries of the scalar-expr shall be constants (literal and named), references to variables, references

 5              to functions and function dummy procedures, and intrinsic operations. If scalar-expr contains a reference to a

 6              function or a function dummy procedure, the reference shall not require an explicit interface, the function shall

 7              not require an explicit interface unless it is an intrinsic, the function shall not be a transformational intrinsic,

 8              and the result shall be scalar. If an argument to a function or a function dummy procedure is an array, it shall

 9              be an array name. If a reference to a statement function appears in scalar-expr , its definition shall have been

10              provided earlier in the scoping unit and shall not be the name of the statement function being defined.


11    C1262     (R1237) Named constants in scalar-expr shall have been declared earlier in the scoping unit or made accessible

12              by use or host association. If array elements appear in scalar-expr , the array shall have been declared as an array

13              earlier in the scoping unit or made accessible by use or host association.


14    C1263     (R1237) If a dummy-arg-name, variable, function reference, or dummy function reference is typed by the implicit

15              typing rules, its appearance in any subsequent type declaration statement shall confirm this implied type and

16              the values of any implied type parameters.


17    C1264     (R1237) The function-name and each dummy-arg-name shall be specified, explicitly or implicitly, to be scalar.


18    C1265     (R1237) A given dummy-arg-name may appear only once in any dummy-arg-name-list.


19    C1266     (R1237) Each variable reference in scalar-expr may be either a reference to a dummy argument of the statement

20              function or a reference to a variable accessible in the same scoping unit as the statement function statement.


21    The definition of a statement function with the same name as an accessible entity from the host shall be preceded by the

22    declaration of its type in a type declaration statement.


23    The dummy arguments have a scope of the statement function statement. Each dummy argument has the same type and

24    type parameters as the entity of the same name in the scoping unit containing the statement function.


25    A statement function shall not be supplied as a procedure argument.


26    The value of a statement function reference is obtained by evaluating the expression using the values of the actual arguments

27    for the values of the corresponding dummy arguments and, if necessary, converting the result to the declared type and

28    type attributes of the function.


29    A function reference in the scalar expression shall not cause a dummy argument of the statement function to become

30    redefined or undefined.



31    12.6          Pure procedures

32    A pure procedure is

33           (1)     A pure intrinsic function (13.1),

34           (2)     A pure intrinsic subroutine (13.1),

35           (3)     Defined by a pure subprogram, or

36           (4)     A statement function that references only pure functions.


37    A pure subprogram is a subprogram that has the prefix-spec PURE or ELEMENTAL. The following
38    additional constraints apply to pure subprograms.





      SEP 2002                                             WORKING DRAFT                                                      281


      J3/02-007R3                                   WORKING DRAFT                                     SEP 2002



 1    C1267     The specification-part of a pure function subprogram shall specify that all dummy arguments
 2              have INTENT (IN) except procedure arguments and arguments with the POINTER attribute.

 3    C1268     The specification-part of a pure subroutine subprogram shall specify the intents of all dummy ar-
 4              guments except procedure arguments, alternate return indicators, and arguments with the POINTER
 5              attribute.

 6    C1269     A local variable declared in the specification-part or internal-subprogram-part of a pure subpro-
 7              gram shall not have the SAVE attribute.

             NOTE 12.42

             Variable initialization in a type-declaration-stmt or a data-stmt implies the SAVE attribute; there-
             fore, such initialization is also disallowed.


 8    C1270     The specification-part of a pure subprogram shall specify that all dummy arguments that are
 9              procedure arguments are pure.

10    C1271     If a procedure that is neither an intrinsic procedure nor a statement function is used in a context
11              that requires it to be pure, then its interface shall be explicit in the scope of that use. The
12              interface shall specify that the procedure is pure.

13    C1272     All internal subprograms in a pure subprogram shall be pure.

14    C1273     In a pure subprogram any designator with a base object that is in common or accessed by
15              host or use association, is a dummy argument of a pure function, is a dummy argument with
16              INTENT (IN) of a pure subroutine, or an object that is storage associated with any such variable,
17              shall not be used in the following contexts:

18            (1)    In a variable definition context(16.5.7);

19            (2)    As the data-target in a pointer-assignment-stmt ;

20            (3)    As the expr corresponding to a component with the POINTER attribute in a structure-
21                   constructor .

22            (4)    As the expr of an intrinsic assignment statement in which the variable is of a derived type
23                   if the derived type has a pointer component at any level of component selection; or

             NOTE 12.43

             This requires that processors be able to determine if entities with the PRIVATE attribute or with
             private components have a pointer component.

24            (5)    As an actual argument associated with a dummy argument with INTENT (OUT) or IN-
25                   TENT (INOUT) or with the POINTER attribute.

26    C1274     Any procedure referenced in a pure subprogram, including one referenced via a defined operation,
27              assignment, or finalization, shall be pure.

28    C1275     A pure subprogram shall not contain a print-stmt , open-stmt , close-stmt , backspace-stmt , endfile-
29              stmt , rewind-stmt , flush-stmt , wait-stmt , or inquire-stmt .

30    C1276     A pure subprogram shall not contain a read-stmt or write-stmt whose io-unit is a file-unit-
31              number or *.

32    C1277     A pure subprogram shall not contain a stop-stmt .





      282                                     WORKING DRAFT                                           SEP 2002


      SEP 2002                              WORKING DRAFT                                     J3/02-007R3



          NOTE 12.44

          The above constraints are designed to guarantee that a pure procedure is free from side effects
          (modifications of data visible outside the procedure), which means that it is safe to reference it in
          constructs such as a FORALL assignment-stmt where there is no explicit order of evaluation.

          The constraints on pure subprograms may appear complicated, but it is not necessary for a pro-
          grammer to be intimately familiar with them. From the programmer's point of view, these con-
          straints can be summarized as follows: a pure subprogram shall not contain any operation that
          could conceivably result in an assignment or pointer assignment to a common variable, a variable
          accessed by use or host association, or an INTENT (IN) dummy argument; nor shall a pure sub-
          program contain any operation that could conceivably perform any external file input/output or
          STOP operation. Note the use of the word conceivably; it is not sufficient for a pure subprogram
          merely to be side-effect free in practice. For example, a function that contains an assignment to a
          global variable but in a block that is not executed in any invocation of the function is nevertheless
          not a pure function. The exclusion of functions of this nature is required if strict compile-time
          checking is to be used.

          It is expected that most library procedures will conform to the constraints required of pure pro-
          cedures, and so can be declared pure and referenced in FORALL statements and constructs and
          within user-defined pure procedures.


          NOTE 12.45

          Pure subroutines are included to allow subroutine calls from pure procedures in a safe way, and to
          allow forall-assignment-stmt s to be defined assignments. The constraints for pure subroutines are
          based on the same principles as for pure functions, except that side effects to INTENT (OUT),
          INTENT (INOUT), and pointer dummy arguments are permitted.



 1    12.7       Elemental procedures

 2    12.7.1      Elemental procedure declaration and interface

 3    An elemental procedure is an elemental intrinsic procedure or a procedure that is defined by an
 4    elemental subprogram.

 5    An elemental subprogram has the prefix-spec ELEMENTAL. An elemental subprogram is a pure sub-
 6    program. The PURE prefix-spec need not appear; it is implied by the ELEMENTAL prefix-spec. The
 7    following additional constraints apply to elemental subprograms.

 8    C1278     All dummy arguments of an elemental procedure shall be scalar dummy data objects and shall
 9              not have the POINTER or ALLOCATABLE attribute.

10    C1279     The result variable of an elemental function shall be scalar and shall not have the POINTER or
11              ALLOCATABLE attribute.

12    C1280     In the scoping unit of an elemental subprogram, an object designator with a dummy argument
13              as the base object shall not appear in a specification-expr except as the argument to one of the
14              intrinsic functions BIT SIZE, KIND, LEN, or the numeric inquiry functions (13.5.6).

          NOTE 12.46

          An elemental subprogram is a pure subprogram and all of the constraints for pure subprograms
          also apply.





      SEP 2002                                    WORKING DRAFT                                            283


      J3/02-007R3                                WORKING DRAFT                                      SEP 2002



             NOTE 12.47

             The restriction on dummy arguments in specification expressions is imposed primarily to facilitate
             optimization. An example of usage that is not permitted is


                  ELEMENTAL REAL FUNCTION F (A, N)
                      REAL, INTENT (IN) :: A
                      INTEGER, INTENT (IN) :: N
                      REAL :: WORK_ARRAY(N)        ! Invalid
                      ...
                  END FUNCTION F


             An example of usage that is permitted is


                  ELEMENTAL REAL FUNCTION F (A)
                      REAL, INTENT (IN) :: A
                      REAL (SELECTED_REAL_KIND (PRECISION (A)*2)) :: WORK
                      ...
                  END FUNCTION F



 1    12.7.2      Elemental function actual arguments and results

 2    If a generic name or a specific name is used to reference an elemental function, the shape of the result is
 3    the same as the shape of the actual argument with the greatest rank. If there are no actual arguments
 4    or the actual arguments are all scalar, the result is scalar. For those elemental functions that have more
 5    than one argument, all actual arguments shall be conformable. In the array case, the values of the
 6    elements, if any, of the result are the same as would have been obtained if the scalar function had been
 7    applied separately, in any order, to corresponding elements of each array actual argument.

             NOTE 12.48

             An example of an elemental reference to the intrinsic function MAX:

             if X and Y are arrays of shape (M, N),


             MAX (X, 0.0, Y)


             is an array expression of shape (M, N) whose elements have values


             MAX (X(I, J),      0.0, Y(I, J)), I = 1, 2, ..., M, J = 1,2, ..., N



 8    12.7.3      Elemental subroutine actual arguments

 9    An elemental subroutine is one that has only scalar dummy arguments, but may have array actual
10    arguments. In a reference to an elemental subroutine, either all actual arguments shall be scalar, or
11    all actual arguments associated with INTENT (OUT) and INTENT (INOUT) dummy arguments shall
12    be arrays of the same shape and the remaining actual arguments shall be conformable with them. In
13    the case that the actual arguments associated with INTENT (OUT) and INTENT (INOUT) dummy
14    arguments are arrays, the values of the elements, if any, of the results are the same as would be obtained
15    if the subroutine had been applied separately, in any order, to corresponding elements of each array
16    actual argument.

17    In a reference to the intrinsic subroutine MVBITS, the actual arguments corresponding to the TO and
18    FROM dummy arguments may be the same variable and may be associated scalar variables or associated
19    array variables all of whose corresponding elements are associated. Apart from this, the actual arguments



      284                                  WORKING DRAFT                                            SEP 2002


     SEP 2002                              WORKING DRAFT                                     J3/02-007R3



1    in a reference to an elemental subroutine must satisfy the restrictions of 12.4.1.7.





     SEP 2002                                    WORKING DRAFT                                      285


J3/02-007R3       WORKING DRAFT    SEP 2002





286            WORKING DRAFT       SEP 2002


      SEP 2002                             WORKING DRAFT                                      J3/02-007R3





 1    Section 13: Intrinsic procedures and modules

 2    There are four classes of intrinsic procedures: inquiry functions, elemental functions, transformational
 3    functions, and subroutines. Some intrinsic subroutines are elemental.

 4    There are three sets of standard intrinsic modules: a Fortran environment module (13.8.3), modules to
 5    support exception handling and IEEE arithmetic, and a module to support interoperability with the C
 6    programming language. The later two sets of modules are described in sections 14 and 15, respectively.


 7    13.1          Classes of intrinsic procedures

 8    An inquiry function is one whose result depends on the properties of one or more of its arguments
 9    instead of their values; in fact, these argument values may be undefined. Unless the description of an
10    inquiry function states otherwise, these arguments are permitted to be unallocated or pointers that are
11    not associated. An elemental intrinsic function is one that is specified for scalar arguments, but may
12    be applied to array arguments as described in 12.7. All other intrinsic functions are transformational
13    functions; they almost all have one or more array arguments or an array result. All standard intrinsic
14    functions are pure.

15    The elemental subroutine MVBITS is pure. No other standard intrinsic subroutine is pure.

           NOTE 13.1

           As with user-written elemental subroutines, an elemental intrinsic subroutine is pure. The nonele-
           mental intrinsic subroutines all have side effects (or reflect system side effects) and thus are not
           pure.


16    Generic names of standard intrinsic procedures are listed in 13.5. In most cases, generic functions
17    accept arguments of more than one type and the type of the result is the same as the type of the
18    arguments. Specific names of standard intrinsic functions with corresponding generic names are listed
19    in 13.6.

20    If an intrinsic function is used as an actual argument to a procedure, its specific name shall be used and
21    it may be referenced in the called procedure only with scalar arguments. If an intrinsic function does
22    not have a specific name, it shall not be used as an actual argument (12.4.1.3).

23    Elemental intrinsic procedures behave as described in 12.7.


24    13.2          Arguments to intrinsic procedures

25    All intrinsic procedures may be invoked with either positional arguments or argument keywords (12.4).
26    The descriptions in 13.5 through 13.7 give the argument keyword names and positional sequence for
27    standard intrinsic procedures.

28    Many of the intrinsic procedures have optional arguments. These arguments are identified by the notation
29    "optional" in the argument descriptions. In addition, the names of the optional arguments are enclosed
30    in square brackets in description headings and in lists of procedures. The valid forms of reference for
31    procedures with optional arguments are described in 12.4.1.





      SEP 2002                                   WORKING DRAFT                                            287


      J3/02-007R3                                 WORKING DRAFT                                      SEP 2002



             NOTE 13.2

             The text CMPLX (X [, Y, KIND]) indicates that Y and KIND are both optional arguments. Valid
             reference forms include CMPLX(x ), CMPLX(x, y), CMPLX(x, KIND=kind ), CMPLX(x, y, kind ),
             and CMPLX(KIND=kind, X=x, Y=y).


             NOTE 13.3

             Some intrinsic procedures impose additional requirements on their optional arguments. For exam-
             ple, SELECTED REAL KIND requires that at least one of its optional arguments be present, and
             RANDOM SEED requires that at most one of its optional arguments be present.


 1    The dummy arguments of the specific intrinsic procedures in 13.6 have INTENT(IN). The dummy
 2    arguments of the generic intrinsic procedures in 13.7 have INTENT(IN) if the intent is not stated
 3    explicitly.

 4    The actual argument associated with an intrinsic function dummy argument named KIND shall be a
 5    scalar integer initialization expression and its value shall specify a representation method for the function
 6    result that exists on the processor.

 7    Intrinsic subroutines that assign values to arguments of type character do so in accordance with the
 8    rules of intrinsic assignment (7.4.1.3).


 9    13.2.1         The shape of array arguments

10    Unless otherwise specified, the inquiry intrinsic functions accept array arguments for which the shape
11    need not be defined. The shape of array arguments to transformational and elemental intrinsic functions
12    shall be defined.


13    13.2.2         Mask arguments

14    Some array intrinsic functions have an optional MASK argument of type logical that is used by the
15    function to select the elements of one or more arguments to be operated on by the function. Any
16    element not selected by the mask need not be defined at the time the function is invoked.

17    The MASK affects only the value of the function, and does not affect the evaluation, prior to invoking
18    the function, of arguments that are array expressions.


19    13.3           Bit model

20    The bit manipulation procedures are ten elemental functions and one elemental subroutine. Logical
21    operations on bits are provided by the elemental functions IOR, IAND, NOT, and IEOR; shift operations
22    are provided by the elemental functions ISHFT and ISHFTC; bit subfields may be referenced by the
23    elemental function IBITS and by the elemental subroutine MVBITS; single-bit processing is provided
24    by the elemental functions BTEST, IBSET, and IBCLR.

25    For the purposes of these procedures, a bit is defined to be a binary digit w located at position k of a
26    nonnegative integer scalar object based on a model nonnegative integer defined by


                                                           z-1

                                                    j =           wk � 2k
                                                           k=0


27    and for which wk may have the value 0 or 1. An example of a model number compatible with the
28    examples used in 13.4 would have z = 32, thereby defining a 32-bit integer.



      288                                     WORKING DRAFT                                          SEP 2002


      SEP 2002                              WORKING DRAFT                                                       J3/02-007R3



 1    An inquiry function BIT SIZE is available to determine the parameter z of the model.

 2    Effectively, this model defines an integer object to consist of z bits in sequence numbered from right
 3    to left from 0 to z - 1. This model is valid only in the context of the use of such an object as the
 4    argument or result of one of the bit manipulation procedures. In all other contexts, the model defined
 5    for an integer in 13.4 applies. In particular, whereas the models are identical for wz-1 = 0, they do not
 6    correspond for wz-1 = 1 and the interpretation of bits in such objects is processor dependent.


 7    13.4        Numeric models

 8    The numeric manipulation and inquiry functions are described in terms of a model for the representation
 9    and behavior of numbers on a processor. The model has parameters that are determined so as to make
10    the model best fit the machine on which the program is executed.

11    The model set for integer i is defined by


                                                                q-1

                                                    i = s �             wk � rk
                                                                k=0


12    where r is an integer exceeding one, q is a positive integer, each wk is a nonnegative integer less than r,
13    and s is +1 or �1.

14    The model set for real x is defined by


                                                   0 or

                                                                        p
                                           x = 
                                                   s � be �                  fk � b-k ,
                                                                       k=1


15    where b and p are integers exceeding one; each fk is a nonnegative integer less than b, with f1 nonzero; s
16    is +1 or �1; and e is an integer that lies between some integer maximum emax and some integer minimum
17    emin inclusively. For x = 0, its exponent e and digits fk are defined to be zero. The integer parameters
18    r and q determine the set of model integers and the integer parameters b, p, emin, and emax determine
19    the set of model floating point numbers. The parameters of the integer and real models are available
20    for each integer and real type implemented by the processor. The parameters characterize the set of
21    available numbers in the definition of the model. The floating-point manipulation functions (13.5.10)
22    and numeric inquiry functions (13.5.6) provide values of some parameters and other values related to
23    the models.

           NOTE 13.4

           Examples of these functions in 13.7 use the models


                                                                       30

                                                     i = s �                 wk � 2k
                                                                      k=0



           and


                                                                24
                                                      1
                               x = 0 or s � 2e �           +           fk � 2-k         ,    - 126  e  127
                                                      2
                                                                k=2





      SEP 2002                                       WORKING DRAFT                                                     289


      J3/02-007R3                              WORKING DRAFT                                      SEP 2002


 1    13.5       Standard generic intrinsic procedures

 2    For all of the standard intrinsic procedures, the arguments shown are the names that shall be used for
 3    argument keywords if the keyword form is used for actual arguments.

             NOTE 13.5

             For example, a reference to CMPLX may be written in the form CMPLX (A, B, M) or in the form
             CMPLX (Y = B, KIND = M, X = A).


             NOTE 13.6

             Many of the argument keywords have names that are indicative of their usage. For example:

                 KIND                                   Describes the kind type parameter of the result
                 STRING, STRING A                       An arbitrary character string
                 BACK                                   Controls the direction of string scan
                                                          (forward or backward)
                 MASK                                   A mask that may be applied to the arguments
                 DIM                                    A selected dimension of an array argument



 4    13.5.1      Numeric functions

 5        ABS (A)                                           Absolute value
 6        AIMAG (Z)                                         Imaginary part of a complex number
 7        AINT (A [, KIND])                                 Truncation to whole number
 8        ANINT (A [, KIND])                                Nearest whole number
 9        CEILING (A [, KIND])                              Least integer greater than or equal to number
10        CMPLX (X [, Y, KIND])                             Conversion to complex type
11        CONJG (Z)                                         Conjugate of a complex number
12        DBLE (A)                                          Conversion to double precision real type
13        DIM (X, Y)                                        Positive difference
14        DPROD (X, Y)                                      Double precision real product
15        FLOOR (A [, KIND])                                Greatest integer less than or equal to number
16        INT (A [, KIND])                                  Conversion to integer type
17        MAX (A1, A2 [, A3,...])                           Maximum value
18        MIN (A1, A2 [, A3,...])                           Minimum value
19        MOD (A, P)                                        Remainder function
20        MODULO (A, P)                                     Modulo function
21        NINT (A [, KIND])                                 Nearest integer
22        REAL (A [, KIND])                                 Conversion to real type
23        SIGN (A, B)                                       Transfer of sign


24    13.5.2      Mathematical functions

25        ACOS (X)                                          Arccosine
26        ASIN (X)                                          Arcsine
27        ATAN (X)                                          Arctangent
28        ATAN2 (Y, X)                                      Arctangent
29        COS (X)                                           Cosine
30        COSH (X)                                          Hyperbolic cosine
31        EXP (X)                                           Exponential
32        LOG (X)                                           Natural logarithm
33        LOG10 (X)                                         Common logarithm (base 10)
34        SIN (X)                                           Sine



      290                                 WORKING DRAFT                                           SEP 2002


      SEP 2002                          WORKING DRAFT                                  J3/02-007R3



 1       SINH (X)                                  Hyperbolic sine
 2       SQRT (X)                                  Square root
 3       TAN (X)                                   Tangent
 4       TANH (X)                                  Hyperbolic tangent


 5    13.5.3     Character functions

 6       ACHAR (I)                                 Character in given position in ASCII collating
 7                                                     sequence
 8       ADJUSTL (STRING)                          Adjust left
 9       ADJUSTR (STRING)                          Adjust right
10       CHAR (I [, KIND])                         Character in given position in processor collating
11                                                     sequence
12       IACHAR (C)                                Position of a character in ASCII collating
13                                                     sequence
14       ICHAR (C [, KIND])                        Position of a character in processor collating
15                                                     sequence
         INDEX (STRING, SUBSTRING [, BACK,         Starting position of a substring
16              KIND])
17       LEN TRIM (STRING [, KIND])                Length without trailing blank characters
18       LGE (STRING A, STRING B)                  Lexically greater than or equal
19       LGT (STRING A, STRING B)                  Lexically greater than
20       LLE (STRING A, STRING B)                  Lexically less than or equal
21       LLT (STRING A, STRING B)                  Lexically less than
22       MAX (A1, A2 [, A3,...])                   Maximum value
23       MIN (A1, A2 [, A3,...])                   Minimum value
24       REPEAT (STRING, NCOPIES)                  Repeated concatenation
25       SCAN (STRING, SET [, BACK, KIND])         Scan a string for a character in a set
26       TRIM (STRING)                             Remove trailing blank characters
27       VERIFY (STRING, SET [, BACK, KIND])       Verify the set of characters in a string


28    13.5.4     Kind functions

29       KIND (X)                                  Kind type parameter value
30       SELECTED CHAR KIND (NAME)                 Character kind type parameter value, given
31                                                     character set name
32       SELECTED INT KIND (R)                     Integer kind type parameter value, given range
33       SELECTED REAL KIND ([P, R])               Real kind type parameter value, given precision
34                                                     and range


35    13.5.5     Miscellaneous type conversion functions

36       LOGICAL (L [, KIND])                      Convert between objects of type logical with
37                                                     different kind type parameters
38       TRANSFER (SOURCE, MOLD [, SIZE])          Treat first argument as if of type of second
39                                                     argument


40    13.5.6     Numeric inquiry functions

41       DIGITS (X)                                Number of significant digits of the model
42       EPSILON (X)                               Number that is almost negligible compared to
43                                                     one
44       HUGE (X)                                  Largest number of the model
45       MAXEXPONENT (X)                           Maximum exponent of the model




      SEP 2002                                WORKING DRAFT                                          291


      J3/02-007R3                           WORKING DRAFT                                 SEP 2002



 1       MINEXPONENT (X)                          Minimum exponent of the model
 2       PRECISION (X)                            Decimal precision
 3       RADIX (X)                                Base of the model
 4       RANGE (X)                                Decimal exponent range
 5       TINY (X)                                 Smallest positive number of the model


 6    13.5.7     Array inquiry functions

 7       LBOUND (ARRAY [, DIM, KIND])             Lower dimension bounds of an array
 8       SHAPE (SOURCE [, KIND])                  Shape of an array or scalar
 9       SIZE (ARRAY [, DIM, KIND])               total number of elements in an array
10       UBOUND (ARRAY [, DIM, KIND])             Upper dimension bounds of an array


11    13.5.8     Other inquiry functions

         ALLOCATED (ARRAY) or                     Allocation status
12              ALLOCATED (SCALAR)
13       ASSOCIATED (POINTER [, TARGET])          Association status inquiry or comparison
14       BIT SIZE (I)                             Number of bits of the model
15       EXTENDS TYPE OF (A, MOLD)                Same dynamic type or an extension
16       LEN (STRING [, KIND])                    Length of a character entity
17       PRESENT (A)                              Argument presence
18       SAME TYPE AS (A, B)                      Same dynamic type


19    13.5.9     Bit manipulation procedures

20       BTEST (I, POS)                           Bit testing
21       IAND (I, J)                              Bitwise AND
22       IBCLR (I, POS)                           Clear bit
23       IBITS (I, POS, LEN)                      Bit extraction
24       IBSET (I, POS)                           Set bit
25       IEOR (I, J)                              Exclusive OR
26       IOR (I, J)                               Inclusive OR
27       ISHFT (I, SHIFT)                         Logical shift
28       ISHFTC (I, SHIFT [, SIZE])               Circular shift
         MVBITS (FROM, FROMPOS, LEN, TO,          Copies bits from one integer to another
29              TOPOS)
30       NOT (I)                                  Bitwise complement


31    13.5.10     Floating-point manipulation functions

32       EXPONENT (X)                             Exponent part of a model number
33       FRACTION (X)                             Fractional part of a number
34       NEAREST (X, S)                           Nearest different processor number in given
35                                                    direction
36       RRSPACING (X)                            Reciprocal of the relative spacing of model
37                                                    numbers near given number
38       SCALE (X, I)                             Multiply a real by its base to an integer power
39       SET EXPONENT (X, I)                      Set exponent part of a number
40       SPACING (X)                              Absolute spacing of model numbers near given
41                                                    number





      292                              WORKING DRAFT                                      SEP 2002


      SEP 2002                      WORKING DRAFT                                  J3/02-007R3


 1    13.5.11    Vector and matrix multiply functions

         DOT PRODUCT (VECTOR A,                   Dot product of two rank-one arrays
 2          VECTOR B)
 3       MATMUL (MATRIX A, MATRIX B)              Matrix multiplication


 4    13.5.12    Array reduction functions

 5       ALL (MASK [, DIM])                       True if all values are true
 6       ANY (MASK [, DIM])                       True if any value is true
 7       COUNT (MASK [, DIM, KIND])               Number of true elements in an array
         MAXVAL (ARRAY, DIM [, MASK]) or          Maximum value in an array
 8          MAXVAL (ARRAY [, MASK])
         MINVAL (ARRAY, DIM [, MASK]) or          Minimum value in an array
 9          MINVAL (ARRAY [, MASK])
         PRODUCT (ARRAY, DIM [, MASK]) or         Product of array elements
10          PRODUCT (ARRAY [, MASK])
         SUM (ARRAY, DIM [, MASK]) or             Sum of array elements
11          SUM (ARRAY [, MASK])


12    13.5.13    Array construction functions

13       CSHIFT (ARRAY, SHIFT [, DIM])            Circular shift
         EOSHIFT (ARRAY, SHIFT [, BOUNDARY,       End-off shift
14          DIM])
15       MERGE (TSOURCE, FSOURCE, MASK)           Merge under mask
16       PACK (ARRAY, MASK [, VECTOR])            Pack an array into an array of rank one under a
17                                                    mask
         RESHAPE (SOURCE, SHAPE[, PAD,            Reshape an array
18          ORDER])
19       SPREAD (SOURCE, DIM, NCOPIES)            Replicates array by adding a dimension
20       TRANSPOSE (MATRIX)                       Transpose of an array of rank two
21       UNPACK (VECTOR, MASK, FIELD)             Unpack an array of rank one into an array under
22                                                    a mask


23    13.5.14    Array location functions

         MAXLOC (ARRAY, DIM [, MASK, KIND])       Location of a maximum value in an array
            or MAXLOC (ARRAY [, MASK,
24          KIND])
         MINLOC (ARRAY, DIM [, MASK, KIND])       Location of a minimum value in an array
            or MINLOC (ARRAY [, MASK, KIND])
25


26    13.5.15    Null function

27       NULL ([MOLD])                            Returns disassociated or unallocated result


28    13.5.16    Random number subroutines

29       RANDOM NUMBER (HARVEST)                  Returns pseudorandom number
30       RANDOM SEED ([SIZE, PUT, GET])           Initializes or restarts the pseudorandom number
31                                                    generator





      SEP 2002                               WORKING DRAFT                                       293


      J3/02-007R3                             WORKING DRAFT                                    SEP 2002


 1    13.5.17         System environment procedures

 2           COMMAND ARGUMENT COUNT ()                    Number of command arguments
 3           CPU TIME (TIME)                              Obtain processor time
             DATE AND TIME ([DATE, TIME, ZONE,            Obtain date and time
 4              VALUES])
             GET COMMAND ([COMMAND,                       Returns entire command
 5              LENGTH, STATUS])
             GET COMMAND ARGUMENT (NUMBER                 Returns a command argument
 6              [, VALUE, LENGTH, STATUS])
             GET ENVIRONMENT VARIABLE (NAME               Obtain the value of an environment variable
                [, VALUE, LENGTH, STATUS,
 7              TRIM NAME])
             SYSTEM CLOCK ([COUNT,                        Obtain data from the system clock
 8              COUNT RATE, COUNT MAX])


 9    13.6       Specific names for standard intrinsic functions

10    Except for AMAX0, AMIN0, MAX1, and MIN1, the result type of the specific function is the same as the
11    result type of the corresponding generic function would be if it were invoked with the same arguments
12    as the specific function.


              Specific Name                      Generic Name                        Argument Type


              ABS                               ABS                                 default real
              ACOS                              ACOS                                default real
              AIMAG                             AIMAG                               default complex
              AINT                              AINT                                default real
              ALOG                              LOG                                 default real
              ALOG10                            LOG10                               default real
        �     AMAX0 (. . . )                    REAL (MAX (. . . ))                 default integer
        �     AMAX1                             MAX                                 default real
        �     AMIN0 (. . . )                    REAL (MIN (. . . ))                 default integer
        �     AMIN1                             MIN                                 default real
              AMOD                              MOD                                 default real
              ANINT                             ANINT                               default real
              ASIN                              ASIN                                default real
              ATAN                              ATAN                                default real
              ATAN2                             ATAN2                               default real
              CABS                              ABS                                 default complex
              CCOS                              COS                                 default complex
              CEXP                              EXP                                 default complex
              CHAR                              CHAR                                default integer
              CLOG                              LOG                                 default complex
              CONJG                             CONJG                               default complex
              COS                               COS                                 default real
              COSH                              COSH                                default real
              CSIN                              SIN                                 default complex
              CSQRT                             SQRT                                default complex
              DABS                              ABS                                 double precision real
              DACOS                             ACOS                                double precision real
              DASIN                             ASIN                                double precision real
              DATAN                             ATAN                                double precision real
              DATAN2                            ATAN2                               double precision real
              DCOS                              COS                                 double precision real



      294                               WORKING DRAFT                                          SEP 2002


     SEP 2002                             WORKING DRAFT                                    J3/02-007R3


            Specific Name                        Generic Name                         Argument Type


            DCOSH                               COSH                                 double precision real
            DDIM                                DIM                                  double precision real
            DEXP                                EXP                                  double precision real
            DIM                                 DIM                                  default real
            DINT                                AINT                                 double precision real
            DLOG                                LOG                                  double precision real
            DLOG10                              LOG10                                double precision real
       �    DMAX1                               MAX                                  double precision real
       �    DMIN1                               MIN                                  double precision real
            DMOD                                MOD                                  double precision real
            DNINT                               ANINT                                double precision real
            DPROD                               DPROD                                default real
            DSIGN                               SIGN                                 double precision real
            DSIN                                SIN                                  double precision real
            DSINH                               SINH                                 double precision real
            DSQRT                               SQRT                                 double precision real
            DTAN                                TAN                                  double precision real
            DTANH                               TANH                                 double precision real
            EXP                                 EXP                                  default real
       �    FLOAT                               REAL                                 default integer
            IABS                                ABS                                  default integer
       �    ICHAR                               ICHAR                                default character
            IDIM                                DIM                                  default integer
       �    IDINT                               INT                                  double precision real
            IDNINT                              NINT                                 double precision real
       �    IFIX                                INT                                  default real
            INDEX                               INDEX                                default character
       �    INT                                 INT                                  default real
            ISIGN                               SIGN                                 default integer
            LEN                                 LEN                                  default character
       �    LGE                                 LGE                                  default character
       �    LGT                                 LGT                                  default character
       �    LLE                                 LLE                                  default character
       �    LLT                                 LLT                                  default character
       �    MAX0                                MAX                                  default integer
       �    MAX1 (. . . )                       INT (MAX (. . . ))                   default real
       �    MIN0                                MIN                                  default integer
       �    MIN1 (. . . )                       INT (MIN (. . . ))                   default real
            MOD                                 MOD                                  default integer
            NINT                                NINT                                 default real
       �    REAL                                REAL                                 default integer
            SIGN                                SIGN                                 default real
            SIN                                 SIN                                  default real
            SINH                                SINH                                 default real
       �    SNGL                                REAL                                 double precision real
            SQRT                                SQRT                                 default real
            TAN                                 TAN                                  default real
            TANH                                TANH                                 default real



1    A specific intrinsic function market with a bullet (�) shall not be used as an actual argument.





     SEP 2002                                   WORKING DRAFT                                             295


      J3/02-007R3                                 WORKING DRAFT                                       SEP 2002


 1    13.7       Specifications of the standard intrinsic procedures

 2    Detailed specifications of the standard generic intrinsic procedures are provided here in alphabetical
 3    order.

 4    The types and type parameters of standard intrinsic procedure arguments and function results are de-
 5    termined by these specifications. The "Argument(s)" paragraphs specify requirements on the actual
 6    arguments of the procedures. The result characteristics are sometimes specified in terms of the charac-
 7    teristics of dummy arguments. A program is prohibited from invoking an intrinsic procedure under cir-
 8    cumstances where a value to be returned in a subroutine argument or function result is outside the range
 9    of values representable by objects of the specified type and type parameters, unless the intrinsic module
10    IEEE ARITHMETIC (section 14) is accessible and there is support for an infinite or a NaN result, as
11    appropriate. If an infinite result is returned, the flag IEEE OVERFLOW or IEEE DIVIDE BY ZERO
12    shall signal; if a NaN result is returned, the flag IEEE INVALID shall signal. If all results are normal,
13    these flags shall have the same status as when the intrinsic procedure was invoked.


14    13.7.1         ABS (A)

15              Description. Absolute value.

16              Class. Elemental function.

17              Argument.      A shall be of type integer, real, or complex.

18              Result Characteristics. The same as A except that if A is complex, the result is real.

19              Result Value. If A is of type integer or real, the value of the result is |A|; if A is complex with
20              value (x, y), the result is equal to a processor-dependent approximation to     x2 + y2.

21              Example.     ABS ((3.0, 4.0)) has the value 5.0 (approximately).


22    13.7.2         ACHAR (I)

23              Description. Returns the character in a specified position of the ASCII collating sequence. It
24              is the inverse of the IACHAR function.

25              Class. Elemental function.

26              Argument.      I shall be of type integer.

27              Result Characteristics. Default character of length one.

28              Result Value. If I has a value in the range 0  I  127, the result is the character in position I
29              of the ASCII collating sequence, provided the processor is capable of representing that character;
30              otherwise, the result is processor dependent. ACHAR (IACHAR (C)) shall have the value C for
31              any character C capable of representation in the processor.

32              Example.     ACHAR (88) has the value 'X'.


33    13.7.3         ACOS (X)

34              Description. Arccosine (inverse cosine) function.

35              Class. Elemental function.

36              Argument.      X shall be of type real with a value that satisfies the inequality |X|  1.

37              Result Characteristics. Same as X.



      296                                   WORKING DRAFT                                             SEP 2002


      SEP 2002                                WORKING DRAFT                                     J3/02-007R3



 1              Result Value. The result has a value equal to a processor-dependent approximation to arc-
 2              cos(X), expressed in radians. It lies in the range 0  ACOS(X)  .

 3              Example.     ACOS (0.54030231) has the value 1.0 (approximately).


 4    13.7.4         ADJUSTL (STRING)

 5              Description. Adjust to the left, removing leading blanks and inserting trailing blanks.

 6              Class. Elemental function.

 7              Argument.     STRING shall be of type character.

 8              Result Characteristics. Character of the same length and kind type parameter as STRING.

 9              Result Value. The value of the result is the same as STRING except that any leading blanks
10              have been deleted and the same number of trailing blanks have been inserted.

11              Example.     ADJUSTL (' WORD') has the value 'WORD '.


12    13.7.5         ADJUSTR (STRING)

13              Description. Adjust to the right, removing trailing blanks and inserting leading blanks.

14              Class. Elemental function.

15              Argument.     STRING shall be of type character.

16              Result Characteristics. Character of the same length and kind type parameter as STRING.

17              Result Value. The value of the result is the same as STRING except that any trailing blanks
18              have been deleted and the same number of leading blanks have been inserted.

19              Example.     ADJUSTR ('WORD ') has the value ' WORD'.


20    13.7.6         AIMAG (Z)

21              Description. Imaginary part of a complex number.

22              Class. Elemental function.

23              Argument.     Z shall be of type complex.

24              Result Characteristics. Real with the same kind type parameter as Z.

25              Result Value. If Z has the value (x, y), the result has the value y.

26              Example.     AIMAG ((2.0, 3.0)) has the value 3.0.


27    13.7.7         AINT (A [, KIND])

28              Description. Truncation to a whole number.

29              Class. Elemental function.

30              Arguments.

31              A                 shall be of type real.

32              KIND (optional) shall be a scalar integer initialization expression.



      SEP 2002                                     WORKING DRAFT                                            297


      J3/02-007R3                                  WORKING DRAFT                                             SEP 2002



 1              Result Characteristics. The result is of type real. If KIND is present, the kind type parameter
 2              is that specified by the value of KIND; otherwise, the kind type parameter is that of A.

 3              Result Value. If |A| < 1, AINT (A) has the value 0; if |A|  1, AINT (A) has a value equal
 4              to the integer whose magnitude is the largest integer that does not exceed the magnitude of A
 5              and whose sign is the same as the sign of A.

 6              Examples.     AINT (2.783) has the value 2.0. AINT (�2.783) has the value �2.0.


 7    13.7.8         ALL (MASK [, DIM])

 8              Description. Determine whether all values are true in MASK along dimension DIM.

 9              Class. Transformational function.

10              Arguments.

11              MASK               shall be of type logical. It shall not be scalar.

                DIM (optional)     shall be scalar and of type integer with value in the range 1  DIM  n,
                                   where n is the rank of MASK. The corresponding actual argument shall not
12                                 be an optional dummy argument.

13              Result Characteristics. The result is of type logical with the same kind type parameter as
14              MASK. It is scalar if DIM is absent; otherwise, the result has rank n - 1 and shape (d1, d2,
15              ..., dDIM-1, dDIM+1, ..., dn) where (d1, d2, ..., dn) is the shape of MASK.

16              Result Value.

17              Case (i):     The result of ALL (MASK) has the value true if all elements of MASK are true
18                            or if MASK has size zero, and the result has value false if any element of MASK
19                            is false.

20              Case (ii):    If MASK has rank one, ALL(MASK,DIM) is equal to ALL(MASK). Otherwise,
21                            the value of element (s1, s2, . . . , sDIM-1, sDIM+1, . . . , sn) of ALL (MASK, DIM)
22                            is equal to ALL (MASK (s1, s2, . . . , sDIM-1, :, sDIM+1, ..., sn)).

23              Examples.

24              Case (i):     The value of ALL ((/ .TRUE., .FALSE., .TRUE. /)) is false.

                                                   1    3    5                          0    3    5
                Case (ii):    If B is the array                   and C is the array                   then ALL (B /= C,
25                                                 2    4    6                          7    4    8
26                            DIM = 1) is [true, false, false] and ALL (B /= C, DIM = 2) is [false, false].


27    13.7.9         ALLOCATED (ARRAY) or ALLOCATED (SCALAR)

28              Description. Indicate whether an allocatable variable is allocated.

29              Class. Inquiry function.

30              Arguments.

31              ARRAY              shall be an allocatable array.

32              SCALAR             shall be an allocatable scalar.

33              Result Characteristics. Default logical scalar.

34              Result Value. The result has the value true if the argument (ARRAY or SCALAR) is allocated
35              and has the value false if the argument is unallocated.



      298                                   WORKING DRAFT                                                    SEP 2002


      SEP 2002                            WORKING DRAFT                                              J3/02-007R3


 1    13.7.10     ANINT (A [, KIND])

 2          Description. Nearest whole number.

 3          Class. Elemental function.

 4          Arguments.

 5          A                  shall be of type real.

 6          KIND (optional) shall be a scalar integer initialization expression.

 7          Result Characteristics. The result is of type real. If KIND is present, the kind type parameter
 8          is that specified by the value of KIND; otherwise, the kind type parameter is that of A.

 9          Result Value. The result is the integer nearest A, or if there are two integers equally near A,
10          the result is whichever such integer has the greater magnitude.

11          Examples.     ANINT (2.783) has the value 3.0. ANINT (�2.783) has the value �3.0.


12    13.7.11     ANY (MASK [, DIM])

13          Description. Determine whether any value is true in MASK along dimension DIM.

14          Class. Transformational function.

15          Arguments.

16          MASK               shall be of type logical. It shall not be scalar.

            DIM (optional)     shall be scalar and of type integer with a value in the range 1  DIM  n,
                               where n is the rank of MASK. The corresponding actual argument shall not
17                             be an optional dummy argument.

18          Result Characteristics. The result is of type logical with the same kind type parameter as
19          MASK. It is scalar if DIM is absent; otherwise, the result has rank n - 1 and shape (d1, d2,
20          ..., dDIM-1, dDIM+1, ..., dn) where (d1, d2, ..., dn) is the shape of MASK.

21          Result Value.

22          Case (i):     The result of ANY (MASK) has the value true if any element of MASK is true
23                        and has the value false if no elements are true or if MASK has size zero.

24          Case (ii):    If MASK has rank one, ANY(MASK,DIM) is equal to ANY(MASK). Otherwise,
25                        the value of element (s1, s2, . . . , sDIM-1, sDIM+1, . . . , sn) of ANY(MASK, DIM)
26                        is equal to ANY(MASK (s1, s2, . . . , sDIM-1, :, sDIM+1, . . . , sn)).

27          Examples.

28          Case (i):     The value of ANY ((/ .TRUE., .FALSE., .TRUE. /)) is true.

                                               1    3    5                          0    3    5
            Case (ii):    If B is the array                   and C is the array                   then ANY(B /= C,
29                                             2    4    6                          7    4    8
30                        DIM = 1) is [true, false, true] and ANY(B /= C, DIM = 2) is [true, true].


31    13.7.12     ASIN (X)

32          Description. Arcsine (inverse sine) function.

33          Class. Elemental function.




      SEP 2002                                      WORKING DRAFT                                              299


      J3/02-007R3                                    WORKING DRAFT                                       SEP 2002



 1           Argument.       X shall be of type real. Its value shall satisfy the inequality |X|  1.

 2           Result Characteristics. Same as X.

 3           Result Value. The result has a value equal to a processor-dependent approximation to arc-
 4           sin(X), expressed in radians. It lies in the range -/2  ASIN(X)  /2.

 5           Example.       ASIN (0.84147098) has the value 1.0 (approximately).


 6    13.7.13     ASSOCIATED (POINTER [, TARGET])

 7           Description. Returns the association status of its pointer argument or indicates whether the
 8           pointer is associated with the target.

 9           Class. Inquiry function.

10           Arguments.

             POINTER             shall be a pointer. It may be of any type or may be a procedure pointer. Its
11                               pointer association status shall not be undefined.

             TARGET              shall be allowable as the data-target or proc-target in a pointer assignment
             (optional)          statement (7.4.2) in which POINTER is pointer-object . If TARGET is a
12                               pointer then its pointer association status shall not be undefined.

13           Result Characteristics. Default logical scalar.

14           Result Value.

15           Case (i):       If TARGET is absent, the result is true if POINTER is associated with a target
16                           and false if it is not.

17           Case (ii):      If TARGET is present and is a procedure, the result is true if POINTER is
18                           associated with TARGET.

19           Case (iii):     If TARGET is present and is a procedure pointer, the result is true if POINTER
20                           and TARGET are associated with the same procedure. If either POINTER or
21                           TARGET is disassociated, the result is false.

22           Case (iv):      If TARGET is present and is a scalar target, the result is true if TARGET is not a
23                           zero-sized storage sequence and the target associated with POINTER occupies the
24                           same storage units as TARGET. Otherwise, the result is false. If the POINTER
25                           is disassociated, the result is false.

26           Case (v):       If TARGET is present and is an array target, the result is true if the target
27                           associated with POINTER and TARGET have the same shape, are neither of
28                           size zero nor arrays whose elements are zero-sized storage sequences, and occupy
29                           the same storage units in array element order. Otherwise, the result is false. If
30                           POINTER is disassociated, the result is false.

31           Case (vi):      If TARGET is present and is a scalar pointer, the result is true if the target
32                           associated with POINTER and the target associated with TARGET are not zero-
33                           sized storage sequences and they occupy the same storage units. Otherwise, the
34                           result is false. If either POINTER or TARGET is disassociated, the result is
35                           false.

36           Case (vii):     If TARGET is present and is an array pointer, the result is true if the target
37                           associated with POINTER and the target associated with TARGET have the
38                           same shape, are neither of size zero nor arrays whose elements are zero-sized
39                           storage sequences, and occupy the same storage units in array element order.
40                           Otherwise, the result is false. If either POINTER or TARGET is disassociated,
41                           the result is false.



      300                                  WORKING DRAFT                                                 SEP 2002


      SEP 2002                                      WORKING DRAFT                                      J3/02-007R3



 1          Examples. ASSOCIATED (CURRENT, HEAD) is true if CURRENT is associated with the
 2          target HEAD. After the execution of

 3                A PART => A (:N)

 4          ASSOCIATED (A PART, A) is true if N is equal to UBOUND (A, DIM = 1).                              After the
 5          execution of

 6                NULLIFY (CUR); NULLIFY (TOP)

 7          ASSOCIATED (CUR, TOP) is false.


 8    13.7.14          ATAN (X)

 9          Description. Arctangent (inverse tangent) function.

10          Class. Elemental function.

11          Argument.               X shall be of type real.

12          Result Characteristics. Same as X.

13          Result Value. The result has a value equal to a processor-dependent approximation to arc-
14          tan(X), expressed in radians, that lies in the range -/2  ATAN(X)  /2.

15          Example.               ATAN (1.5574077) has the value 1.0 (approximately).


16    13.7.15          ATAN2 (Y, X)

17          Description. Arctangent (inverse tangent) function. The result is the principal value of the
18          argument of the nonzero complex number (X, Y).

19          Class. Elemental function.

20          Arguments.

21          Y                            shall be of type real.

            X                            shall be of the same type and kind type parameter as Y. If Y has the value
22                                       zero, X shall not have the value zero.

23          Result Characteristics. Same as X.

24          Result Value. The result has a value equal to a processor-dependent approximation to the
25          principal value of the argument of the complex number (X, Y), expressed in radians. It lies in
26          the range - < ATAN2(Y,X)   and is equal to a processor-dependent approximation to a
27          value of arctan(Y/X) if X = 0. If Y > 0, the result is positive. If Y = 0, the result is zero if
28          X > 0 and the result is  if X < 0. If Y < 0, the result is negative. If X = 0, the absolute value
29          of the result is /2.

30          Examples.               ATAN2 (1.5574077, 1.0) has the value 1.0 (approximately). If Y has the value
                 1       1                                      -1    1
                                    and X has the value                    , the value of ATAN2 (Y, X) is approximately
31               -1     -1                                      -1    1
                 3           
                  4           4
                 -3                .
32                       - 
                  4           4


33    13.7.16          BIT SIZE (I)




      SEP 2002                                             WORKING DRAFT                                          301


      J3/02-007R3                                     WORKING DRAFT                                         SEP 2002



 1           Description. Returns the number of bits z defined by the model of 13.3.

 2           Class. Inquiry function.

 3           Argument.      I shall be of type integer. It may be a scalar or an array.

 4           Result Characteristics. Scalar integer with the same kind type parameter as I.

 5           Result Value. The result has the value of the number of bits z of the model integer defined
 6           for bit manipulation contexts in 13.3.

 7           Example.     BIT SIZE (1) has the value 32 if z of the model is 32.


 8    13.7.17       BTEST (I, POS)

 9           Description. Tests a bit of an integer value.

10           Class. Elemental function.

11           Arguments.

12           I                  shall be of type integer.

13           POS                shall be of type integer. It shall be nonnegative and be less than BIT SIZE (I).

14           Result Characteristics. Default logical.

15           Result Value. The result has the value true if bit POS of I has the value 1 and has the value
16           false if bit POS of I has the value 0. The model for the interpretation of an integer value as a
17           sequence of bits is in 13.3.

                                                                                             1     2
             Examples.       BTEST (8, 3) has the value true. If A has the value                        , the value of
18                                                                                           3     4
                                  false      false                                        true     false
             BTEST (A, 2) is                          and the value of BTEST (2, A) is                       .
19                                false      true                                         false    false


20    13.7.18       CEILING (A [, KIND])

21           Description. Returns the least integer greater than or equal to its argument.

22           Class. Elemental function.

23           Arguments.

24           A                  shall be of type real.

25           KIND (optional) shall be a scalar integer initialization expression.

26           Result Characteristics. Integer. If KIND is present, the kind type parameter is that specified
27           by the value of KIND; otherwise, the kind type parameter is that of default integer type.

28           Result Value. The result has a value equal to the least integer greater than or equal to A.

29           Examples.     CEILING (3.7) has the value 4. CEILING (�3.7) has the value �3.


30    13.7.19       CHAR (I [, KIND])

31           Description. Returns the character in a given position of the processor collating sequence
32           associated with the specified kind type parameter. It is the inverse of the ICHAR function.



      302                                    WORKING DRAFT                                                  SEP 2002


      SEP 2002                               WORKING DRAFT                                        J3/02-007R3



 1          Class. Elemental function.

 2          Arguments.

            I                     shall be of type integer with a value in the range 0  I  n - 1, where n is the
                                  number of characters in the collating sequence associated with the specified
 3                                kind type parameter.

 4          KIND (optional) shall be a scalar integer initialization expression.

 5          Result Characteristics. Character of length one. If KIND is present, the kind type parameter
 6          is that specified by the value of KIND; otherwise, the kind type parameter is that of default
 7          character type.

 8          Result Value. The result is the character in position I of the collating sequence associated
 9          with the specified kind type parameter. ICHAR (CHAR (I, KIND (C))) shall have the value I
10          for 0  I  n - 1 and CHAR (ICHAR (C), KIND (C)) shall have the value C for any character
11          C capable of representation in the processor.

12          Example.        CHAR (88) has the value 'X' on a processor using the ASCII collating sequence.


13    13.7.20     CMPLX (X [, Y, KIND])

14          Description. Convert to complex type.

15          Class. Elemental function.

16          Arguments.

17          X                     shall be of type integer, real, or complex, or a boz-literal-constant .

            Y (optional)          shall be of type integer or real, or a boz-literal-constant . If X is of type
                                  complex, Y shall not be present, nor shall Y be associated with an optional
18                                dummy argument.

19          KIND (optional) shall be a scalar integer initialization expression.

20          Result Characteristics. The result is of type complex. If KIND is present, the kind type
21          parameter is that specified by the value of KIND; otherwise, the kind type parameter is that of
22          default real type.

23          Result Value. If Y is absent and X is not complex, it is as if Y were present with the value
24          zero. If X is complex, it is as if X were real with the value REAL (X, KIND) and Y were present
25          with the value AIMAG (X, KIND). CMPLX (X, Y, KIND) has the complex value whose real
26          part is REAL (X, KIND) and whose imaginary part is REAL (Y, KIND).

27          Example.        CMPLX (�3) has the value (�3.0, 0.0).


28    13.7.21     COMMAND ARGUMENT COUNT ()

29          Description. Returns the number of command arguments.

30          Class. Inquiry function.

31          Arguments. None.

32          Result Characteristics. Scalar default integer.

33          Result Value. The result value is equal to the number of command arguments available.



      SEP 2002                                     WORKING DRAFT                                             303


      J3/02-007R3                               WORKING DRAFT                                       SEP 2002



 1           If there are no command arguments available or if the processor does not support command
 2           arguments, then the result value is 0. If the processor has a concept of a command name, the
 3           command name does not count as one of the command arguments.

 4           Example.     See 13.7.42.


 5    13.7.22     CONJG (Z)

 6           Description. Conjugate of a complex number.

 7           Class. Elemental function.

 8           Argument.      Z shall be of type complex.

 9           Result Characteristics. Same as Z.

10           Result Value. If Z has the value (x, y), the result has the value (x, -y).

11           Example.     CONJG ((2.0, 3.0)) has the value (2.0, �3.0).


12    13.7.23     COS (X)

13           Description. Cosine function.

14           Class. Elemental function.

15           Argument.      X shall be of type real or complex.

16           Result Characteristics. Same as X.

17           Result Value. The result has a value equal to a processor-dependent approximation to cos(X).
18           If X is of type real, it is regarded as a value in radians. If X is of type complex, its real part is
19           regarded as a value in radians.

20           Example.     COS (1.0) has the value 0.54030231 (approximately).


21    13.7.24     COSH (X)

22           Description. Hyperbolic cosine function.

23           Class. Elemental function.

24           Argument.      X shall be of type real.

25           Result Characteristics. Same as X.

26           Result Value. The result has a value equal to a processor-dependent approximation to cosh(X).

27           Example.     COSH (1.0) has the value 1.5430806 (approximately).


28    13.7.25     COUNT (MASK [, DIM, KIND])

29           Description. Count the number of true elements of MASK along dimension DIM.

30           Class. Transformational function.

31           Arguments.

32           MASK               shall be of type logical. It shall not be scalar.




      304                                 WORKING DRAFT                                             SEP 2002


      SEP 2002                                WORKING DRAFT                                                  J3/02-007R3



            DIM (optional)        shall be scalar and of type integer with a value in the range 1  DIM  n,
                                  where n is the rank of MASK. The corresponding actual argument shall not
 1                                be an optional dummy argument.

 2          KIND (optional) shall be a scalar integer initialization expression.

 3          Result Characteristics. Integer. If KIND is present, the kind type parameter is that spec-
 4          ified by the value of KIND; otherwise the kind type parameter is that of default integer type.
 5          The result is scalar if DIM is absent; otherwise, the result has rank n - 1 and shape (d1, d2,
 6          ..., dDIM-1, dDIM+1, ..., dn) where (d1, d2, ..., dn) is the shape of MASK.

 7          Result Value.

 8          Case (i):         The result of COUNT (MASK) has a value equal to the number of true elements
 9                            of MASK or has the value zero if MASK has size zero.

10          Case (ii):        If MASK has rank one, COUNT (MASK, DIM) has a value equal to that of
11                            COUNT (MASK). Otherwise, the value of element (s1, s2, ..., sDIM-1, sDIM+1,
12                            ..., sn) of COUNT (MASK, DIM) is equal to COUNT (MASK (s1, s2, ..., sDIM-1,
13                            :, sDIM+1, ..., sn)).

14          Examples.

15          Case (i):         The value of COUNT ((/ .TRUE., .FALSE., .TRUE. /)) is 2.

                                                       1    3    5                          0    3    5
            Case (ii):        If B is the array                       and C is the array                   , COUNT (B /= C,
16                                                     2    4    6                          7    4    8
17                            DIM = 1) is [2, 0, 1] and COUNT (B /= C, DIM = 2) is [1, 2].


18    13.7.26      CPU TIME (TIME)

19          Description. Returns the processor time.

20          Class. Subroutine.

21          Argument. TIME shall be scalar and of type real. It is an INTENT(OUT) argument that is
22          assigned a processor-dependent approximation to the processor time in seconds. If the processor
23          cannot return a meaningful time, a processor-dependent negative value is returned.

24          Example.



25               REAL T1, T2

26               ...

27               CALL CPU TIME(T1)

28               ...      ! Code to be timed.

29               CALL CPU TIME(T2)

30               WRITE (*,*) 'Time taken by code was ', T2-T1, ' seconds'



31          writes the processor time taken by a piece of code.

         NOTE 13.7

         A processor for which a single result is inadequate (for example, a parallel processor) might choose
         to provide an additional version for which time is an array.

         The exact definition of time is left imprecise because of the variability in what different processors





      SEP 2002                                              WORKING DRAFT                                              305


      J3/02-007R3                                 WORKING DRAFT                                                      SEP 2002



             NOTE 13.7 (cont.)

             are able to provide. The primary purpose is to compare different algorithms on the same processor
             or discover which parts of a calculation are the most expensive.

             The start time is left imprecise because the purpose is to time sections of code, as in the example.

             Most computer systems have multiple concepts of time. One common concept is that of time
             expended by the processor for a given program. This may or may not include system overhead,
             and has no obvious connection to elapsed "wall clock" time.


 1    13.7.27        CSHIFT (ARRAY, SHIFT [, DIM])

 2              Description. Perform a circular shift on an array expression of rank one or perform circular
 3              shifts on all the complete rank one sections along a given dimension of an array expression of
 4              rank two or greater. Elements shifted out at one end of a section are shifted in at the other end.
 5              Different sections may be shifted by different amounts and in different directions.

 6              Class. Transformational function.

 7              Arguments.

 8              ARRAY               may be of any type. It shall not be scalar.

                SHIFT               shall be of type integer and shall be scalar if ARRAY has rank one; otherwise,
                                    it shall be scalar or of rank n - 1 and of shape (d1, d2, ..., dDIM-1, dDIM+1,
 9                                  ..., dn) where (d1, d2, ..., dn) is the shape of ARRAY.

                DIM (optional)      shall be a scalar and of type integer with a value in the range 1  DIM  n,
                                    where n is the rank of ARRAY. If DIM is omitted, it is as if it were present
10                                  with the value 1.

11              Result Characteristics. The result is of the type and type parameters of ARRAY, and has
12              the shape of ARRAY.

13              Result Value.

14              Case (i):      If ARRAY has rank one, element i of the result is ARRAY (1 + MODULO (i +
15                             SHIFT � 1, SIZE (ARRAY))).

16              Case (ii):     If ARRAY has rank greater than one, section (s1, s2, ..., sDIM-1, :, sDIM+1, ....,
17                             sn) of the result has a value equal to CSHIFT (ARRAY (s1, s2, ..., sDIM-1, :,
18                             sDIM+1, ...., sn), sh, 1), where sh is SHIFT or SHIFT (s1, s2, ..., sDIM-1, sDIM+1,
19                             ..., sn).

20              Examples.

21              Case (i):      If V is the array [1, 2, 3, 4, 5, 6], the effect of shifting V circularly to the left by
22                             two positions is achieved by CSHIFT (V, SHIFT = 2) which has the value [3, 4,
23                             5, 6, 1, 2]; CSHIFT (V, SHIFT = �2) achieves a circular shift to the right by two
24                             positions and has the value [5, 6, 1, 2, 3, 4].

25              Case (ii):     The rows of an array of rank two may all be shifted by the same amount or by
                                                                       1 2 3 
                               different amounts. If M is the array         4         5    6
                                                                                              , the value of
26                                                                         7         8    9
                                                                                 3 1 2 
                               CSHIFT (M, SHIFT = �1, DIM = 2) is                    6    4      5
                                                                                                     , and the value of
27                                                                                   9    7      8




      306                                   WORKING DRAFT                                                            SEP 2002


      SEP 2002                                WORKING DRAFT                                         J3/02-007R3


                                                                                 3 1 2 
                           CSHIFT (M, SHIFT = (/ �1, 1, 0 /), DIM = 2) is            5    6    4
                                                                                                   .
 1                                                                                   7    8    9


 2    13.7.28      DATE AND TIME ([DATE, TIME, ZONE, VALUES])

 3          Description. Returns data about the real-time clock and date in a form compatible with the
 4          representations defined in ISO 8601:1988.

 5          Class. Subroutine.

 6          Arguments.

            DATE (optional) shall be scalar and of type default character. It is an INTENT (OUT) ar-
                               gument. It is assigned a value of the form CCYYMMDD, where CC is the
                               century, YY is the year within the century, MM is the month within the year,
                               and DD is the day within the month. If there is no date available, DATE is
 7                             assigned all blanks.

            TIME (optional) shall be scalar and of type default character. It is an INTENT (OUT) argu-
                               ment. It is assigned a value of the form hhmmss.sss, where hh is the hour
                               of the day, mm is the minutes of the hour, and ss.sss is the seconds and
                               milliseconds of the minute. If there is no clock available, TIME is assigned
 8                             all blanks.

            ZONE (optional) shall be scalar and of type default character. It is an INTENT (OUT) argu-
                               ment. It is assigned a value of the form +hhmm or -hhmm, where hh and mm
                               are the time difference with respect to Coordinated Universal Time (UTC) in
                               hours and minutes, respectively. If this information is not available, ZONE
 9                             is assigned all blanks.

            VALUES             shall be of type default integer and of rank one. It is an INTENT (OUT)
            (optional)         argument. Its size shall be at least 8. The values returned in VALUES are
10                             as follows:

                 VALUES (1)    the year, including the century (for example, 1990), or �HUGE (0) if there is
11                             no date available;

12               VALUES (2)    the month of the year, or �HUGE (0) if there is no date available;

13               VALUES (3)    the day of the month, or �HUGE (0) if there is no date available;

                 VALUES (4)    the time difference with respect to Coordinated Universal Time (UTC) in
14                             minutes, or �HUGE (0) if this information is not available;

15               VALUES (5)    the hour of the day, in the range of 0 to 23, or �HUGE (0) if there is no clock;

                 VALUES (6)    the minutes of the hour, in the range 0 to 59, or �HUGE (0) if there is no
16                             clock;

                 VALUES (7)    the seconds of the minute, in the range 0 to 60, or �HUGE (0) if there is no
17                             clock;

                 VALUES (8)    the milliseconds of the second, in the range 0 to 999, or �HUGE (0) if there
18                             is no clock.

19          Example.



20               INTEGER DATE_TIME (8)



      SEP 2002                                   WORKING DRAFT                                             307


      J3/02-007R3                                 WORKING DRAFT                                       SEP 2002



 1                   CHARACTER (LEN = 10) BIG_BEN (3)

 2                   CALL DATE_AND_TIME (BIG_BEN (1), BIG_BEN (2),           &

 3                                           BIG_BEN (3), DATE_TIME)



 4              If run in Geneva, Switzerland on April 12, 1985 at 15:27:35.5 with a system configured for the
 5              local time zone, this sample would have assigned the value 19850412 to BIG BEN (1), the value
 6              152735.500 to BIG BEN (2), the value +0100 to BIG BEN (3), and the value (/ 1985, 4, 12,
 7              60, 15, 27, 35, 500 /) to DATE TIME.

             NOTE 13.8

             UTC is defined by ISO 8601:1988.


 8    13.7.29          DBLE (A)

 9              Description. Convert to double precision real type.

10              Class. Elemental function.

11              Argument.     A shall be of type integer, real, or complex, or a boz-literal-constant .

12              Result Characteristics. Double precision real.

13              Result Value. The result has the value REAL (A, KIND (0.0D0)).

14              Example.     DBLE (�3) has the value �3.0D0.


15    13.7.30          DIGITS (X)

16              Description. Returns the number of significant digits of the model representing numbers of
17              the same type and kind type parameter as the argument.

18              Class. Inquiry function.

19              Argument.     X shall be of type integer or real. It may be a scalar or an array.

20              Result Characteristics. Default integer scalar.

21              Result Value. The result has the value q if X is of type integer and p if X is of type real,
22              where q and p are as defined in 13.4 for the model representing numbers of the same type and
23              kind type parameter as X.

24              Example.     DIGITS (X) has the value 24 for real X whose model is as in Note 13.4.


25    13.7.31          DIM (X, Y)

26              Description. The difference X�Y if it is positive; otherwise zero.

27              Class. Elemental function.

28              Arguments.

29              X                  shall be of type integer or real.

30              Y                  shall be of the same type and kind type parameter as X.

31              Result Characteristics. Same as X.




      308                                    WORKING DRAFT                                            SEP 2002


      SEP 2002                             WORKING DRAFT                                       J3/02-007R3



 1          Result Value. The value of the result is X�Y if X>Y and zero otherwise.

 2          Example.       DIM (�3.0, 2.0) has the value 0.0.


 3    13.7.32     DOT PRODUCT (VECTOR A, VECTOR B)

 4          Description. Performs dot-product multiplication of numeric or logical vectors.

 5          Class. Transformational function.

 6          Arguments.

            VECTOR A            shall be of numeric type (integer, real, or complex) or of logical type. It shall
 7                              be a rank-one array.

            VECTOR B            shall be of numeric type if VECTOR A is of numeric type or of type logical
                                if VECTOR A is of type logical. It shall be a rank-one array. It shall be of
 8                              the same size as VECTOR A.

 9          Result Characteristics. If the arguments are of numeric type, the type and kind type pa-
10          rameter of the result are those of the expression VECTOR A * VECTOR B determined by the
11          types of the arguments according to 7.1.4.2. If the arguments are of type logical, the result is
12          of type logical with the kind type parameter of the expression VECTOR A .AND. VECTOR B
13          according to 7.1.4.2. The result is scalar.

14          Result Value.

15          Case (i):       If VECTOR A is of type integer or real, the result has the value SUM (VEC-
16                          TOR A*VECTOR B). If the vectors have size zero, the result has the value zero.

17          Case (ii):      If VECTOR A is of type complex, the result has the value SUM (CONJG (VEC-
18                          TOR A)*VECTOR B). If the vectors have size zero, the result has the value
19                          zero.

20          Case (iii):     If VECTOR A is of type logical, the result has the value ANY (VECTOR A
21                          .AND. VECTOR B). If the vectors have size zero, the result has the value false.


22          Example.       DOT PRODUCT ((/ 1, 2, 3 /), (/ 2, 3, 4 /)) has the value 20.


23    13.7.33     DPROD (X, Y)

24          Description. Double precision real product.

25          Class. Elemental function.

26          Arguments.

27          X                   shall be of type default real.

28          Y                   shall be of type default real.

29          Result Characteristics. Double precision real.

30          Result Value. The result has a value equal to a processor-dependent approximation to the
31          product of X and Y.

32          Example.       DPROD (�3.0, 2.0) has the value �6.0D0.


33    13.7.34     EOSHIFT (ARRAY, SHIFT [, BOUNDARY, DIM])




      SEP 2002                                   WORKING DRAFT                                              309


      J3/02-007R3                                      WORKING DRAFT                                       SEP 2002



 1           Description. Perform an end-off shift on an array expression of rank one or perform end-off
 2           shifts on all the complete rank-one sections along a given dimension of an array expression of
 3           rank two or greater. Elements are shifted off at one end of a section and copies of a boundary
 4           value are shifted in at the other end. Different sections may have different boundary values and
 5           may be shifted by different amounts and in different directions.

 6           Class. Transformational function.

 7           Arguments.

 8           ARRAY             may be of any type. It shall not be scalar.

             SHIFT             shall be of type integer and shall be scalar if ARRAY has rank one; otherwise,
                               it shall be scalar or of rank n - 1 and of shape (d1, d2, ..., dDIM-1, dDIM+1,
 9                             ..., dn) where (d1, d2, ..., dn) is the shape of ARRAY.

             BOUNDARY          shall be of the same type and type parameters as ARRAY and shall be scalar
             (optional)        if ARRAY has rank one; otherwise, it shall be either scalar or of rank n - 1
                               and of shape (d1, d2, ..., dDIM-1, dDIM+1, ..., dn). BOUNDARY may be
                               omitted for the types in the following table and, in this case, it is as if it were
                               present with the scalar value shown.


                                                        Type of ARRAY                 Value of BOUNDARY

                                                        Integer                       0
                                                        Real                          0.0
                                                        Complex                       (0.0, 0.0)
                                                        Logical                       false
10                                                      Character (len)               len blanks

             DIM (optional)    shall be scalar and of type integer with a value in the range 1  DIM  n,
                               where n is the rank of ARRAY. If DIM is omitted, it is as if it were present
11                             with the value 1.

12           Result Characteristics. The result has the type, type parameters, and shape of ARRAY.

13           Result Value. Element (s1, s2, ..., sn) of the result has the value ARRAY (s1, s2, ..., sDIM-1,
14           sDIM + sh, sDIM+1, ..., sn) where sh is SHIFT or SHIFT (s1, s2, ..., sDIM-1, sDIM+1, ..., sn)
15           provided the inequality LBOUND (ARRAY, DIM)  sDIM + sh  UBOUND (ARRAY, DIM)
16           holds and is otherwise BOUNDARY or BOUNDARY (s1, s2, ..., sDIM-1, sDIM+1, ..., sn).

17           Examples.

18           Case (i):     If V is the array [1, 2, 3, 4, 5, 6], the effect of shifting V end-off to the left by 3
19                         positions is achieved by EOSHIFT (V, SHIFT = 3), which has the value [4, 5,
20                         6, 0, 0, 0]; EOSHIFT (V, SHIFT = �2, BOUNDARY = 99) achieves an end-off
21                         shift to the right by 2 positions with the boundary value of 99 and has the value
22                         [99, 99, 1, 2, 3, 4].

23           Case (ii):    The rows of an array of rank two may all be shifted by the same amount or by
24                         different amounts and the boundary elements can be the same or different. If M is
                                         A       B    C 
                           the array         D    E     F
                                                            , then the value of EOSHIFT (M, SHIFT = �1, BOUND-
25                                           G    H     I
                                                              * A          B 
                           ARY = '*', DIM = 2) is                 *    D    E    , and the value of EOSHIFT (M, SHIFT =
                                                                                
26                                                                    G    H





      310                                    WORKING DRAFT                                                 SEP 2002


      SEP 2002                            WORKING DRAFT                                         J3/02-007R3


                                                                                               *    A    B 
                          (/ �1, 1, 0 /), BOUNDARY = (/ '*', '/', ' ?' /), DIM = 2) is          E    F    /
                                                                                                              .
 1                                                                                              G    H    I


 2    13.7.35     EPSILON (X)

 3          Description. Returns a positive model number that is almost negligible compared to unity of
 4          the model representing numbers of the same type and kind type parameter as the argument.

 5          Class. Inquiry function.

 6          Argument.     X shall be of type real. It may be a scalar or an array.

 7          Result Characteristics. Scalar of the same type and kind type parameter as X.

 8          Result Value. The result has the value b1-p where b and p are as defined in 13.4 for the model
 9          representing numbers of the same type and kind type parameter as X.

10          Example.     EPSILON (X) has the value 2-23 for real X whose model is as in Note 13.4.


11    13.7.36     EXP (X)

12          Description. Exponential.

13          Class. Elemental function.

14          Argument.     X shall be of type real or complex.

15          Result Characteristics. Same as X.

16          Result Value. The result has a value equal to a processor-dependent approximation to eX. If
17          X is of type complex, its imaginary part is regarded as a value in radians.

18          Example.     EXP (1.0) has the value 2.7182818 (approximately).


19    13.7.37     EXPONENT (X)

20          Description. Returns the exponent part of the argument when represented as a model number.

21          Class. Elemental function.

22          Argument.     X shall be of type real.

23          Result Characteristics. Default integer.

24          Result Value. The result has a value equal to the exponent e of the model representation
25          (13.4) for the value of X, provided X is nonzero and e is within the range for default integers.
26          EXPONENT (X) has the value zero if X is zero.

27          Examples.      EXPONENT (1.0) has the value 1 and EXPONENT (4.1) has the value 3 for
28          reals whose model is as in Note 13.4.


29    13.7.38     EXTENDS TYPE OF (A, MOLD)

30          Description. Inquires whether the dynamic type of A is an extension type (4.5.3) of the
31          dynamic type of MOLD.

32          Class. Inquiry function.




      SEP 2002                                 WORKING DRAFT                                                   311


      J3/02-007R3                                  WORKING DRAFT                                       SEP 2002



 1              Arguments.

                A                  shall be an object of extensible type. If it is a pointer, it shall not have an
 2                                 undefined association status.

                MOLD               shall be an object of extensible type. If it is a pointer, it shall not have an
 3                                 undefined association status.

 4              Result Characteristics. Default logical scalar.

 5              Result Value. If MOLD is unlimited polymorphic and is either a disassociated pointer or
 6              unallocated allocatable, the result is true; otherwise if A is unlimited polymorphic and is either
 7              a disassociated pointer or unallocated allocatable, the result is false; otherwise the result is true
 8              if and only if the dynamic type of A is an extension type of the dynamic type of MOLD.

             NOTE 13.9

             The dynamic type of a disassociated pointer or unallocated allocatable is its declared type.


 9    13.7.39        FLOOR (A [, KIND])

10              Description. Returns the greatest integer less than or equal to its argument.

11              Class. Elemental function.

12              Arguments.

13              A                  shall be of type real.

14              KIND (optional) shall be a scalar integer initialization expression.

15              Result Characteristics. Integer. If KIND is present, the kind type parameter is that specified
16              by the value of KIND; otherwise, the kind type parameter is that of default integer type.

17              Result Value. The result has a value equal to the greatest integer less than or equal to A.

18              Examples.     FLOOR (3.7) has the value 3. FLOOR (�3.7) has the value �4.


19    13.7.40        FRACTION (X)

20              Description. Returns the fractional part of the model representation of the argument value.

21              Class. Elemental function.

22              Argument.      X shall be of type real.

23              Result Characteristics. Same as X.

24              Result Value. The result has the value X � b-e, where b and e are as defined in 13.4 for the
25              model representation of X. If X has the value zero, the result has the value zero.

26              Example.     FRACTION (3.0) has the value 0.75 for reals whose model is as in Note 13.4.


27    13.7.41        GET COMMAND ([COMMAND, LENGTH, STATUS])

28              Description. Returns the entire command by which the program was invoked.

29              Class. Subroutine.

30              Arguments.



      312                                   WORKING DRAFT                                              SEP 2002


      SEP 2002                          WORKING DRAFT                                      J3/02-007R3



            COMMAND          shall be scalar and of type default character. It is an INTENT(OUT) argu-
            (optional)       ment. It is assigned the entire command by which the program was invoked.
 1                           If the command cannot be determined, COMMAND is assigned all blanks.

            LENGTH           shall be scalar and of type default integer. It is an INTENT(OUT) argument.
            (optional)       It is assigned the significant length of the command by which the program
                             was invoked. The significant length may include trailing blanks if the pro-
                             cessor allows commands with significant trailing blanks. This length does
                             not consider any possible truncation or padding in assigning the command
                             to the COMMAND argument; in fact the COMMAND argument need not
                             even be present. If the command length cannot be determined, a length of 0
 2                           is assigned.

            STATUS           shall be scalar and of type default integer. It is an INTENT(OUT) argument.
            (optional)       It is assigned the value -1 if the COMMAND argument is present and has
                             a length less than the significant length of the command. It is assigned a
                             processor-dependent positive value if the command retrieval fails. Otherwise
 3                           it is assigned the value 0.


      13.7.42     GET COMMAND ARGUMENT (NUMBER [, VALUE, LENGTH, STA-

 4                TUS])

 5          Description. Returns a command argument.

 6          Class. Subroutine.

 7          Arguments.

 8          NUMBER           shall be scalar and of type default integer. It is an INTENT(IN) argument.

                             It specifies the number of the command argument that the other arguments
                             give information about.        Useful values of NUMBER are those between 0
                             and the argument count returned by the COMMAND ARGUMENT COUNT
                             intrinsic. Other values are allowed, but will result in error status return (see
 9                           below).

                             Command argument 0 is defined to be the command name by which the
                             program was invoked if the processor has such a concept. It is allowed to
                             call the GET COMMAND ARGUMENT procedure for command argument
                             number 0, even if the processor does not define command names or other
10                           command arguments.

                             The remaining command arguments are numbered consecutively from 1 to
11                           the argument count in an order determined by the processor.

            VALUE            shall be scalar and of type default character. It is an INTENT(OUT) ar-
            (optional)       gument.    It is assigned the value of the command argument specified by
                             NUMBER. If the command argument value cannot be determined, VALUE
12                           is assigned all blanks.





      SEP 2002                                WORKING DRAFT                                             313


      J3/02-007R3                                  WORKING DRAFT                                   SEP 2002



                LENGTH              shall be scalar and of type default integer. It is an INTENT(OUT) argument.
                (optional)          It is assigned the significant length of the command argument specified by
                                    NUMBER. The significant length may include trailing blanks if the processor
                                    allows command arguments with significant trailing blanks. This length does
                                    not consider any possible truncation or padding in assigning the command
                                    argument value to the VALUE argument; in fact the VALUE argument need
                                    not even be present. If the command argument length cannot be determined,
 1                                  a length of 0 is assigned.

                STATUS              shall be scalar and of type default integer. It is an INTENT(OUT) argument.
                (optional)          It is assigned the value -1 if the VALUE argument is present and has a
                                    length less than the significant length of the command argument specified by
                                    NUMBER. It is assigned a processor-dependent positive value if the argument
 2                                  retrieval fails. Otherwise it is assigned the value 0.

             NOTE 13.10

             One possible reason for failure is that NUMBER is negative or greater than COMMAND ARGU-
             MENT COUNT().


 3              Example.



 4                    Program echo

 5                       integer :: i

 6                       character :: command*32, arg*128

 7                       call get_command_argument(0, command)

 8                       write (*,*) "Command name is: ", command

 9                       do i = 1 , command_argument_count()

10                            call get_command_argument(i, arg)

11                            write (*,*) "Argument ", i, " is ", arg

12                       end do

13                    end program echo



      13.7.43        GET ENVIRONMENT VARIABLE (NAME [, VALUE, LENGTH, STA-

14                   TUS, TRIM NAME])

15              Description. Gets the value of an environment variable.

16              Class. Subroutine.

17              Arguments.

                NAME                shall be a scalar and of type default character. It is an INTENT(IN) argu-
18                                  ment. The interpretation of case is processor dependent

                VALUE               shall be a scalar of type default character. It is an INTENT(OUT) argu-
                (optional)          ment. It is assigned the value of the environment variable specified by NAME.
                                    VALUE is assigned all blanks if the environment variable does not exist or
                                    does not have a value or if the processor does not support environment vari-
19                                  ables.

                LENGTH              shall be a scalar of type default integer. It is an INTENT(OUT) argument.
                (optional)          If the specified environment variable exists and has a value, LENGTH is set
20                                  to the length of that value. Otherwise LENGTH is set to 0.



      314                                     WORKING DRAFT                                        SEP 2002


      SEP 2002                            WORKING DRAFT                                      J3/02-007R3



            STATUS             shall be scalar and of type default integer. It is an INTENT(OUT) argument.
            (optional)         If the environment variable exists and either has no value or its value is
                               successfully assigned to VALUE, STATUS is set to zero. STATUS is set to -1
                               if the VALUE argument is present and has a length less than the significant
                               length of the environment variable. It is assigned the value 1 if the specified
                               environment variable does not exist, or 2 if the processor does not support
                               environment variables. Processor-dependent values greater than 2 may be
 1                             returned for other error conditions.

            TRIM NAME          shall be a scalar of type logical.      It is an INTENT(IN) argument.        If
            (optional)         TRIM NAME is present with the value false then trailing blanks in NAME
                               are considered significant if the processor supports trailing blanks in environ-
                               ment variable names. Otherwise trailing blanks in NAME are not considered
 2                             part of the environment variable's name.


 3    13.7.44     HUGE (X)

 4          Description. Returns the largest number of the model representing numbers of the same type
 5          and kind type parameter as the argument.

 6          Class. Inquiry function.

 7          Argument.      X shall be of type integer or real. It may be a scalar or an array.

 8          Result Characteristics. Scalar of the same type and kind type parameter as X.

 9          Result Value. The result has the value rq - 1 if X is of type integer and (1 - b-p)bemax if X is
10          of type real, where r, q, b, p, and emax are as defined in 13.4 for the model representing numbers
11          of the same type and kind type parameter as X.

12          Example. HUGE (X) has the value (1 - 2-24) � 2127 for real X whose model is as in Note 13.4.


13    13.7.45     IACHAR (C)

14          Description. Returns the position of a character in the ASCII collating sequence. This is the
15          inverse of the ACHAR function.

16          Class. Elemental function.

17          Argument.      C shall be of type default character and of length one.

18          Result Characteristics. Default integer.

19          Result Value. If C is in the collating sequence defined by the codes specified in ISO/IEC
20          646:1991 (International Reference Version), the result is the position of C in that sequence and
21          satisfies the inequality (0  IACHAR(C)  127). A processor-dependent value is returned if C
22          is not in the ASCII collating sequence. The results are consistent with the LGE, LGT, LLE,
23          and LLT lexical comparison functions. For example, if LLE (C, D) is true, IACHAR (C) <=
24          IACHAR (D) is true where C and D are any two characters representable by the processor.

25          Example.      IACHAR ('X') has the value 88.


26    13.7.46     IAND (I, J)

27          Description. Performs a bitwise AND.

28          Class. Elemental function.




      SEP 2002                                  WORKING DRAFT                                            315


      J3/02-007R3                              WORKING DRAFT                                      SEP 2002



 1           Arguments.

 2           I                  shall be of type integer.

 3           J                  shall be of type integer with the same kind type parameter as I.

 4           Result Characteristics. Same as I.

 5           Result Value. The result has the value obtained by combining I and J bit-by-bit according to
 6           the following truth table:


                                               I     J    IAND (I, J)

                                               1     1        1
                                               1     0        0
                                               0     1        0
                                               0     0        0



 7           The model for the interpretation of an integer value as a sequence of bits is in 13.3.

 8           Example.     IAND (1, 3) has the value 1.


 9    13.7.47       IBCLR (I, POS)

10           Description. Clears one bit to zero.

11           Class. Elemental function.

12           Arguments.

13           I                  shall be of type integer.

14           POS                shall be of type integer. It shall be nonnegative and less than BIT SIZE (I).

15           Result Characteristics. Same as I.

16           Result Value. The result has the value of the sequence of bits of I, except that bit POS is
17           zero. The model for the interpretation of an integer value as a sequence of bits is in 13.3.

18           Examples.      IBCLR (14, 1) has the result 12. If V has the value [1, 2, 3, 4], the value of
19           IBCLR (POS = V, I = 31) is [29, 27, 23, 15].


20    13.7.48       IBITS (I, POS, LEN)

21           Description. Extracts a sequence of bits.

22           Class. Elemental function.

23           Arguments.

24           I                  shall be of type integer.

             POS                shall be of type integer. It shall be nonnegative and POS + LEN shall be
25                              less than or equal to BIT SIZE (I).

26           LEN                shall be of type integer and nonnegative.

27           Result Characteristics. Same as I.




      316                                  WORKING DRAFT                                          SEP 2002


      SEP 2002                            WORKING DRAFT                                     J3/02-007R3



 1          Result Value. The result has the value of the sequence of LEN bits in I beginning at bit POS,
 2          right-adjusted and with all other bits zero. The model for the interpretation of an integer value
 3          as a sequence of bits is in 13.3.

 4          Example.     IBITS (14, 1, 3) has the value 7.


 5    13.7.49      IBSET (I, POS)

 6          Description. Sets one bit to one.

 7          Class. Elemental function.

 8          Arguments.

 9          I                  shall be of type integer.

10          POS                shall be of type integer. It shall be nonnegative and less than BIT SIZE (I).

11          Result Characteristics. Same as I.

12          Result Value. The result has the value of the sequence of bits of I, except that bit POS is one.
13          The model for the interpretation of an integer value as a sequence of bits is in 13.3.

14          Examples.       IBSET (12, 1) has the value 14. If V has the value [1, 2, 3, 4], the value of
15          IBSET (POS = V, I = 0) is [2, 4, 8, 16].


16    13.7.50      ICHAR (C [, KIND])

17          Description. Returns the position of a character in the processor collating sequence associated
18          with the kind type parameter of the character. This is the inverse of the CHAR function.

19          Class. Elemental function.

20          Arguments.

            C                  shall be of type character and of length one. Its value shall be that of a
21                             character capable of representation in the processor.

22          KIND (optional) shall be a scalar integer initialization expression.

23          Result Characteristics. Integer. If KIND is present, the kind type parameter is that specified
24          by the value of KIND; otherwise, the kind type parameter is that of default integer type.

25          Result Value. The result is the position of C in the processor collating sequence associated
26          with the kind type parameter of C and is in the range 0  ICHAR(C)  n - 1, where n is
27          the number of characters in the collating sequence. For any characters C and D capable of
28          representation in the processor, C <= D is true if and only if ICHAR (C) <= ICHAR (D) is true
29          and C == D is true if and only if ICHAR (C) == ICHAR (D) is true.

30          Example.      ICHAR ('X') has the value 88 on a processor using the ASCII collating sequence
31          for the default character type.


32    13.7.51      IEOR (I, J)

33          Description. Performs a bitwise exclusive OR.

34          Class. Elemental function.

35          Arguments.



      SEP 2002                                   WORKING DRAFT                                           317


      J3/02-007R3                              WORKING DRAFT                                     SEP 2002



 1           I                  shall be of type integer.

 2           J                  shall be of type integer with the same kind type parameter as I.

 3           Result Characteristics. Same as I.

 4           Result Value. The result has the value obtained by combining I and J bit-by-bit according to
 5           the following truth table:


                                               I    J      IEOR (I, J)

                                               1    1          0
                                               1    0          1
                                               0    1          1
                                               0    0          0



 6           The model for the interpretation of an integer value as a sequence of bits is in 13.3.

 7           Example.      IEOR (1, 3) has the value 2.


 8    13.7.52     INDEX (STRING, SUBSTRING [, BACK, KIND])

 9           Description. Returns the starting position of a substring within a string.

10           Class. Elemental function.

11           Arguments.

12           STRING             shall be of type character.

13           SUBSTRING          shall be of type character with the same kind type parameter as STRING.

14           BACK (optional) shall be of type logical.

15           KIND (optional) shall be a scalar integer initialization expression.

16           Result Characteristics. Integer. If KIND is present, the kind type parameter is that specified
17           by the value of KIND; otherwise the kind type parameter is that of default integer type.

18           Result Value.

19           Case (i):      If BACK is absent or has the value false, the result is the minimum positive value
20                          of I such that STRING (I : I + LEN (SUBSTRING) � 1) = SUBSTRING or zero if
21                          there is no such value. Zero is returned if LEN (STRING) < LEN (SUBSTRING)
22                          and one is returned if LEN (SUBSTRING) = 0.

23           Case (ii):     If BACK is present with the value true, the result is the maximum value of
24                          I less than or equal to LEN (STRING) � LEN (SUBSTRING) + 1 such that
25                          STRING (I : I + LEN (SUBSTRING) � 1) = SUBSTRING or zero if there is
26                          no such value. Zero is returned if LEN (STRING) < LEN (SUBSTRING) and
27                          LEN (STRING) + 1 is returned if LEN (SUBSTRING) = 0.


28           Examples.      INDEX ('FORTRAN', 'R') has the value 3.
29           INDEX ('FORTRAN', 'R', BACK = .TRUE.) has the value 5.


30    13.7.53     INT (A [, KIND])

31           Description. Convert to integer type.




      318                                  WORKING DRAFT                                         SEP 2002


      SEP 2002                             WORKING DRAFT                                          J3/02-007R3



 1          Class. Elemental function.

 2          Arguments.

 3          A                   shall be of type integer, real, or complex, or a boz-literal-constant .

 4          KIND (optional) shall be a scalar integer initialization expression.

 5          Result Characteristics. Integer. If KIND is present, the kind type parameter is that specified
 6          by the value of KIND; otherwise, the kind type parameter is that of default integer type.

 7          Result Value.

 8          Case (i):       If A is of type integer, INT (A) = A.

 9          Case (ii):      If A is of type real, there are two cases: if |A| < 1, INT (A) has the value 0; if
10                          |A|  1, INT (A) is the integer whose magnitude is the largest integer that does
11                          not exceed the magnitude of A and whose sign is the same as the sign of A.

12          Case (iii):     If A is of type complex, INT(A) = INT(REAL(A, KIND(A))).

13          Case (iv):      If A is a boz-literal-constant , it is treated as if it were an int-literal-constant with
14                          a kind-param that specifies the representation method with the largest decimal
15                          exponent range supported by the processor.


16          Example.       INT (�3.7) has the value �3.


17    13.7.54     IOR (I, J)

18          Description. Performs a bitwise inclusive OR.

19          Class. Elemental function.

20          Arguments.

21          I                   shall be of type integer.

22          J                   shall be of type integer with the same kind type parameter as I.

23          Result Characteristics. Same as I.

24          Result Value. The result has the value obtained by combining I and J bit-by-bit according to
25          the following truth table:


                                                 I    J    IOR (I, J)

                                                 1    1        1
                                                 1    0        1
                                                 0    1        1
                                                 0    0        0



26          The model for the interpretation of an integer value as a sequence of bits is in 13.3.

27          Example.       IOR (5, 3) has the value 7.


28    13.7.55     ISHFT (I, SHIFT)

29          Description. Performs a logical shift.

30          Class. Elemental function.




      SEP 2002                                    WORKING DRAFT                                                319


      J3/02-007R3                                  WORKING DRAFT                                   SEP 2002



 1           Arguments.

 2           I                      shall be of type integer.

             SHIFT                  shall be of type integer. The absolute value of SHIFT shall be less than or
 3                                  equal to BIT SIZE (I).

 4           Result Characteristics. Same as I.

 5           Result Value. The result has the value obtained by shifting the bits of I by SHIFT positions.
 6           If SHIFT is positive, the shift is to the left; if SHIFT is negative, the shift is to the right;
 7           and if SHIFT is zero, no shift is performed. Bits shifted out from the left or from the right, as
 8           appropriate, are lost. Zeros are shifted in from the opposite end. The model for the interpretation
 9           of an integer value as a sequence of bits is in 13.3.

10           Example.      ISHFT (3, 1) has the result 6.


11    13.7.56     ISHFTC (I, SHIFT [, SIZE])

12           Description. Performs a circular shift of the rightmost bits.

13           Class. Elemental function.

14           Arguments.

15           I                      shall be of type integer.

             SHIFT                  shall be of type integer. The absolute value of SHIFT shall be less than or
16                                  equal to SIZE.

             SIZE (optional)        shall be of type integer. The value of SIZE shall be positive and shall not
                                    exceed BIT SIZE (I). If SIZE is absent, it is as if it were present with the
17                                  value of BIT SIZE (I).

18           Result Characteristics. Same as I.

19           Result Value. The result has the value obtained by shifting the SIZE rightmost bits of I
20           circularly by SHIFT positions. If SHIFT is positive, the shift is to the left; if SHIFT is negative,
21           the shift is to the right; and if SHIFT is zero, no shift is performed. No bits are lost. The
22           unshifted bits are unaltered. The model for the interpretation of an integer value as a sequence
23           of bits is in 13.3.

24           Example.      ISHFTC (3, 2, 3) has the value 5.


25    13.7.57     KIND (X)

26           Description. Returns the value of the kind type parameter of X.

27           Class. Inquiry function.

28           Argument.       X may be of any intrinsic type. It may be a scalar or an array.

29           Result Characteristics. Default integer scalar.

30           Result Value. The result has a value equal to the kind type parameter value of X.

31           Example.      KIND (0.0) has the kind type parameter value of default real.


32    13.7.58     LBOUND (ARRAY [, DIM, KIND])



      320                                   WORKING DRAFT                                          SEP 2002


      SEP 2002                            WORKING DRAFT                                         J3/02-007R3



 1          Description. Returns all the lower bounds or a specified lower bound of an array.

 2          Class. Inquiry function.

 3          Arguments.

            ARRAY              may be of any type. It shall not be scalar. It shall not be an unallocated
 4                             allocatable or a pointer that is not associated.

            DIM (optional)     shall be scalar and of type integer with a value in the range 1  DIM  n,
                               where n is the rank of ARRAY. The corresponding actual argument shall not
 5                             be an optional dummy argument.

 6          KIND (optional) shall be a scalar integer initialization expression.

 7          Result Characteristics. Integer. If KIND is present, the kind type parameter is that specified
 8          by the value of KIND; otherwise the kind type parameter is that of default integer type. The
 9          result is scalar if DIM is present; otherwise, the result is an array of rank one and size n, where
10          n is the rank of ARRAY.

11          Result Value.

12          Case (i):      If ARRAY is a whole array or array structure component and either ARRAY is an
13                         assumed-size array of rank DIM or dimension DIM of ARRAY has nonzero extent,
14                         LBOUND (ARRAY, DIM) has a value equal to the lower bound for subscript DIM
15                         of ARRAY. Otherwise the result value is 1.

16          Case (ii):     LBOUND (ARRAY) has a value whose ith component is equal to LBOUND (AR-
17                         RAY, i), for i = 1, 2, ..., n, where n is the rank of ARRAY.


18          Examples.      If A is declared by the statement

19               REAL A (2:3, 7:10)

20          then LBOUND (A) is [2, 7] and LBOUND (A, DIM=2) is 7.


21    13.7.59        LEN (STRING [, KIND])

22          Description. Returns the length of a character entity.

23          Class. Inquiry function.

24          Arguments.

            STRING             shall be of type character. It may be a scalar or an array. If it is an unallocated
                               allocatable or a pointer that is not associated, its length type parameter shall
25                             not be deferred.

26          KIND (optional) shall be a scalar integer initialization expression.

27          Result Characteristics. Integer scalar. If KIND is present, the kind type parameter is that
28          specified by the value of KIND; otherwise the kind type parameter is that of default integer
29          type.

30          Result Value. The result has a value equal to the number of characters in STRING if it is
31          scalar or in an element of STRING if it is an array.

32          Example.      If C is declared by the statement

33               CHARACTER (11) C (100)




      SEP 2002                                     WORKING DRAFT                                             321


      J3/02-007R3                                    WORKING DRAFT                                   SEP 2002



 1              LEN (C) has the value 11.


 2    13.7.60        LEN TRIM (STRING [, KIND])

 3              Description. Returns the length of the character argument without counting trailing blank
 4              characters.

 5              Class. Elemental function.

 6              Arguments.

 7              STRING                 shall be of type character.

 8              KIND (optional) shall be a scalar integer initialization expression.

 9              Result Characteristics. Integer. If KIND is present, the kind type parameter is that specified
10              by the value of KIND; otherwise the kind type parameter is that of default integer type.

11              Result Value. The result has a value equal to the number of characters remaining after any
12              trailing blanks in STRING are removed. If the argument contains no nonblank characters, the
13              result is zero.

14              Examples.          LEN TRIM (' A B ') has the value 4 and LEN TRIM ('      ') has the value 0.


15    13.7.61        LGE (STRING A, STRING B)

16              Description. Test whether a string is lexically greater than or equal to another string, based
17              on the ASCII collating sequence.

18              Class. Elemental function.

19              Arguments.

20              STRING A               shall be of type default character.

21              STRING B               shall be of type default character.

22              Result Characteristics. Default logical.

23              Result Value. If the strings are of unequal length, the comparison is made as if the shorter
24              string were extended on the right with blanks to the length of the longer string. If either string
25              contains a character not in the ASCII character set, the result is processor dependent. The
26              result is true if the strings are equal or if STRING A follows STRING B in the ASCII collating
27              sequence; otherwise, the result is false.

             NOTE 13.11

             The result is true if both STRING A and STRING B are of zero length.


28              Example.       LGE ('ONE', 'TWO') has the value false.


29    13.7.62        LGT (STRING A, STRING B)

30              Description. Test whether a string is lexically greater than another string, based on the ASCII
31              collating sequence.

32              Class. Elemental function.

33              Arguments.



      322                                      WORKING DRAFT                                         SEP 2002


      SEP 2002                            WORKING DRAFT                                      J3/02-007R3



 1          STRING A            shall be of type default character.

 2          STRING B            shall be of type default character.

 3          Result Characteristics. Default logical.

 4          Result Value. If the strings are of unequal length, the comparison is made as if the shorter
 5          string were extended on the right with blanks to the length of the longer string. If either string
 6          contains a character not in the ASCII character set, the result is processor dependent. The
 7          result is true if STRING A follows STRING B in the ASCII collating sequence; otherwise, the
 8          result is false.

         NOTE 13.12

         The result is false if both STRING A and STRING B are of zero length.


 9          Example.      LGT ('ONE', 'TWO') has the value false.


10    13.7.63     LLE (STRING A, STRING B)

11          Description. Test whether a string is lexically less than or equal to another string, based on
12          the ASCII collating sequence.

13          Class. Elemental function.

14          Arguments.

15          STRING A            shall be of type default character.

16          STRING B            shall be of type default character.

17          Result Characteristics. Default logical.

18          Result Value. If the strings are of unequal length, the comparison is made as if the shorter
19          string were extended on the right with blanks to the length of the longer string. If either
20          string contains a character not in the ASCII character set, the result is processor dependent.
21          The result is true if the strings are equal or if STRING A precedes STRING B in the ASCII
22          collating sequence; otherwise, the result is false.

         NOTE 13.13

         The result is true if both STRING A and STRING B are of zero length.


23          Example.      LLE ('ONE', 'TWO') has the value true.


24    13.7.64     LLT (STRING A, STRING B)

25          Description. Test whether a string is lexically less than another string, based on the ASCII
26          collating sequence.

27          Class. Elemental function.

28          Arguments.

29          STRING A            shall be of type default character.

30          STRING B            shall be of type default character.

31          Result Characteristics. Default logical.



      SEP 2002                                   WORKING DRAFT                                           323


      J3/02-007R3                                      WORKING DRAFT                                       SEP 2002



 1              Result Value. If the strings are of unequal length, the comparison is made as if the shorter
 2              string were extended on the right with blanks to the length of the longer string. If either string
 3              contains a character not in the ASCII character set, the result is processor dependent. The
 4              result is true if STRING A precedes STRING B in the ASCII collating sequence; otherwise, the
 5              result is false.

             NOTE 13.14

             The result is false if both STRING A and STRING B are of zero length.


 6              Example.      LLT ('ONE', 'TWO') has the value true.


 7    13.7.65         LOG (X)

 8              Description. Natural logarithm.

 9              Class. Elemental function.

10              Argument.           X shall be of type real or complex. If X is real, its value shall be greater than
11              zero. If X is complex, its value shall not be zero.

12              Result Characteristics. Same as X.

13              Result Value. The result has a value equal to a processor-dependent approximation to log X.
                                                                                                                 e
14              A result of type complex is the principal value with imaginary part  in the range - <   .
15              The imaginary part of the result is  only when the real part of the argument is less than zero
16              and the imaginary part of the argument is zero.

17              Example.      LOG (10.0) has the value 2.3025851 (approximately).


18    13.7.66         LOG10 (X)

19              Description. Common logarithm.

20              Class. Elemental function.

21              Argument.           X shall be of type real. The value of X shall be greater than zero.

22              Result Characteristics. Same as X.

23              Result Value. The result has a value equal to a processor-dependent approximation to log X.
                                                                                                                10


24              Example.      LOG10 (10.0) has the value 1.0 (approximately).


25    13.7.67         LOGICAL (L [, KIND])

26              Description. Converts between kinds of logical.

27              Class. Elemental function.

28              Arguments.

29              L                       shall be of type logical.

30              KIND (optional) shall be a scalar integer initialization expression.

31              Result Characteristics. Logical. If KIND is present, the kind type parameter is that specified
32              by the value of KIND; otherwise, the kind type parameter is that of default logical.




      324                                        WORKING DRAFT                                             SEP 2002


      SEP 2002                                    WORKING DRAFT                                         J3/02-007R3



 1          Result Value. The value is that of L.

 2          Example.       LOGICAL (L .OR. .NOT. L) has the value true and is of type default logical,
 3          regardless of the kind type parameter of the logical variable L.


 4    13.7.68     MATMUL (MATRIX A, MATRIX B)

 5          Description. Performs matrix multiplication of numeric or logical matrices.

 6          Class. Transformational function.

 7          Arguments.

            MATRIX A            shall be of numeric type (integer, real, or complex) or of logical type. It shall
 8                              be an array of rank one or two.

            MATRIX B            shall be of numeric type if MATRIX A is of numeric type and of logical type
                                if MATRIX A is of logical type. It shall be an array of rank one or two. If
                                MATRIX A has rank one, MATRIX B shall have rank two. If MATRIX B
                                has rank one, MATRIX A shall have rank two. The size of the first (or only)
                                dimension of MATRIX B shall equal the size of the last (or only) dimension
 9                              of MATRIX A.

10          Result Characteristics. If the arguments are of numeric type, the type and kind type pa-
11          rameter of the result are determined by the types of the arguments as specified in 7.1.4.2 for
12          the * operator. If the arguments are of type logical, the result is of type logical with the kind
13          type parameter of the arguments as specified in 7.1.4.2 for the .AND. operator. The shape of
14          the result depends on the shapes of the arguments as follows:

15          Case (i):       If MATRIX A has shape (n, m) and MATRIX B has shape (m, k), the result has
16                          shape (n, k).

17          Case (ii):      If MATRIX A has shape (m) and MATRIX B has shape (m, k), the result has
18                          shape (k).

19          Case (iii):     If MATRIX A has shape (n, m) and MATRIX B has shape (m), the result has
20                          shape (n).


21          Result Value.

22          Case (i):       Element (i, j) of the result has the value SUM (MATRIX A (i, :) * MATRIX B (:,
23                          j)) if the arguments are of numeric type and has the value ANY (MATRIX A (i,
24                          :) .AND. MATRIX B (:, j)) if the arguments are of logical type.

25          Case (ii):      Element (j) of the result has the value SUM (MATRIX A (:) * MATRIX B (:,
26                          j)) if the arguments are of numeric type and has the value ANY (MATRIX A (:)
27                          .AND. MATRIX B (:, j)) if the arguments are of logical type.

28          Case (iii):     Element (i) of the result has the value SUM (MATRIX A (i, :) * MATRIX B (:))
29                          if the arguments are of numeric type and has the value ANY (MATRIX A (i, :)
30                          .AND. MATRIX B (:)) if the arguments are of logical type.


                                                                                     1 2 
                                                              1    2    3
            Examples.       Let A and B be the matrices                      and         2    3    ; let X and Y be the
                                                              2    3    4                         
31                                                                                       3    4
32          vectors [1, 2] and [1, 2, 3].

33          Case (i):       The result of MATMUL (A, B) is the matrix-matrix product AB with the value
                              14    20       .
34                            20    29





      SEP 2002                                       WORKING DRAFT                                                325


      J3/02-007R3                                WORKING DRAFT                                        SEP 2002



 1           Case (ii):     The result of MATMUL (X, A) is the vector-matrix product XA with the value
 2                          [5, 8, 11].

 3           Case (iii):    The result of MATMUL (A, Y) is the matrix-vector product AY with the value
 4                          [14, 20].


 5    13.7.69     MAX (A1, A2 [, A3, ...])

 6           Description. Maximum value.

 7           Class. Elemental function.

 8           Arguments.       The arguments shall all have the same type which shall be integer, real, or
 9           character and they shall all have the same kind type parameter.

10           Result Characteristics. The type and kind type parameter of the result are the same as those
11           of the arguments. For arguments of character type, the length of the result is the length of the
12           longest argument.

13           Result Value. The value of the result is that of the largest argument. For arguments of
14           character type, the result is the value that would be selected by application of intrinsic relational
15           operators; that is, the collating sequence for characters with the kind type parameter of the
16           arguments is applied. If the selected argument is shorter than the longest argument, the result
17           is extended with blanks on the right to the length of the longest argument.

18           Examples. MAX (�9.0, 7.0, 2.0) has the value 7.0, MAX ("Z", "BB") has the value "Z ", and
19           MAX ((/"A", "Z"/), (/"BB", "Y "/)) has the value (/"BB", "Z "/).


20    13.7.70     MAXEXPONENT (X)

21           Description. Returns the maximum exponent of the model representing numbers of the same
22           type and kind type parameter as the argument.

23           Class. Inquiry function.

24           Argument.      X shall be of type real. It may be a scalar or an array.

25           Result Characteristics. Default integer scalar.

26           Result Value. The result has the value emax, as defined in 13.4 for the model representing
27           numbers of the same type and kind type parameter as X.

28           Example. MAXEXPONENT (X) has the value 127 for real X whose model is as in Note 13.4.


      13.7.71     MAXLOC (ARRAY, DIM [, MASK, KIND]) or

29                MAXLOC (ARRAY [, MASK, KIND])

30           Description. Determine the location of the first element of ARRAY along dimension DIM
31           having the maximum value of the elements identified by MASK.

32           Class. Transformational function.

33           Arguments.

34           ARRAY                shall be of type integer, real, or character. It shall not be scalar.





      326                                  WORKING DRAFT                                              SEP 2002


      SEP 2002                                WORKING DRAFT                                     J3/02-007R3



            DIM                   shall be scalar and of type integer with a value in the range 1  DIM  n,
                                  where n is the rank of ARRAY. The corresponding actual argument shall not
 1                                be an optional dummy argument.

 2          MASK (optional) shall be of type logical and shall be conformable with ARRAY.

 3          KIND (optional) shall be a scalar integer initialization expression.

 4          Result Characteristics. Integer. If KIND is present, the kind type parameter is that specified
 5          by the value of KIND; otherwise the kind type parameter is that of default integer type. If DIM
 6          is absent, the result is an array of rank one and of size equal to the rank of ARRAY; otherwise,
 7          the result is of rank n - 1 and shape (d1, d2, ..., dDIM-1, dDIM+1, ..., dn), where (d1, d2, ..., dn)
 8          is the shape of ARRAY.

 9          Result Value.

10          Case (i):      The result of MAXLOC (ARRAY) is a rank-one array whose element values are
11                         the values of the subscripts of an element of ARRAY whose value equals the
12                         maximum value of all of the elements of ARRAY. The ith subscript returned lies
13                         in the range 1 to ei, where ei is the extent of the ith dimension of ARRAY. If
14                         more than one element has the maximum value, the element whose subscripts are
15                         returned is the first such element, taken in array element order. If ARRAY has
16                         size zero, all elements of the result are zero.

17          Case (ii):     The result of MAXLOC (ARRAY, MASK = MASK) is a rank-one array whose
18                         element values are the values of the subscripts of an element of ARRAY, corre-
19                         sponding to a true element of MASK, whose value equals the maximum value of
20                         all such elements of ARRAY. The ith subscript returned lies in the range 1 to
21                         ei, where ei is the extent of the ith dimension of ARRAY. If more than one such
22                         element has the maximum value, the element whose subscripts are returned is
23                         the first such element taken in array element order. If ARRAY has size zero or
24                         every element of MASK has the value false, all elements of the result are zero.

25          Case (iii):    If ARRAY has rank one, MAXLOC (ARRAY, DIM = DIM [, MASK = MASK])
26                         is a scalar whose value is equal to that of the first element of MAXLOC (ARRAY [,
27                         MASK = MASK]). Otherwise, the value of element (s1, s2, ..., sDIM-1, sDIM+1,
28                         ..., sn ) of the result is equal to

29                                  MAXLOC (ARRAY (s1, s2, ..., sDIM-1, :, sDIM+1, ..., sn), DIM=1
30                                  [, MASK = MASK (s1, s2, ..., sDIM-1, :, sDIM+1, ..., sn) ] ).


31          If ARRAY has type character, the result is the value that would be selected by application of
32          intrinsic relational operators; that is, the collating sequence for characters with the kind type
33          parameter of the arguments is applied.

34          Examples.

35          Case (i):      The value of MAXLOC ((/ 2, 6, 4, 6 /)) is [2].

                                                  0 -5         8     -3 
            Case (ii):     If A has the value         3    4    -1    2     , MAXLOC (A, MASK = A � 6) has the
                                                                           
36                                                    1    5    6     -4
37                         value [3, 2]. Note that this is independent of the declared lower bounds for A.

38          Case (iii):    The value of MAXLOC ((/ 5, -9, 3 /), DIM = 1) is 1.               If B has the value
                             1     3    -9    , MAXLOC (B, DIM = 1) is [2, 1, 2] and MAXLOC (B, DIM = 2)
39                           2     2    6
40                         is [2, 3]. Note that this is independent of the declared lower bounds for B.


41    13.7.72      MAXVAL (ARRAY, DIM [, MASK]) or MAXVAL (ARRAY [, MASK])



      SEP 2002                                        WORKING DRAFT                                         327


      J3/02-007R3                                WORKING DRAFT                                        SEP 2002



 1           Description. Maximum value of the elements of ARRAY along dimension DIM corresponding
 2           to the true elements of MASK.

 3           Class. Transformational function.

 4           Arguments.

 5           ARRAY                shall be of type integer, real, or character. It shall not be scalar.

             DIM                  shall be scalar and of type integer with a value in the range 1  DIM  n,
                                  where n is the rank of ARRAY. The corresponding actual argument shall not
 6                                be an optional dummy argument.

 7           MASK (optional) shall be of type logical and shall be conformable with ARRAY.

 8           Result Characteristics. The result is of the same type and type parameters as ARRAY. It is
 9           scalar if DIM is absent; otherwise, the result has rank n-1 and shape (d1, d2, ..., dDIM-1, dDIM+1,
10           ..., dn) where (d1, d2, ..., dn) is the shape of ARRAY.

11           Result Value.

12           Case (i):      The result of MAXVAL (ARRAY) has a value equal to the maximum value of
13                          all the elements of ARRAY if the size of ARRAY is not zero. If ARRAY has size
14                          zero and type integer or real, the result has the value of the negative number of
15                          the largest magnitude supported by the processor for numbers of the type and
16                          kind type parameter of ARRAY. If ARRAY has size zero and type character, the
17                          result has the value of a string of characters of length LEN (ARRAY), with each
18                          character equal to CHAR (0, KIND = KIND (ARRAY)).

19           Case (ii):     The result of MAXVAL (ARRAY, MASK = MASK) has a value equal to that of
20                          MAXVAL (PACK (ARRAY, MASK)).

21           Case (iii):    The result of MAXVAL (ARRAY, DIM = DIM [,MASK = MASK]) has a value
22                          equal to that of MAXVAL (ARRAY [,MASK = MASK]) if ARRAY has rank one.
23                          Otherwise, the value of element (s1, s2, ..., sDIM-1, sDIM+1, ..., sn) of the result
24                          is equal to

25                                  MAXVAL (ARRAY (s1, s2, ..., sDIM-1, :, sDIM+1, ..., sn)
26                                  [, MASK = MASK (s1, s2, ..., sDIM-1, :, sDIM+1, ..., sn) ] ).


27           If ARRAY has type character, the result is the value that would be selected by application of
28           intrinsic relational operators; that is, the collating sequence for characters with the kind type
29           parameter of the arguments is applied.

30           Examples.

31           Case (i):      The value of MAXVAL ((/ 1, 2, 3 /)) is 3.

32           Case (ii):     MAXVAL (C, MASK = C � 0.0) finds the maximum of the negative elements of
33                          C.
                                                   1    3    5
             Case (iii):    If B is the array                     , MAXVAL (B, DIM = 1) is [2, 4, 6] and MAX-
34                                                 2    4    6
35                          VAL (B, DIM = 2) is [5, 6].


36    13.7.73       MERGE (TSOURCE, FSOURCE, MASK)

37           Description. Choose alternative value according to the value of a mask.

38           Class. Elemental function.

39           Arguments.



      328                                  WORKING DRAFT                                              SEP 2002


      SEP 2002                                 WORKING DRAFT                                        J3/02-007R3



 1          TSOURCE              may be of any type.

 2          FSOURCE              shall be of the same type and type parameters as TSOURCE.

 3          MASK                 shall be of type logical.

 4          Result Characteristics. Same as TSOURCE.

 5          Result Value. The result is TSOURCE if MASK is true and FSOURCE otherwise.

                                                                1    6    5                              0    3    2
            Examples.      If TSOURCE is the array                             , FSOURCE is the array
 6                                                              2    4    6                              7    4    8
                                         T     .    T
            and MASK is the array                        , where "T" represents true and "." represents false, then
 7                                        .    .    T
                                                                     1    3    5
            MERGE (TSOURCE, FSOURCE, MASK) is                                       . The value of MERGE (1.0, 0.0,
 8                                                                   7    4    6
 9          K > 0) is 1.0 for K = 5 and 0.0 for K = �2.


10    13.7.74     MIN (A1, A2 [, A3, ...])

11          Description. Minimum value.

12          Class. Elemental function.

13          Arguments.       The arguments shall all be of the same type which shall be integer, real, or
14          character and they shall all have the same kind type parameter.

15          Result Characteristics. The type and kind type parameter of the result are the same as those
16          of the arguments. For arguments of character type, the length of the result is the length of the
17          longest argument.

18          Result Value.        The value of the result is that of the smallest argument.           For arguments
19          of character type, the result is the value that would be selected by application of intrinsic
20          relational operators; that is, the collating sequence for characters with the kind type parameter
21          of the arguments is applied. If the selected argument is shorter than the longest argument, the
22          result is extended with blanks on the right to the length of the longest argument.

23          Example. MIN (�9.0, 7.0, 2.0) has the value �9.0, MIN ("A", "YY") has the value "A ", and
24          MIN ((/"Z", "A"/), (/"YY", "B "/)) has the value (/"YY", "A "/).


25    13.7.75     MINEXPONENT (X)

26          Description. Returns the minimum (most negative) exponent of the model representing num-
27          bers of the same type and kind type parameter as the argument.

28          Class. Inquiry function.

29          Argument.     X shall be of type real. It may be a scalar or an array.

30          Result Characteristics. Default integer scalar.

31          Result Value. The result has the value emin, as defined in 13.4 for the model representing
32          numbers of the same type and kind type parameter as X.

33          Example. MINEXPONENT (X) has the value �126 for real X whose model is as in Note 13.4.


      13.7.76     MINLOC (ARRAY, DIM [, MASK, KIND]) or

34                MINLOC (ARRAY [, MASK, KIND])


      SEP 2002                                      WORKING DRAFT                                                  329


      J3/02-007R3                               WORKING DRAFT                                       SEP 2002



 1           Description. Determine the location of the first element of ARRAY along dimension DIM
 2           having the minimum value of the elements identified by MASK.

 3           Class. Transformational function.

 4           Arguments.

 5           ARRAY              shall be of type integer, real, or character. It shall not be scalar.

             DIM                shall be scalar and of type integer with a value in the range 1 < DIM  n,
                                where n is the rank of ARRAY. The corresponding actual argument shall not
 6                              be an optional dummy argument.

 7           MASK (optional) shall be of type logical and shall be conformable with ARRAY.

 8           KIND (optional) shall be a scalar integer initialization expression.

 9           Result Characteristics. Integer. If KIND is present, the kind type parameter is that specified
10           by the value of KIND; otherwise the kind type parameter is that of default integer type. If DIM
11           is absent, the result is an array of rank one and of size equal to the rank of ARRAY; otherwise,
12           the result is of rank n - 1 and shape (d1, d2, ..., dDIM-1, dDIM+1, ..., dn), where (d1, d2, ..., dn)
13           is the shape of ARRAY.

14           Result Value.

15           Case (i):      The result of MINLOC (ARRAY) is a rank-one array whose element values are
16                          the values of the subscripts of an element of ARRAY whose value equals the
17                          minimum value of all the elements of ARRAY. The ith subscript returned lies
18                          in the range 1 to ei, where ei is the extent of the ith dimension of ARRAY. If
19                          more than one element has the minimum value, the element whose subscripts are
20                          returned is the first such element, taken in array element order. If ARRAY has
21                          size zero, all elements of the result are zero.

22           Case (ii):     The result of MINLOC (ARRAY, MASK = MASK) is a rank-one array whose
23                          element values are the values of the subscripts of an element of ARRAY, corre-
24                          sponding to a true element of MASK, whose value equals the minimum value of
25                          all such elements of ARRAY. The ith subscript returned lies in the range 1 to
26                          ei, where ei is the extent of the ith dimension of ARRAY. If more than one such
27                          element has the minimum value, the element whose subscripts are returned is the
28                          first such element taken in array element order. If ARRAY has size zero or every
29                          element of MASK has the value false, all elements of the result are zero.

30           Case (iii):    If ARRAY has rank one, MINLOC (ARRAY, DIM = DIM [, MASK = MASK]) is
31                          a scalar whose value is equal to that of the first element of MINLOC (ARRAY [,
32                          MASK = MASK]). Otherwise, the value of element (s1, s2, ..., sDIM-1, sDIM+1,
33                          ..., sn) of the result is equal to

34                                 MINLOC (ARRAY (s1, s2, ..., sDIM-1, :, sDIM+1, ..., sn), DIM=1
35                                 [, MASK = MASK (s1, s2, ..., sDIM-1, :, sDIM+1, ..., sn) ] ).


36           If ARRAY has type character, the result is the value that would be selected by application of
37           intrinsic relational operators; that is, the collating sequence for characters with the kind type
38           parameter of the arguments is applied.

39           Examples.

40           Case (i):      The value of MINLOC ((/ 4, 3, 6, 3 /)) is [2].

                                                   0 -5          8     -3 
             Case (ii):     If A has the value         3    4     -1    2     , MINLOC (A, MASK = A
                                                                                                       > �4) has
41                                                     1    5     6     -4



      330                                WORKING DRAFT                                              SEP 2002


      SEP 2002                                WORKING DRAFT                                       J3/02-007R3



 1                         the value [1, 4]. Note that this is true even if A has a declared lower bound other
 2                         than 1.

 3          Case (iii):    The value of MINLOC ((/ 5, -9, 3 /), DIM = 1) is 2.                If B has the value
                             1     3    -9    , MINLOC (B, DIM = 1) is [1, 2, 1] and MINLOC (B, DIM = 2)
 4                           2     2    6
 5                         is [3, 1]. Note that this is true even if B has a declared lower bound other than 1.


 6    13.7.77      MINVAL (ARRAY, DIM [, MASK]) or MINVAL (ARRAY [, MASK])

 7          Description. Minimum value of all the elements of ARRAY along dimension DIM correspond-
 8          ing to true elements of MASK.

 9          Class. Transformational function.

10          Arguments.

11          ARRAY                 shall be of type integer, real, or character. It shall not be scalar.

            DIM                   shall be scalar and of type integer with a value in the range 1  DIM  n,
                                  where n is the rank of ARRAY. The corresponding actual argument shall not
12                                be an optional dummy argument.

13          MASK (optional) shall be of type logical and shall be conformable with ARRAY.

14          Result Characteristics. The result is of the same type and type parameters as ARRAY. It is
15          scalar if DIM is absent; otherwise, the result has rank n-1 and shape (d1, d2, ..., dDIM-1, dDIM+1,
16          ..., dn) where (d1, d2, ..., dn) is the shape of ARRAY.

17          Result Value.

18          Case (i):      The result of MINVAL (ARRAY) has a value equal to the minimum value of all
19                         the elements of ARRAY if the size of ARRAY is not zero. If ARRAY has size
20                         zero and type integer or real, the result has the value of the positive number of
21                         the largest magnitude supported by the processor for numbers of the type and
22                         kind type parameter of ARRAY. If ARRAY has size zero and type character,
23                         the result has the value of a string of characters of length LEN (ARRAY), with
24                         each character equal to CHAR (n - 1, KIND = KIND (ARRAY)), where n is the
25                         number of characters in the collating sequence for characters with the kind type
26                         parameter of ARRAY.

27          Case (ii):     The result of MINVAL (ARRAY, MASK = MASK) has a value equal to that of
28                         MINVAL (PACK (ARRAY, MASK)).

29          Case (iii):    The result of MINVAL (ARRAY, DIM = DIM [, MASK = MASK]) has a value
30                         equal to that of MINVAL (ARRAY [, MASK = MASK]) if ARRAY has rank one.
31                         Otherwise, the value of element (s1, s2, ..., sDIM-1, sDIM+1, ..., sn) of the result
32                         is equal to

33                                  MINVAL (ARRAY (s1, s2, ..., sDIM-1, :, sDIM+1, ..., sn)
34                                  [, MASK= MASK (s1, s2, ..., sDIM-1, :, sDIM+1, ..., sn) ] ).


35          If ARRAY has type character, the result is the value that would be selected by application of
36          intrinsic relational operators; that is, the collating sequence for characters with the kind type
37          parameter of the arguments is applied.

38          Examples.

39          Case (i):      The value of MINVAL ((/ 1, 2, 3 /)) is 1.





      SEP 2002                                     WORKING DRAFT                                           331


      J3/02-007R3                                WORKING DRAFT                                       SEP 2002



 1           Case (ii):     MINVAL (C, MASK = C > 0.0) forms the minimum of the positive elements of
 2                          C.

                                                 1    3    5
             Case (iii):    If B is the array                   , MINVAL (B, DIM = 1) is [1, 3, 5] and MINVAL (B,
 3                                               2    4    6
 4                          DIM = 2) is [1, 2].


 5    13.7.78     MOD (A, P)

 6           Description. Remainder function.

 7           Class. Elemental function.

 8           Arguments.

 9           A                    shall be of type integer or real.

10           P                    shall be of the same type and kind type parameter as A. P shall not be zero.

11           Result Characteristics. Same as A.

12           Result Value. The value of the result is A�INT (A/P) * P.

13           Examples.      MOD (3.0, 2.0) has the value 1.0 (approximately). MOD (8, 5) has the value 3.
14           MOD (�8, 5) has the value �3. MOD (8, �5) has the value 3. MOD (�8, �5) has the value �3.


15    13.7.79     MODULO (A, P)

16           Description. Modulo function.

17           Class. Elemental function.

18           Arguments.

19           A                    shall be of type integer or real.

20           P                    shall be of the same type and kind type parameter as A. P shall not be zero.

21           Result Characteristics. Same as A.

22           Result Value.

23           Case (i):      A is of type integer. MODULO (A, P) has the value R such that A = Q � P + R,
24                          where Q is an integer, the inequalities 0  R < P hold if P > 0, and P < R  0
25                          hold if P < 0.

26           Case (ii):     A is of type real. The value of the result is A � FLOOR (A / P) * P.


27           Examples.      MODULO (8, 5) has the value 3. MODULO (�8, 5) has the value 2. MOD-
28           ULO (8, �5) has the value �2. MODULO (�8, �5) has the value �3.


29    13.7.80     MVBITS (FROM, FROMPOS, LEN, TO, TOPOS)

30           Description. Copies a sequence of bits from one data object to another.

31           Class. Elemental subroutine.

32           Arguments.

33           FROM                 shall be of type integer. It is an INTENT (IN) argument.




      332                                 WORKING DRAFT                                              SEP 2002


      SEP 2002                            WORKING DRAFT                                     J3/02-007R3



            FROMPOS           shall be of type integer and nonnegative. It is an INTENT (IN) argument.
                              FROMPOS + LEN shall be less than or equal to BIT SIZE (FROM). The
                              model for the interpretation of an integer value as a sequence of bits is in
 1                            13.3.

 2          LEN               shall be of type integer and nonnegative. It is an INTENT (IN) argument.

            TO                shall be a variable of type integer with the same kind type parameter value
                              as FROM and may be associated with FROM (12.7.3. It is an INTENT (IN-
                              OUT) argument. TO is defined by copying the sequence of bits of length
                              LEN, starting at position FROMPOS of FROM to position TOPOS of TO.
                              No other bits of TO are altered. On return, the LEN bits of TO starting
                              at TOPOS are equal to the value that the LEN bits of FROM starting at
                              FROMPOS had on entry. The model for the interpretation of an integer
 3                            value as a sequence of bits is in 13.3.

            TOPOS             shall be of type integer and nonnegative. It is an INTENT (IN) argument.
 4                            TOPOS + LEN shall be less than or equal to BIT SIZE (TO).

 5          Example. If TO has the initial value 6, the value of TO after the statement
 6          CALL MVBITS (7, 2, 2, TO, 0) is 5.


 7    13.7.81      NEAREST (X, S)

 8          Description. Returns the nearest different machine-representable number in a given direction.

 9          Class. Elemental function.

10          Arguments.

11          X                 shall be of type real.

12          S                 shall be of type real and not equal to zero.

13          Result Characteristics. Same as X.

14          Result Value. The result has a value equal to the machine-representable number distinct from
15          X and nearest to it in the direction of the infinity with the same sign as S.

16          Example.     NEAREST (3.0, 2.0) has the value 3 + 2-22 on a machine whose representation is
17          that of the model in Note 13.4.

         NOTE 13.15

         Unlike other floating-point manipulation functions, NEAREST operates on machine-representable
         numbers rather than model numbers. On many systems there are machine-representable numbers
         that lie between adjacent model numbers.


18    13.7.82      NINT (A [, KIND])

19          Description. Nearest integer.

20          Class. Elemental function.

21          Arguments.

22          A                 shall be of type real.

23          KIND (optional) shall be a scalar integer initialization expression.



      SEP 2002                                 WORKING DRAFT                                         333


      J3/02-007R3                               WORKING DRAFT                                      SEP 2002



 1           Result Characteristics. Integer. If KIND is present, the kind type parameter is that specified
 2           by the value of KIND; otherwise, the kind type parameter is that of default integer type.

 3           Result Value. The result is the integer nearest A, or if there are two integers equally near A,
 4           the result is whichever such integer has the greater magnitude.

 5           Example.     NINT (2.783) has the value 3.


 6    13.7.83     NOT (I)

 7           Description. Performs a bitwise complement.

 8           Class. Elemental function.

 9           Argument.       I shall be of type integer.

10           Result Characteristics. Same as I.

11           Result Value. The result has the value obtained by complementing I bit-by-bit according to
12           the following truth table:


                                                     I      NOT (I)

                                                     1         0
                                                     0         1



13           The model for the interpretation of an integer value as a sequence of bits is in 13.3.

14           Example.      If I is represented by the string of bits 01010101, NOT (I) has the binary value
15           10101010.


16    13.7.84     NULL ([MOLD])

17           Description.      Returns a disassociated pointer or designates an unallocated allocatable com-
18           ponent of a structure constructor.

19           Class. Transformational function.

20           Argument. MOLD shall be a pointer or allocatable. It may be of any type or may be a
21           procedure pointer.    If MOLD is a pointer its pointer association status may be undefined,
22           disassociated, or associated. If MOLD is allocatable its allocation status may be allocated or
23           unallocated. It need not be defined with a value.

24           Result Characteristics. If MOLD is present, the characteristics are the same as MOLD. If
25           MOLD has deferred type parameters, those type parameters of the result are deferred.

26           If MOLD is absent, the characteristics of the result are determined by the entity with which the
27           reference is associated. See Table 13.1. MOLD shall not be absent in any other context. If any
28           type parameters of the contextual entity are deferred, those type parameters of the result are
29           deferred. If any type parameters of the contextual entity are assumed, MOLD shall be present.

30           If the context of the reference to NULL is an actual argument to a generic procedure, MOLD
31           shall be present if the type, type parameters, or rank is required to resolve the generic reference.
32           MOLD shall also be present if the reference appears as an actual argument corresponding to a
33           dummy argument with assumed character length.





      334                                  WORKING DRAFT                                           SEP 2002


      SEP 2002                             WORKING DRAFT                                       J3/02-007R3


                          Table 13.1: Characteristics of the result of NULL ( )


          Appearance of NULL ( )                           Type, type parameters, and rank of result:

          right side of a pointer assignment               pointer on the left side
          initialization for an object in a declaration    the object
          default initialization for a component           the component
          in a structure constructor                       the corresponding component
          as an actual argument                            the corresponding dummy argument
          in a DATA statement                              the corresponding pointer object



 1          Result. The result is a disassociated pointer or an unallocated allocatable entity.

 2          Examples.

 3          Case (i):      REAL, POINTER, DIMENSION(:) :: VEC => NULL ( ) defines the initial
 4                         association status of VEC to be disassociated.

 5          Case (ii):     The MOLD argument is required in the following:


 6                         INTERFACE GEN

 7                               SUBROUTINE S1 (J, PI)

 8                                      INTEGER J

 9                                      INTEGER, POINTER :: PI

10                               END SUBROUTINE S1

11                               SUBROUTINE S2 (K, PR)

12                                      INTEGER K

13                                      REAL, POINTER :: PR

14                               END SUBROUTINE S2

15                         END INTERFACE

16                         REAL, POINTER :: REAL_PTR

17                         CALL GEN (7, NULL (REAL_PTR) )                ! Invokes S2


18    13.7.85     PACK (ARRAY, MASK [, VECTOR])

19          Description. Pack an array into an array of rank one under the control of a mask.

20          Class. Transformational function.

21          Arguments.

22          ARRAY               may be of any type. It shall not be scalar.

23          MASK                shall be of type logical and shall be conformable with ARRAY.

            VECTOR              shall be of the same type and type parameters as ARRAY and shall have
            (optional)          rank one. VECTOR shall have at least as many elements as there are true
                                elements in MASK. If MASK is scalar with the value true, VECTOR shall
24                              have at least as many elements as there are in ARRAY.

25          Result Characteristics. The result is an array of rank one with the same type and type
26          parameters as ARRAY. If VECTOR is present, the result size is that of VECTOR; otherwise,
27          the result size is the number t of true elements in MASK unless MASK is scalar with the value
28          true, in which case the result size is the size of ARRAY.




      SEP 2002                                   WORKING DRAFT                                           335


      J3/02-007R3                               WORKING DRAFT                                                SEP 2002



 1           Result Value. Element i of the result is the element of ARRAY that corresponds to the ith
 2           true element of MASK, taking elements in array element order, for i = 1, 2, ..., t. If VECTOR
 3           is present and has size n > t, element i of the result has the value VECTOR (i), for i = t + 1,
 4           ..., n.

                                                                                    0 0 0 
             Examples.       The nonzero elements of an array M with the value          9    0    0         may be "gath-
                                                                                                      
 5                                                                                      0    0    7
 6           ered" by the function PACK. The result of PACK (M, MASK = M /= 0) is [9, 7] and the result
 7           of PACK (M, M /= 0, VECTOR = (/ 2, 4, 6, 8, 10, 12 /)) is [9, 7, 6, 8, 10, 12].


 8    13.7.86      PRECISION (X)

 9           Description. Returns the decimal precision of the model representing real numbers with the
10           same kind type parameter as the argument.

11           Class. Inquiry function.

12           Argument.       X shall be of type real or complex. It may be a scalar or an array.

13           Result Characteristics. Default integer scalar.

14           Result Value. The result has the value INT ((p - 1) * LOG10 (b)) + k, where b and p are as
15           defined in 13.4 for the model representing real numbers with the same value for the kind type
16           parameter as X, and where k is 1 if b is an integral power of 10 and 0 otherwise.

17           Example. PRECISION (X) has the value INT (23 * LOG10 (2.)) = INT (6.92...) = 6 for real
18           X whose model is as in Note 13.4.


19    13.7.87      PRESENT (A)

20           Description. Determine whether an optional argument is present.

21           Class. Inquiry function.

22           Argument.        A shall be the name of an optional dummy argument that is accessible in the
23           subprogram in which the PRESENT function reference appears. It may be of any type and it
24           may be a pointer. It may be a scalar or an array. It may be a dummy procedure. The dummy
25           argument A has no INTENT attribute.

26           Result Characteristics. Default logical scalar.

27           Result Value. The result has the value true if A is present (12.4.1.6) and otherwise has the
28           value false.


29    13.7.88      PRODUCT (ARRAY, DIM [, MASK]) or PRODUCT (ARRAY [, MASK])

30           Description. Product of all the elements of ARRAY along dimension DIM corresponding to
31           the true elements of MASK.

32           Class. Transformational function.

33           Arguments.

34           ARRAY               shall be of type integer, real, or complex. It shall not be scalar.





      336                                WORKING DRAFT                                                       SEP 2002


      SEP 2002                                WORKING DRAFT                                   J3/02-007R3



            DIM                   shall be scalar and of type integer with a value in the range 1  DIM  n,
                                  where n is the rank of ARRAY. The corresponding actual argument shall not
 1                                be an optional dummy argument.

 2          MASK (optional) shall be of type logical and shall be conformable with ARRAY.

 3          Result Characteristics. The result is of the same type and kind type parameter as AR-
 4          RAY. It is scalar if DIM is absent; otherwise, the result has rank n - 1 and shape (d1, d2,
 5          ..., dDIM-1, dDIM+1, ..., dn) where (d1, d2, ..., dn) is the shape of ARRAY.

 6          Result Value.

 7          Case (i):       The result of PRODUCT (ARRAY) has a value equal to a processor-dependent
 8                          approximation to the product of all the elements of ARRAY or has the value one
 9                          if ARRAY has size zero.

10          Case (ii):      The result of PRODUCT (ARRAY, MASK = MASK) has a value equal to a
11                          processor-dependent approximation to the product of the elements of ARRAY
12                          corresponding to the true elements of MASK or has the value one if there are no
13                          true elements.

14          Case (iii):     If ARRAY has rank one, PRODUCT (ARRAY, DIM = DIM [, MASK = MASK])
15                          has a value equal to that of PRODUCT (ARRAY [, MASK = MASK ]). Other-
16                          wise, the value of element (s1, s2, ..., sDIM-1, sDIM+1, ..., sn) of PRODUCT (AR-
17                          RAY, DIM = DIM [ ,MASK = MASK]) is equal to

18                                  PRODUCT (ARRAY (s1, s2, ..., sDIM-1, :, sDIM+1, ..., sn) [, MASK =
19                                  MASK (s1, s2, ..., sDIM-1, :, sDIM+1, ..., sn) ] ).


20          Examples.

21          Case (i):       The value of PRODUCT ((/ 1, 2, 3 /)) is 6.

22          Case (ii):      PRODUCT (C, MASK = C > 0.0) forms the product of the positive elements of
23                          C.

                                                   1    3    5
            Case (iii):     If B is the array                     , PRODUCT (B, DIM = 1) is [2, 12, 30] and
24                                                 2    4    6
25                          PRODUCT (B, DIM = 2) is [15, 48].


26    13.7.89      RADIX (X)

27          Description. Returns the base of the model representing numbers of the same type and kind
28          type parameter as the argument.

29          Class. Inquiry function.

30          Argument.       X shall be of type integer or real. It may be a scalar or an array.

31          Result Characteristics. Default integer scalar.

32          Result Value. The result has the value r if X is of type integer and the value b if X is of type
33          real, where r and b are as defined in 13.4 for the model representing numbers of the same type
34          and kind type parameter as X.

35          Example.       RADIX (X) has the value 2 for real X whose model is as in Note 13.4.


36    13.7.90      RANDOM NUMBER (HARVEST)

37          Description. Returns one pseudorandom number or an array of pseudorandom numbers from
38          the uniform distribution over the range 0  x < 1.




      SEP 2002                                    WORKING DRAFT                                         337


      J3/02-007R3                             WORKING DRAFT                                    SEP 2002



 1           Class. Subroutine.

 2           Argument. HARVEST shall be of type real. It is an INTENT (OUT) argument. It may be a
 3           scalar or an array variable. It is assigned pseudorandom numbers from the uniform distribution
 4           in the interval 0  x < 1.

 5           Examples.



 6               REAL X, Y (10, 10)

 7               ! Initialize X with a pseudorandom number

 8               CALL RANDOM_NUMBER (HARVEST = X)

 9               CALL RANDOM_NUMBER (Y)

10               ! X and Y contain uniformly distributed random numbers



11    13.7.91      RANDOM SEED ([SIZE, PUT, GET])

12           Description. Restarts or queries the pseudorandom number generator used by RANDOM -
13           NUMBER.

14           Class. Subroutine.

15           Arguments.     There shall either be exactly one or no arguments present.

             SIZE (optional)    shall be scalar and of type default integer. It is an INTENT (OUT) argument.
                                It is assigned the number N of integers that the processor uses to hold the
16                              value of the seed.

             PUT (optional)     shall be a default integer array of rank one and size  N .     It is an IN-
                                TENT (IN) argument. It is used in a processor-dependent manner to compute
17                              the seed value accessed by the pseudorandom number generator.

             GET (optional)     shall be a default integer array of rank one and size  N It is an IN-
18                              TENT (OUT) argument. It is assigned the current value of the seed.

19           If no argument is present, the processor assigns a processor-dependent value to the seed.

20           The pseudorandom number generator used by RANDOM NUMBER maintains a seed that is
21           updated during the execution of RANDOM NUMBER and that may be specified or returned by
22           RANDOM SEED. Computation of the seed from the argument PUT is performed in a processor-
23           dependent manner. The value returned by GET need not be the same as the value specified
24           by PUT in an immediately preceding reference to RANDOM SEED. For example, following
25           execution of the statements



26               CALL RANDOM_SEED (PUT=SEED1)

27               CALL RANDOM_SEED (GET=SEED2)



28           SEED2 need not equal SEED1. When the values differ, the use of either value as the PUT
29           argument in a subsequent call to RANDOM SEED shall result in the same sequence of pseudo-
30           random numbers being generated. For example, after execution of the statements



31               CALL RANDOM_SEED (PUT=SEED1)

32               CALL RANDOM_SEED (GET=SEED2)




      338                                  WORKING DRAFT                                       SEP 2002


      SEP 2002                              WORKING DRAFT                                        J3/02-007R3



 1               CALL RANDOM_NUMBER (X1)

 2               CALL RANDOM_SEED (PUT=SEED2)

 3               CALL RANDOM_NUMBER (X2)



 4          X2 equals X1.

 5          Examples.



 6               CALL RANDOM_SEED                               ! Processor initialization

 7               CALL RANDOM_SEED (SIZE = K)                    ! Puts size of seed in K

 8               CALL RANDOM_SEED (PUT = SEED (1 : K)) ! Define seed

 9               CALL RANDOM_SEED (GET = OLD (1 : K))           ! Read current seed



10    13.7.92      RANGE (X)

11          Description. Returns the decimal exponent range of the model representing integer or real
12          numbers with the same kind type parameter as the argument.

13          Class. Inquiry function.

14          Argument.        X shall be of type integer, real, or complex. It may be a scalar or an array.

15          Result Characteristics. Default integer scalar.

16          Result Value.

17          Case (i):        For an integer argument, the result has the value INT (LOG10 (HUGE(X))).

18          Case (ii):       For a real argument, the result has the value INT (MIN (LOG10 (HUGE(X)),
19                           �LOG10 (TINY(X)))).

20          Case (iii):      For a complex argument, the result has the value RANGE(REAL(X)).


21          Examples.      RANGE (X) has the value 38 for real X whose model is as in Note 13.4, since in
22          this case HUGE(X) = (1 - 2-24) � 2127 and TINY(X) = 2-127.


23    13.7.93      REAL (A [, KIND])

24          Description. Convert to real type.

25          Class. Elemental function.

26          Arguments.

27          A                    shall be of type integer, real, or complex, or a boz-literal-constant .

28          KIND (optional) shall be a scalar integer initialization expression.

29          Result Characteristics. Real.

30          Case (i):        If A is of type integer or real and KIND is present, the kind type parameter is
31                           that specified by the value of KIND. If A is of type integer or real and KIND is
32                           not present, the kind type parameter is that of default real type.

33          Case (ii):       If A is of type complex and KIND is present, the kind type parameter is that
34                           specified by the value of KIND. If A is of type complex and KIND is not present,
35                           the kind type parameter is the kind type parameter of A.




      SEP 2002                                    WORKING DRAFT                                               339


      J3/02-007R3                                   WORKING DRAFT                                       SEP 2002



 1           Case (iii):    If A is a boz-literal-constant and KIND is present, the kind type parameter is
 2                          that specified by the value of KIND. If A is a boz-literal-constant and KIND is
 3                          not present, the kind type parameter is that of default real type.


 4           Result Value.

 5           Case (i):      If A is of type integer or real, the result is equal to a processor-dependent ap-
 6                          proximation to A.

 7           Case (ii):     If A is of type complex, the result is equal to a processor-dependent approximation
 8                          to the real part of A.

 9           Case (iii):    If A is a boz-literal-constant , the value of the result is equal to the value that a
10                          variable of the same type and kind type parameters as the result would have if its
11                          value was the bit pattern specified by the boz-literal-constant . The interpretation
12                          of the value of the bit pattern is processor dependent.


13           Examples. REAL (�3) has the value �3.0. REAL (Z) has the same kind type parameter and
14           the same value as the real part of the complex variable Z.

15    13.7.94     REPEAT (STRING, NCOPIES)

16           Description. Concatenate several copies of a string.

17           Class. Transformational function.

18           Arguments.

19           STRING                 shall be scalar and of type character.

20           NCOPIES                shall be scalar and of type integer. Its value shall not be negative.

21           Result Characteristics. Character scalar of length NCOPIES times that of STRING, with
22           the same kind type parameter as STRING.

23           Result Value. The value of the result is the concatenation of NCOPIES copies of STRING.

24           Examples.      REPEAT ('H', 2) has the value HH. REPEAT ('XYZ', 0) has the value of a
25           zero-length string.

26    13.7.95     RESHAPE (SOURCE, SHAPE [, PAD, ORDER])

27           Description. Constructs an array of a specified shape from the elements of a given array.

28           Class. Transformational function.

29           Arguments.

             SOURCE                 may be of any type. It shall not be scalar. If PAD is absent or of size zero,
                                    the size of SOURCE shall be greater than or equal to PRODUCT (SHAPE).
30                                  The size of the result is the product of the values of the elements of SHAPE.

             SHAPE                  shall be of type integer, rank one, and constant size. Its size shall be positive
31                                  and less than 8. It shall not have an element whose value is negative.

             PAD (optional)         shall be of the same type and type parameters as SOURCE. PAD shall not
32                                  be scalar.

             ORDER                  shall be of type integer, shall have the same shape as SHAPE, and its value
             (optional)             shall be a permutation of (1, 2, ..., n), where n is the size of SHAPE. If absent,
33                                  it is as if it were present with value (1, 2, ..., n).



      340                                    WORKING DRAFT                                              SEP 2002


      SEP 2002                               WORKING DRAFT                                      J3/02-007R3



 1          Result Characteristics.         The result is an array of shape SHAPE (that is, SHAPE (RE-
 2          SHAPE (SOURCE, SHAPE, PAD, ORDER)) is equal to SHAPE) with the same type and type
 3          parameters as SOURCE.

 4          Result Value. The elements of the result, taken in permuted subscript order ORDER (1),
 5          ..., ORDER (n), are those of SOURCE in normal array element order followed if necessary by
 6          those of PAD in array element order, followed if necessary by additional copies of PAD in array
 7          element order.

                                                                                                1    3    5
            Examples.         RESHAPE ((/ 1, 2, 3, 4, 5, 6 /), (/ 2, 3 /)) has the value                       . RE-
 8                                                                                              2    4    6
                                                                                                1    2    3    4
            SHAPE ((/ 1, 2, 3, 4, 5, 6 /), (/ 2, 4 /), (/ 0, 0 /), (/ 2, 1 /)) has the value                         .
 9                                                                                              5    6    0    0


10    13.7.96     RRSPACING (X)

11          Description. Returns the reciprocal of the relative spacing of model numbers near the argument
12          value.

13          Class. Elemental function.

14          Argument.         X shall be of type real.

15          Result Characteristics. Same as X.

16          Result Value. The result has the value |X � b-e| � bp, where b, e, and p are as defined in 13.4
17          for the model representation of X.

18          Example. RRSPACING (�3.0) has the value 0.75�224 for reals whose model is as in Note 13.4.


19    13.7.97     SAME TYPE AS (A, B)

20          Description. Inquires whether the dynamic type of A is the same as the dynamic type of B.

21          Class. Inquiry function.

22          Arguments.

            A                     shall be an object of extensible type. If it is a pointer, it shall not have an
23                                undefined association status.

            B                     shall be an object of extensible type. If it is a pointer, it shall not have an
24                                undefined association status.

25          Result Characteristics. Default logical scalar.

26          Result Value. The result is true if and only if the dynamic type of A is the same as the
27          dynamic type of B.

         NOTE 13.16

         The dynamic type of a disassociated pointer or unallocated allocatable is its declared type.


28    13.7.98     SCALE (X, I)

29          Description. Returns X � bI where b is the base of the model representation of X.

30          Class. Elemental function.





      SEP 2002                                     WORKING DRAFT                                                    341


      J3/02-007R3                               WORKING DRAFT                                     SEP 2002



 1           Arguments.

 2           X                   shall be of type real.

 3           I                   shall be of type integer.

 4           Result Characteristics. Same as X.

 5           Result Value. The result has the value X � bI, where b is defined in 13.4 for model numbers
 6           representing values of X, provided this result is within range; if not, the result is processor
 7           dependent.

 8           Example.       SCALE (3.0, 2) has the value 12.0 for reals whose model is as in Note 13.4.


 9    13.7.99       SCAN (STRING, SET [, BACK, KIND])

10           Description. Scan a string for any one of the characters in a set of characters.

11           Class. Elemental function.

12           Arguments.

13           STRING              shall be of type character.

14           SET                 shall be of type character with the same kind type parameter as STRING.

15           BACK (optional) shall be of type logical.

16           KIND (optional) shall be a scalar integer initialization expression.

17           Result Characteristics. Integer. If KIND is present, the kind type parameter is that specified
18           by the value of KIND; otherwise the kind type parameter is that of default integer type.

19           Result Value.

20           Case (i):       If BACK is absent or is present with the value false and if STRING contains at
21                           least one character that is in SET, the value of the result is the position of the
22                           leftmost character of STRING that is in SET.

23           Case (ii):      If BACK is present with the value true and if STRING contains at least one
24                           character that is in SET, the value of the result is the position of the rightmost
25                           character of STRING that is in SET.

26           Case (iii):     The value of the result is zero if no character of STRING is in SET or if the
27                           length of STRING or SET is zero.


28           Examples.

29           Case (i):       SCAN ('FORTRAN', 'TR') has the value 3.

30           Case (ii):      SCAN ('FORTRAN', 'TR', BACK = .TRUE.) has the value 5.

31           Case (iii):     SCAN ('FORTRAN', 'BCD') has the value 0.


32    13.7.100      SELECTED CHAR KIND (NAME)

33           Description. Returns the value of the kind type parameter of the character set named by the
34           argument.

35           Class. Transformational function.

36           Argument.       NAME shall be scalar and of type default character.



      342                                 WORKING DRAFT                                           SEP 2002


      SEP 2002                            WORKING DRAFT                                      J3/02-007R3



 1          Result Characteristics. Default integer scalar.

 2          Result Value. If NAME has the value DEFAULT, then the result has a value equal to that of
 3          the kind type parameter of the default character type. If NAME has the value ASCII, then the
 4          result has a value equal to that of the kind type parameter of the ASCII character type if the
 5          processor supports such a type; otherwise the result has the value -1. If NAME has the value
 6          ISO 10646, then the result has a value equal to that of the kind type parameter of the ISO/IEC
 7          10646-1:2000 UCS-4 character type if the processor supports such a type; otherwise the result
 8          has the value -1. If NAME is a processor-defined name of some other character type supported
 9          by the processor, then the result has a value equal to that of the kind type parameter of that
10          character type. If NAME is not the name of a supported character type, then the result has the
11          value -1. The NAME is interpreted without respect to case or trailing blanks.

12          Example. SELECTED CHAR KIND ('ASCII') has the value 1 on a processor that uses 1 as
13          the kind type parameter for the ASCII character set.

         NOTE 13.17

         ISO 10646 refers to the UCS-4 representation, a 4-octet character set.


14    13.7.101    SELECTED INT KIND (R)

15          Description. Returns a value of the kind type parameter of an integer type that represents all
16          integer values n with -10R < n < 10R.

17          Class. Transformational function.

18          Argument.       R shall be scalar and of type integer.

19          Result Characteristics. Default integer scalar.

20          Result Value. The result has a value equal to the value of the kind type parameter of an
21          integer type that represents all values n in the range -10R < n < 10R, or if no such kind type
22          parameter is available on the processor, the result is �1. If more than one kind type parameter
23          meets the criterion, the value returned is the one with the smallest decimal exponent range,
24          unless there are several such values, in which case the smallest of these kind values is returned.

25          Example. SELECTED INT KIND (6) has the value KIND (0) on a machine that supports a
26          default integer representation method with r = 2 and q = 31.


27    13.7.102    SELECTED REAL KIND ([P, R])

28          Description. Returns a value of the kind type parameter of a real type with decimal precision
29          of at least P digits and a decimal exponent range of at least R.

30          Class. Transformational function.

31          Arguments.       At least one argument shall be present.

32          P (optional)        shall be scalar and of type integer.

33          R (optional)        shall be scalar and of type integer.

34          Result Characteristics. Default integer scalar.

35          Result Value. If P or R is absent, the result value is the same as if it were present with the
36          value zero. The result has a value equal to a value of the kind type parameter of a real type with
37          decimal precision, as returned by the function PRECISION, of at least P digits and a decimal



      SEP 2002                                   WORKING DRAFT                                           343


      J3/02-007R3                                  WORKING DRAFT                                      SEP 2002



 1           exponent range, as returned by the function RANGE, of at least R, or if no such kind type
 2           parameter is available on the processor, the result is -1 if the processor does not support a real
 3           type with a precision greater than or equal to P but does support a real type with an exponent
 4           range greater than or equal to R, -2 if the processor does not support a real type with an
 5           exponent range greater than or equal to R but does support a real type with a precision greater
 6           than or equal to P, -3 if the processor supports no real type with either of these properties, and
 7           -4 if the processor supports real types for each separately but not together. If more than one
 8           kind type parameter value meets the criteria, the value returned is the one with the smallest
 9           decimal precision, unless there are several such values, in which case the smallest of these kind
10           values is returned.

11           Example.      SELECTED REAL KIND (6, 70) has the value KIND (0.0) on a machine that
12           supports a default real approximation method with b = 16, p = 6, emin = -64, and emax = 63.

13    13.7.103    SET EXPONENT (X, I)

14           Description. Returns the model number whose fractional part is the fractional part of the
15           model representation of X and whose exponent part is I.

16           Class. Elemental function.

17           Arguments.

18           X                      shall be of type real.

19           I                      shall be of type integer.

20           Result Characteristics. Same as X.

21           Result Value. The result has the value X � bI-e, where b and e are as defined in 13.4 for the
22           model representation of X. If X has value zero, the result has value zero.

23           Example.       SET EXPONENT (3.0, 1) has the value 1.5 for reals whose model is as in
24           Note 13.4.


25    13.7.104    SHAPE (SOURCE [, KIND])

26           Description. Returns the shape of an array or a scalar.

27           Class. Inquiry function.

28           Arguments.

             SOURCE                 may be of any type. It may be a scalar or an array. It shall not be an
                                    unallocated allocatable or a pointer that is not associated. It shall not be an
29                                  assumed-size array.

30           KIND (optional) shall be a scalar integer initialization expression.

31           Result Characteristics. Integer. If KIND is present, the kind type parameter is that specified
32           by the value of KIND; otherwise the kind type parameter is that of default integer type. The
33           result is an array of rank one whose size is equal to the rank of SOURCE.

34           Result Value. The value of the result is the shape of SOURCE.

35           Examples.      The value of SHAPE (A (2:5, �1:1) ) is [4, 3]. The value of SHAPE (3) is the
36           rank-one array of size zero.





      344                                    WORKING DRAFT                                            SEP 2002


      SEP 2002                                WORKING DRAFT                                          J3/02-007R3


 1    13.7.105    SIGN (A, B)

 2          Description. Magnitude of A with the sign of B.

 3          Class. Elemental function.

 4          Arguments.

 5          A                      shall be of type integer or real.

 6          B                      shall be of the same type and kind type parameter as A.

 7          Result Characteristics. Same as A.

 8          Result Value.

 9          Case (i):       If B > 0, the value of the result is |A|.

10          Case (ii):      If B < 0, the value of the result is -|A|.

11          Case (iii):     If B is of type integer and B=0, the value of the result is |A|.

12          Case (iv):      If B is of type real and is zero, then

13                          (1)      If the processor cannot distinguish between positive and negative real zero,
14                                   the value of the result is |A|.

15                          (2)      If B is positive real zero, the value of the result is |A|.

16                          (3)      If B is negative real zero, the value of the result is -|A|.


17          Example.       SIGN (�3.0, 2.0) has the value 3.0.


18    13.7.106    SIN (X)

19          Description. Sine function.

20          Class. Elemental function.

21          Argument.       X shall be of type real or complex.

22          Result Characteristics. Same as X.

23          Result Value. The result has a value equal to a processor-dependent approximation to sin(X).
24          If X is of type real, it is regarded as a value in radians. If X is of type complex, its real part is
25          regarded as a value in radians.

26          Example.       SIN (1.0) has the value 0.84147098 (approximately).


27    13.7.107    SINH (X)

28          Description. Hyperbolic sine function.

29          Class. Elemental function.

30          Argument.       X shall be of type real.

31          Result Characteristics. Same as X.

32          Result Value. The result has a value equal to a processor-dependent approximation to sinh(X).

33          Example.       SINH (1.0) has the value 1.1752012 (approximately).


34    13.7.108    SIZE (ARRAY [, DIM, KIND])


      SEP 2002                                      WORKING DRAFT                                           345


      J3/02-007R3                               WORKING DRAFT                                   SEP 2002



 1           Description. Returns the extent of an array along a specified dimension or the total number
 2           of elements in the array.

 3           Class. Inquiry function.

 4           Arguments.

             ARRAY               may be of any type. It shall not be scalar. It shall not be an unallocated
                                 allocatable or a pointer that is not associated. If ARRAY is an assumed-size
 5                               array, DIM shall be present with a value less than the rank of ARRAY.

             DIM (optional)      shall be scalar and of type integer with a value in the range 1  DIM  n,
 6                               where n is the rank of ARRAY.

 7           KIND (optional) shall be a scalar integer initialization expression.

 8           Result Characteristics. Integer scalar. If KIND is present, the kind type parameter is that
 9           specified by the value of KIND; otherwise the kind type parameter is that of default integer
10           type.

11           Result Value. The result has a value equal to the extent of dimension DIM of ARRAY or, if
12           DIM is absent, the total number of elements of ARRAY.

13           Examples.       The value of SIZE (A (2:5, �1:1), DIM=2) is 3. The value of SIZE (A (2:5, �1:1)
14           ) is 12.


15    13.7.109        SPACING (X)

16           Description. Returns the absolute spacing of model numbers near the argument value.

17           Class. Elemental function.

18           Argument.       X shall be of type real.

19           Result Characteristics. Same as X.

20           Result Value. If X is not zero, the result has the value bmax(e-p,eMIN-1), where b, e, and p are
21           as defined in 13.4 for the model representation of X. Otherwise, the result is the same as that
22           of TINY (X).

23           Example.     SPACING (3.0) has the value 2-22 for reals whose model is as in Note 13.4.


24    13.7.110        SPREAD (SOURCE, DIM, NCOPIES)

25           Description. Replicates an array by adding a dimension. Broadcasts several copies of SOURCE
26           along a specified dimension (as in forming a book from copies of a single page) and thus forms
27           an array of rank one greater.

28           Class. Transformational function.

29           Arguments.

             SOURCE              may be of any type. It may be a scalar or an array. The rank of SOURCE
30                               shall be less than 7.

             DIM                 shall be scalar and of type integer with value in the range 1  DIM  n + 1,
31                               where n is the rank of SOURCE.

32           NCOPIES             shall be scalar and of type integer.





      346                                 WORKING DRAFT                                         SEP 2002


      SEP 2002                                       WORKING DRAFT                                       J3/02-007R3



 1          Result Characteristics. The result is an array of the same type and type parameters as
 2          SOURCE and of rank n + 1, where n is the rank of SOURCE.

 3          Case (i):                 If SOURCE is scalar, the shape of the result is (MAX (NCOPIES, 0)).

 4          Case (ii):                If SOURCE is an array with shape (d1, d2, ..., dn), the shape of the result is
 5                                    (d1, d2, ..., dDIM-1, MAX (NCOPIES, 0), dDIM, ..., dn).

 6          Result Value.

 7          Case (i):                 If SOURCE is scalar, each element of the result has a value equal to SOURCE.

 8          Case (ii):                If SOURCE is an array, the element of the result with subscripts (r1, r2, ..., rn+1)
 9                                    has the value SOURCE (r1, r2, ..., rDIM-1, rDIM+1, ..., rn+1).

10          Examples.                 If A is the array [2, 3, 4], SPREAD (A, DIM=1, NCOPIES=NC) is the array
             2 3 4 
                  2    3    4         if NC has the value 3 and is a zero-sized array if NC has the value 0.
                                
11                2    3    4


12    13.7.111         SQRT (X)

13          Description. Square root.

14          Class. Elemental function.

15          Argument. X shall be of type real or complex. Unless X is complex, its value shall be greater
16          than or equal to zero.

17          Result Characteristics. Same as X.

18          Result Value. The result has a value equal to a processor-dependent approximation to the
19          square root of X. A result of type complex is the principal value with the real part greater than
20          or equal to zero. When the real part of the result is zero, the imaginary part is greater than or
21          equal to zero.

22          Example.             SQRT (4.0) has the value 2.0 (approximately).


23    13.7.112         SUM (ARRAY, DIM [, MASK]) or SUM (ARRAY [, MASK])

24          Description. Sum all the elements of ARRAY along dimension DIM corresponding to the true
25          elements of MASK.

26          Class. Transformational function.

27          Arguments.

28          ARRAY                         shall be of type integer, real, or complex. It shall not be scalar.

            DIM                           shall be scalar and of type integer with a value in the range 1  DIM  n,
                                          where n is the rank of ARRAY. The corresponding actual argument shall not
29                                        be an optional dummy argument.

30          MASK (optional) shall be of type logical and shall be conformable with ARRAY.

31          Result Characteristics. The result is of the same type and kind type parameter as AR-
32          RAY. It is scalar if DIM is absent; otherwise, the result has rank n - 1 and shape (d1, d2,
33          ..., dDIM-1, dDIM+1, ..., dn) where (d1, d2, ..., dn) is the shape of ARRAY.

34          Result Value.




      SEP 2002                                             WORKING DRAFT                                             347


      J3/02-007R3                                WORKING DRAFT                                     SEP 2002



 1           Case (i):      The result of SUM (ARRAY) has a value equal to a processor-dependent approx-
 2                          imation to the sum of all the elements of ARRAY or has the value zero if ARRAY
 3                          has size zero.

 4           Case (ii):     The result of SUM (ARRAY, MASK = MASK) has a value equal to a processor-
 5                          dependent approximation to the sum of the elements of ARRAY corresponding
 6                          to the true elements of MASK or has the value zero if there are no true elements.

 7           Case (iii):    If ARRAY has rank one, SUM (ARRAY, DIM = DIM [, MASK = MASK]) has a
 8                          value equal to that of SUM (ARRAY [,MASK = MASK ]). Otherwise, the value
 9                          of element (s1, s2, ..., sDIM-1, sDIM+1, ..., sn) SUM (ARRAY, DIM = DIM [
10                          , MASK = MASK]) is equal to

11                                 SUM (ARRAY (s1, s2, ..., sDIM-1, :, sDIM+1, ..., sn) [, MASK= MASK (s1,
12                                 s2, ..., sDIM-1, :, sDIM+1, ..., sn) ] ).


13           Examples.

14           Case (i):      The value of SUM ((/ 1, 2, 3 /)) is 6.

15           Case (ii):     SUM (C, MASK= C > 0.0) forms the sum of the positive elements of C.

                                                    1    3    5
             Case (iii):    If B is the array                      , SUM (B, DIM = 1) is [3, 7, 11] and SUM (B,
16                                                  2    4    6
17                          DIM = 2) is [9, 12].


18    13.7.113    SYSTEM CLOCK ([COUNT, COUNT RATE, COUNT MAX])

19           Description. Returns numeric data from a real-time clock.

20           Class. Subroutine.

21           Arguments.

             COUNT              shall be scalar and of type integer. It is an INTENT (OUT) argument. It
             (optional)         is assigned a processor-dependent value based on the current value of the
                                processor clock, or �HUGE (COUNT) if there is no clock. The processor-
                                dependent value is incremented by one for each clock count until the value
                                COUNT MAX is reached and is reset to zero at the next count. It lies in the
22                              range 0 to COUNT MAX if there is a clock.

             COUNT RATE         shall be scalar and of type integer or real. It is an INTENT (OUT) argument.
             (optional)         It is assigned a processor-dependent approximation to the number of processor
23                              clock counts per second, or zero if there is no clock.

             COUNT MAX          shall be scalar and of type integer. It is an INTENT(OUT) argument. It is
             (optional)         assigned the maximum value that COUNT can have, or zero if there is no
24                              clock.

25           Example.       If the processor clock is a 24-hour clock that registers time at approximately
26           18.20648193 ticks per second, at 11:30 A.M. the reference

27                CALL SYSTEM CLOCK (COUNT = C, COUNT RATE = R, COUNT MAX = M)

28           defines C = (11 � 3600 + 30 � 60) � 18.20648193               = 753748, R = 18.20648193, and M =
29           24 � 3600 � 18.20648193 - -1 = 86399.


30    13.7.114    TAN (X)

31           Description. Tangent function.




      348                                 WORKING DRAFT                                            SEP 2002


      SEP 2002                            WORKING DRAFT                                      J3/02-007R3



 1          Class. Elemental function.

 2          Argument.     X shall be of type real.

 3          Result Characteristics. Same as X.

 4          Result Value. The result has a value equal to a processor-dependent approximation to tan(X),
 5          with X regarded as a value in radians.

 6          Example.     TAN (1.0) has the value 1.5574077 (approximately).


 7    13.7.115    TANH (X)

 8          Description. Hyperbolic tangent function.

 9          Class. Elemental function.

10          Argument.     X shall be of type real.

11          Result Characteristics. Same as X.

12          Result Value. The result has a value equal to a processor-dependent approximation to tanh(X).

13          Example.     TANH (1.0) has the value 0.76159416 (approximately).


14    13.7.116    TINY (X)

15          Description. Returns the smallest positive number of the model representing numbers of the
16          same type and kind type parameter as the argument.

17          Class. Inquiry function.

18          Argument.     X shall be of type real. It may be a scalar or an array.

19          Result Characteristics. Scalar with the same type and kind type parameter as X.

20          Result Value. The result has the value bemin-1 where b and emin are as defined in 13.4 for the
21          model representing numbers of the same type and kind type parameter as X.

22          Example.     TINY (X) has the value 2-127 for real X whose model is as in Note 13.4.


23    13.7.117    TRANSFER (SOURCE, MOLD [, SIZE])

24          Description. Returns a result with a physical representation identical to that of SOURCE but
25          interpreted with the type and type parameters of MOLD.

26          Class. Transformational function.

27          Arguments.

28          SOURCE             may be of any type. It may be a scalar or an array.

            MOLD               may be of any type. It may be a scalar or an array. If it is a variable, it need
29                             not be defined.

            SIZE (optional)    shall be scalar and of type integer. The corresponding actual argument shall
30                             not be an optional dummy argument.

31          Result Characteristics. The result is of the same type and type parameters as MOLD.





      SEP 2002                                   WORKING DRAFT                                            349


      J3/02-007R3                                    WORKING DRAFT                                       SEP 2002



 1           Case (i):      If MOLD is a scalar and SIZE is absent, the result is a scalar.

 2           Case (ii):     If MOLD is an array and SIZE is absent, the result is an array and of rank one.
 3                          Its size is as small as possible such that its physical representation is not shorter
 4                          than that of SOURCE.

 5           Case (iii):    If SIZE is present, the result is an array of rank one and size SIZE.


 6           Result Value. If the physical representation of the result has the same length as that of
 7           SOURCE, the physical representation of the result is that of SOURCE. If the physical represen-
 8           tation of the result is longer than that of SOURCE, the physical representation of the leading
 9           part is that of SOURCE and the remainder is processor depedent. If the physical representation
10           of the result is shorter than that of SOURCE, the physical representation of the result is the
11           leading part of SOURCE. If D and E are scalar variables such that the physical representation
12           of D is as long as or longer than that of E, the value of TRANSFER (TRANSFER (E, D), E)
13           shall be the value of E. IF D is an array and E is an array of rank one, the value of TRANS-
14           FER (TRANSFER (E, D), E, SIZE (E)) shall be the value of E.

15           Examples.

16           Case (i):      TRANSFER (1082130432, 0.0) has the value 4.0 on a processor that represents
17                          the values 4.0 and 1082130432 as the string of binary digits 0100 0000 1000 0000
18                          0000 0000 0000 0000.

19           Case (ii):     TRANSFER ((/ 1.1, 2.2, 3.3 /), (/ (0.0, 0.0) /)) is a complex rank-one array of
20                          length two whose first element has the value (1.1, 2.2) and whose second element
21                          has a real part with the value 3.3. The imaginary part of the second element is
22                          processor dependent.

23           Case (iii):    TRANSFER ((/ 1.1, 2.2, 3.3 /), (/ (0.0, 0.0) /), 1) is a complex rank-one array
24                          of length one whose only element has the value (1.1, 2.2).


25    13.7.118    TRANSPOSE (MATRIX)

26           Description. Transpose an array of rank two.

27           Class. Transformational function.

28           Argument.      MATRIX may be of any type and shall have rank two.

29           Result Characteristics. The result is an array of the same type and type parameters as
30           MATRIX and with rank two and shape (n, m) where (m, n) is the shape of MATRIX.

31           Result Value. Element (i, j) of the result has the value MATRIX (j, i), i = 1, 2, ..., n;
32           j = 1, 2, ..., m.

                                            1 2 3                                                 1 4 7 
             Example. If A is the array         4     5    6                                             2    5    8    .
                                                               , then TRANSPOSE (A) has the value                    
33                                              7     8    9                                             3    6    9


34    13.7.119    TRIM (STRING)

35           Description. Returns the argument with trailing blank characters removed.

36           Class. Transformational function.

37           Argument.      STRING shall be of type character and shall be a scalar.

38           Result Characteristics. Character with the same kind type parameter value as STRING and
39           with a length that is the length of STRING less the number of trailing blanks in STRING.



      350                                WORKING DRAFT                                                   SEP 2002


      SEP 2002                           WORKING DRAFT                                         J3/02-007R3



 1          Result Value. The value of the result is the same as STRING except any trailing blanks are
 2          removed. If STRING contains no nonblank characters, the result has zero length.

 3          Example.      TRIM (' A B ') has the value ' A B'.


 4    13.7.120    UBOUND (ARRAY [, DIM, KIND])

 5          Description. Returns all the upper bounds of an array or a specified upper bound.

 6          Class. Inquiry function.

 7          Arguments.

            ARRAY              may be of any type. It shall not be scalar. It shall not be an unallocated
                               allocatable or a pointer that is not associated. If ARRAY is an assumed-size
 8                             array, DIM shall be present with a value less than the rank of ARRAY.

            DIM (optional)     shall be scalar and of type integer with a value in the range 1  DIM  n,
                               where n is the rank of ARRAY. The corresponding actual argument shall not
 9                             be an optional dummy argument.

10          KIND (optional) shall be a scalar integer initialization expression.

11          Result Characteristics. Integer. If KIND is present, the kind type parameter is that specified
12          by the value of KIND; otherwise the kind type parameter is that of default integer type. It is
13          scalar if DIM is present; otherwise, the result is an array of rank one and size n, where n is the
14          rank of ARRAY.

15          Result Value.

16          Case (i):      For an array section or for an array expression, other than a whole array or array
17                         structure component, UBOUND (ARRAY, DIM) has a value equal to the number
18                         of elements in the given dimension; otherwise, it has a value equal to the upper
19                         bound for subscript DIM of ARRAY if dimension DIM of ARRAY does not have
20                         size zero and has the value zero if dimension DIM has size zero.

21          Case (ii):     UBOUND (ARRAY) has a value whose ith element is equal to UBOUND (AR-
22                         RAY, i), for i = 1, 2, ..., n, where n is the rank of ARRAY.


23          Examples.     If A is declared by the statement

24          REAL A (2:3, 7:10)
25          then UBOUND (A) is [3, 10] and UBOUND (A, DIM = 2) is 10.


26    13.7.121    UNPACK (VECTOR, MASK, FIELD)

27          Description. Unpack an array of rank one into an array under the control of a mask.

28          Class. Transformational function.

29          Arguments.

            VECTOR             may be of any type. It shall have rank one. Its size shall be at least t where
30                             t is the number of true elements in MASK.

31          MASK               shall be an array of type logical.

            FIELD              shall be of the same type and type parameters as VECTOR and shall be
32                             conformable with MASK.




      SEP 2002                                   WORKING DRAFT                                           351


      J3/02-007R3                                        WORKING DRAFT                                                          SEP 2002



 1           Result Characteristics. The result is an array of the same type and type parameters as
 2           VECTOR and the same shape as MASK.

 3           Result Value. The element of the result that corresponds to the ith true element of MASK,
 4           in array element order, has the value VECTOR (i) for i = 1, 2, ..., t, where t is the number of
 5           true values in MASK. Each other element has a value equal to FIELD if FIELD is scalar or to
 6           the corresponding element of FIELD if it is an array.

 7           Examples.              Particular values may be "scattered" to particular positions in an array by us-
                                                            1 0 0 
             ing UNPACK. If M is the array                      0    1    0    , V is the array [1, 2, 3], and Q is the logical
                                                                              
 8                                                              0    0    1
                         .    T      . 
             mask         T    .      .      , where "T" represents true and "." represents false, then the result of
                                          
 9                        .    .      T
                                                                                               1 2 0 
             UNPACK (V, MASK = Q, FIELD = M) has the value                                         1    1    0         and the result of UN-
                                                                                                                 
10                                                                                                 0    0    3
                                                                                     0 2 0 
             PACK (V, MASK = Q, FIELD = 0) has the value                                 1    0    0    .
                                                                                                       
11                                                                                       0    0    3


12    13.7.122      VERIFY (STRING, SET [, BACK, KIND])

13           Description. Verify that a set of characters contains all the characters in a string by identifying
14           the position of the first character in a string of characters that does not appear in a given set of
15           characters.

16           Class. Elemental function.

17           Arguments.

18           STRING                        shall be of type character.

19           SET                           shall be of type character with the same kind type parameter as STRING.

20           BACK (optional) shall be of type logical.

21           KIND (optional) shall be a scalar integer initialization expression.

22           Result Characteristics. Integer. If KIND is present, the kind type parameter is that specified
23           by the value of KIND; otherwise the kind type parameter is that of default integer type.

24           Result Value.

25           Case (i):              If BACK is absent or has the value false and if STRING contains at least one
26                                  character that is not in SET, the value of the result is the position of the leftmost
27                                  character of STRING that is not in SET.

28           Case (ii):             If BACK is present with the value true and if STRING contains at least one
29                                  character that is not in SET, the value of the result is the position of the rightmost
30                                  character of STRING that is not in SET.

31           Case (iii):            The value of the result is zero if each character in STRING is in SET or if STRING
32                                  has zero length.


33           Examples.

34           Case (i):              VERIFY ('ABBA', 'A') has the value 2.




      352                                          WORKING DRAFT                                                                SEP 2002


      SEP 2002                                WORKING DRAFT                                 J3/02-007R3



 1              Case (ii):     VERIFY ('ABBA', 'A', BACK = .TRUE.) has the value 3.

 2              Case (iii):    VERIFY ('ABBA', 'AB') has the value 0.



 3    13.8          Standard intrinsic modules

 4    This standard defines several intrinsic modules. A processor may extend the standard intrinsic modules
 5    to provide public entities in them in addition to those specified in this standard.

           NOTE 13.18

           To avoid potential name conflicts with program entities, it is recommended that a program use
           the ONLY option in any USE statement that accesses a standard intrinsic module.



 6    13.8.1        The ISO C BINDING module

 7    The ISO C BINDING intrinsic module is described in Section 15.


 8    13.8.2        The IEEE modules

 9    The IEEE EXCEPTIONS, IEEE ARITHMETIC, and IEEE FEATURES intrinsic modules are describ-
10    ed in Section 14.


11    13.8.3        The ISO FORTRAN ENV intrinsic module

12    The intrinsic module ISO FORTRAN ENV provides public entities relating to the Fortran environment.


13    13.8.3.1       Standard input/output units

14    The processor shall provide three constants giving processor-dependent values for preconnected units
15    (9.4).


16    13.8.3.1.1      INPUT UNIT

17    The value of the default integer scalar constant INPUT UNIT identifies the same processor-dependent
18    preconnected external unit as the one identified by an asterisk in a READ statement. The value shall
19    not be -1.


20    13.8.3.1.2      OUTPUT UNIT

21    The value of the default integer scalar constant OUTPUT UNIT identifies the same processor-dependent
22    preconnected external unit as the one identified by an asterisk in a WRITE statement. The value shall
23    not be -1.


24    13.8.3.1.3       ERROR UNIT

25    The value of the default integer scalar constant ERROR UNIT identifies the processor-dependent pre-
26    connected external unit used for the purpose of error reporting. This unit may be the same as OUT-
27    PUT UNIT. The value shall not be -1.


28    13.8.3.2      Input/output status

29    The processor shall provide two constants giving processor-dependent values for end-of-file and end-of-
30    record input/output status (9.10.4).



      SEP 2002                                      WORKING DRAFT                                      353


     J3/02-007R3                              WORKING DRAFT                                     SEP 2002



1    13.8.3.2.1    IOSTAT END

2    The value of the default integer scalar constant IOSTAT END is assigned to the variable specified in an
3    IOSTAT= specifier if an end-of-file condition occurs during execution of an input/output statement and
4    no error condition occurs. This value shall be negative.


5    13.8.3.2.2    IOSTAT EOR

6    The value of the default integer scalar constant IOSTAT EOR is assigned to the variable specified in an
7    IOSTAT= specifier if an end-of-record condition occurs during execution of an input/output statement
8    and no end-of-file or error condition occurs. This value shall be negative and different from the value of
9    IOSTAT END.





     354                                WORKING DRAFT                                           SEP 2002


      SEP 2002                              WORKING DRAFT                                      J3/02-007R3





 1    Section 14: Exceptions and IEEE arithmetic

 2    The intrinsic modules IEEE EXCEPTIONS, IEEE ARITHMETIC, and IEEE FEATURES provide sup-
 3    port for exceptions and IEEE arithmetic. Whether the modules are provided is processor dependent.
 4    If the module IEEE FEATURES is provided, which of the named constants defined in this standard
 5    are included is processor dependent. The module IEEE ARITHMETIC behaves as if it contained a
 6    USE statement for IEEE EXCEPTIONS; everything that is public in IEEE EXCEPTIONS is public in
 7    IEEE ARITHMETIC.

           NOTE 14.1

           The types and procedures defined in these modules are not themselves intrinsic.


 8    If IEEE EXCEPTIONS or IEEE ARITHMETIC is accessible in a scoping unit, IEEE OVERFLOW
 9    and IEEE DIVIDE BY ZERO are supported in the scoping unit for all kinds of real and complex
10    data. Which other exceptions are supported can be determined by the function IEEE SUPPORT -
11    FLAG (14.9.24); whether control of halting is supported can be determined by the function IEEE SUP-
12    PORT HALTING. The extent of support of the other exceptions may be influenced by the accessibility
13    of the named constants IEEE INEXACT FLAG, IEEE INVALID FLAG, and IEEE UNDERFLOW -
14    FLAG of the module IEEE FEATURES. If a scoping unit has access to IEEE UNDERFLOW FLAG
15    of IEEE FEATURES, within the scoping unit the processor shall support underflow and return true
16    from IEEE SUPPORT FLAG( IEEE UNDERFLOW, X) for at least one kind of real. Similarly, if
17    IEEE INEXACT FLAG or IEEE INVALID FLAG is accessible, within the scoping unit the processor
18    shall support the exception and return true from the corresponding inquiry for at least one kind of real.
19    Also, if IEEE HALTING is accessible, within the scoping unit the processor shall support control of
20    halting and return true from IEEE SUPPORT HALTING(FLAG) for the flag.

           NOTE 14.2

           The IEEE FEATURES module is provided to allow a reasonable amount of cooperation between
           the programmer and the processor in controlling the extent of IEEE arithmetic support. On some
           processors some IEEE features are natural for the processor to support, others may be inefficient
           at run time, and others are essentially impossible to support. If IEEE FEATURES is not used, the
           processor will support only the natural operations. Within IEEE FEATURES the processor will
           define the named constants (14.1) corresponding to the time-consuming features (as well as the
           natural ones for completeness) but will not define named constants corresponding to the impossible
           features. If the programmer accesses IEEE FEATURES, the processor shall provide support for
           all of the IEEE FEATURES that are reasonably possible. If the programmer uses an ONLY clause
           on a USE statement to access a particular feature name, the processor shall provide support for
           the corresponding feature, or issue an error message saying the name is not defined in the module.

           When used this way, the named constants in the IEEE FEATURES are similar to what are fre-
           quently called command line switches for the compiler. They can specify compilation options in a
           reasonably portable manner.


21    If a scoping unit does not access IEEE FEATURES, IEEE EXCEPTIONS, or IEEE ARITHMETIC,
22    the level of support is processor dependent, and need not include support for any exceptions. If a flag is
23    signaling on entry to such a scoping unit, the processor ensures that it is signaling on exit. If a flag is
24    quiet on entry to such a scoping unit, whether it is signaling on exit is processor dependent.

25    Further IEEE support is available through the module IEEE ARITHMETIC. The extent of support




      SEP 2002                                    WORKING DRAFT                                            355


      J3/02-007R3                                 WORKING DRAFT                                      SEP 2002



 1    may be influenced by the accessibility of the named constants of the module IEEE FEATURES. If a
 2    scoping unit has access to IEEE DATATYPE of IEEE FEATURES, within the scoping unit the pro-
 3    cessor shall support IEEE arithmetic and return true from IEEE SUPPORT DATATYPE(X) (14.9.21)
 4    for at least one kind of real. Similarly, if IEEE DENORMAL, IEEE DIVIDE, IEEE INF, IEEE NAN,
 5    IEEE ROUNDING, or IEEE SQRT is accessible, within the scoping unit the processor shall support the
 6    feature and return true from the corresponding inquiry function for at least one kind of real. In the case of
 7    IEEE ROUNDING, it shall return true for all the rounding modes IEEE NEAREST, IEEE TO ZERO,
 8    IEEE UP, and IEEE DOWN.

 9    Execution might be slowed on some processors by the support of some features. If IEEE EXCEPTIONS
10    or IEEE ARITHMETIC is accessed but IEEE FEATURES is not accessed, the supported subset of fea-
11    tures is processor dependent. The processor's fullest support is provided when all of IEEE FEATURES
12    is accessed as in



13           USE, INTRINSIC :: IEEE_ARITHMETIC; USE, INTRINSIC :: IEEE_FEATURES



14    but execution might then be slowed by the presence of a feature that is not needed. In all cases, the
15    extent of support can be determined by the inquiry functions.



16    14.1       Derived types and constants defined in the modules

17    The modules IEEE EXCEPTIONS, IEEE ARITHMETIC, and IEEE FEATURES define five derived
18    types, whose components are all private.

19    The module IEEE EXCEPTIONS defines


20       � IEEE FLAG TYPE, for identifying a particular exception flag. Its only possible values are those
21           of named constants defined in the module: IEEE INVALID, IEEE OVERFLOW, IEEE DIVIDE -
22           BY ZERO, IEEE UNDERFLOW, and IEEE INEXACT. The module also defines the array named
23           constants IEEE USUAL = (/ IEEE OVERFLOW, IEEE DIVIDE BY ZERO, IEEE INVALID /)
24           and IEEE ALL = (/ IEEE USUAL, IEEE UNDERFLOW, IEEE INEXACT /).

25       � IEEE STATUS TYPE, for saving the current floating point status.


26    The module IEEE ARITHMETIC defines


27       � IEEE CLASS TYPE, for identifying a class of floating-point values.             Its only possible values
28           are those of named constants defined in the module:           IEEE SIGNALING NAN, IEEE QUI-
29           ET NAN, IEEE NEGATIVE INF, IEEE NEGATIVE NORMAL, IEEE NEGATIVE DENORM-
30           AL, IEEE NEGATIVE ZERO, IEEE POSITIVE ZERO, IEEE POSITIVE DENORMAL, IEEE -
31           POSITIVE NORMAL, IEEE POSITIVE INF.

32       � IEEE ROUND TYPE, for identifying a particular rounding mode. Its only possible values are
33           those of named constants defined in the module: IEEE NEAREST, IEEE TO ZERO, IEEE UP,
34           and IEEE DOWN for the IEEE modes; and IEEE OTHER for any other mode.

35       � The elemental operator == for two values of one of these types to return true if the values are the
36           same and false otherwise.

37       � The elemental operator /= for two values of one of these types to return true if the values differ
38           and false otherwise.




      356                                  WORKING DRAFT                                             SEP 2002


      SEP 2002                              WORKING DRAFT                                       J3/02-007R3



 1    The module IEEE FEATURES defines


 2       � IEEE FEATURES TYPE, for expressing the need for particular IEEE features. Its only possible
 3         values are those of named constants defined in the module: IEEE DATATYPE, IEEE DENOR-
 4         MAL, IEEE DIVIDE, IEEE HALTING, IEEE INEXACT FLAG, IEEE INF, IEEE INVALID -
 5         FLAG, IEEE NAN, IEEE ROUNDING, IEEE SQRT, and IEEE UNDERFLOW FLAG.



 6    14.2      The exceptions

 7    The exceptions are


 8       � IEEE OVERFLOW

 9         This exception occurs when the result for an intrinsic real operation or assignment has an absolute
10         value greater than a processor-dependent limit, or the real or imaginary part of the result for an
11         intrinsic complex operation or assignment has an absolute value greater than a processor-dependent
12         limit.

13       � IEEE DIVIDE BY ZERO

14         This exception occurs when a real or complex division has a nonzero numerator and a zero denom-
15         inator.

16       � IEEE INVALID

17         This exception occurs when a real or complex operation or assignment is invalid; examples are
18         SQRT(X) when X is real and has a nonzero negative value, and conversion to an integer (by
19         assignment, an intrinsic procedure, or a procedure defined in an intrinsic module) when the result
20         is too large to be representable.

21       � IEEE UNDERFLOW

22         This exception occurs when the result for an intrinsic real operation or assignment has an absolute
23         value less than a processor-dependent limit and loss of accuracy is detected, or the real or imaginary
24         part of the result for an intrinsic complex operation or assignment has an absolute value less than
25         a processor-dependent limit and loss of accuracy is detected.

26       � IEEE INEXACT

27         This exception occurs when the result of a real or complex operation or assignment is not exact.


28    Each exception has a flag whose value is either quiet or signaling. The value can be determined by
29    the function IEEE GET FLAG. Its initial value is quiet and it signals when the associated excep-
30    tion occurs. Its status can also be changed by the subroutine IEEE SET FLAG or the subroutine
31    IEEE SET STATUS. Once signaling within a procedure, it remains signaling unless set quiet by an
32    invocation of the subroutine IEEE SET FLAG or the subroutine IEEE SET STATUS.

33    If a flag is signaling on entry to a procedure, the processor will set it to quiet on entry and restore it to
34    signaling on return.

           NOTE 14.3

           If a flag signals during execution of a procedure, the processor shall not set it to quiet on return.





      SEP 2002                                     WORKING DRAFT                                             357


      J3/02-007R3                                WORKING DRAFT                                     SEP 2002



 1    Evaluation of a specification expression may cause an exception to signal.

 2    In a scoping unit that has access to IEEE EXCEPTIONS or IEEE ARITHMETIC, if an intrinsic
 3    procedure or a procedure defined in an intrinsic module executes normally, the values of the flags
 4    IEEE OVERFLOW, IEEE DIVIDE BY ZERO, and IEEE INVALID shall be as on entry to the proce-
 5    dure, even if one or more signals during the calculation. If a real or complex result is too large for the
 6    procedure to handle, IEEE OVERFLOW may signal. If a real or complex result is a NaN because of an
 7    invalid operation (for example, LOG(-1.0)), IEEE INVALID may signal. Similar rules apply to format
 8    processing and to intrinsic operations: no signaling flag shall be set quiet and no quiet flag shall be set
 9    signaling because of an intermediate calculation that does not affect the result.

             NOTE 14.4

             An implementation may provide alternative versions of an intrinsic procedure; a practical example
             of such alternatives might be one version suitable for a call from a scoping unit with access to
             IEEE EXCEPTIONS or IEEE ARITHMETIC and one for other cases.


10    In a sequence of statements that has no invocations of IEEE GET FLAG, IEEE SET FLAG, IEEE -
11    GET STATUS, IEEE SET HALTING, or IEEE SET STATUS, if the execution of an operation would
12    cause an exception to signal but after execution of the sequence no value of a variable depends on the
13    operation, whether the exception is signaling is processor dependent. For example, when Y has the value
14    zero, whether the code



15            X = 1.0/Y

16            X = 3.0



17    signals IEEE DIVIDE BY ZERO is processor dependent. Another example is the following:



18            REAL, PARAMETER :: X=0.0, Y=6.0

19            IF (1.0/X == Y) PRINT *,'Hello world'



20    where the processor is permitted to discard the IF statement since the logical expression can never be
21    true and no value of a variable depends on it.

22    An exception shall not signal if this could arise only during execution of an operation beyond those
23    required or permitted by the standard. For example, the statement



24            IF (F(X)>0.0) Y = 1.0/Z



25    shall not signal IEEE DIVIDE BY ZERO when both F(X) and Z are zero and the statement



26            WHERE(A>0.0) A = 1.0/A



27    shall not signal IEEE DIVIDE BY ZERO. On the other hand, when X has the value 1.0 and Y has the
28    value 0.0, the expression



29            X>0.00001 .OR. X/Y>0.00001



30    is permitted to cause the signaling of IEEE DIVIDE BY ZERO.



      358                                  WORKING DRAFT                                           SEP 2002


      SEP 2002                                WORKING DRAFT                                    J3/02-007R3



 1    The processor need not support IEEE INVALID, IEEE UNDERFLOW, and IEEE INEXACT. If an
 2    exception is not supported, its flag is always quiet. The function IEEE SUPPORT FLAG can be used
 3    to inquire whether a particular flag is supported.



 4    14.3      The rounding modes

 5    The IEEE standard specifies four rounding modes:


 6       � IEEE NEAREST rounds the exact result to the nearest representable value.

 7       � IEEE TO ZERO rounds the exact result towards zero to the next representable value.

 8       � IEEE UP rounds the exact result towards +infinity to the next representable value.

 9       � IEEE DOWN rounds the exact result towards -infinity to the next representable value.


10    The function IEEE GET ROUNDING MODE can be used to inquire which rounding mode is in opera-
11    tion. Its value is one of the above four or IEEE OTHER if the rounding mode does not conform to the
12    IEEE standard.

13    If the processor supports the alteration of the rounding mode during execution, the subroutine IEEE -
14    SET ROUNDING MODE can be used to alter it. The function IEEE SUPPORT ROUNDING can be
15    used to inquire whether this facility is available for a particular mode. The function IEEE SUPPORT IO
16    can be used to inquire whether rounding for base conversion in formatted input/output (9.4.5.12, 9.5.1.12,
17    10.6.1.2.6) is as specified in the IEEE standard.

18    In a procedure other than IEEE SET ROUNDING MODE or IEEE SET STATUS, the processor shall
19    not change the rounding mode on entry, and on return shall ensure that the rounding mode is the same
20    as it was on entry.

           NOTE 14.5

           Within a program, all literal constants that have the same form have the same value (4.1.2).
           Therefore, the value of a literal constant is not affected by the rounding mode.



21    14.4      Halting

22    Some processors allow control during program execution of whether to abort or continue execution after
23    an exception. Such control is exercised by invocation of the subroutine IEEE SET HALTING MODE.
24    Halting is not precise and may occur any time after the exception has occurred. The function IEEE SUP-
25    PORT HALTING can be used to inquire whether this facility is available. The initial halting mode is
26    processor dependent. In a procedure other than IEEE SET HALTING MODE or IEEE SET STATUS,
27    the processor shall not change the halting mode on entry, and on return shall ensure that the halting
28    mode is the same as it was on entry.



29    14.5      The floating point status

30    The values of all the supported flags for exceptions, rounding mode, and halting are called the floating
31    point status. The floating point status can be saved in a scalar variable of type TYPE(IEEE STATUS -
32    TYPE) with the subroutine IEEE GET STATUS and restored with the subroutine IEEE SET STATUS.
33    There are no facilities for finding the values of particular flags held within such a variable. Portions of




      SEP 2002                                    WORKING DRAFT                                            359


      J3/02-007R3                                 WORKING DRAFT                                       SEP 2002



 1    the floating point status can be saved with the subroutines IEEE GET FLAG, IEEE GET HALTING -
 2    MODE, and IEEE GET ROUNDING MODE, and set with the subroutines IEEE SET FLAG, IEEE -
 3    SET HALTING MODE, and IEEE SET ROUNDING MODE.

             NOTE 14.6

             Some processors hold all these flags in a floating point status register that can be saved and restored
             as a whole much faster than all individual flags can be saved and restored. These procedures are
             provided to exploit this feature.


             NOTE 14.7

             The processor is required to ensure that a call to a Fortran procedure does not change the floating
             point status other than by setting exception flags to signaling. No such requirements can be placed
             on procedures defined by means other than Fortran. For such procedures, it is the responsibility
             of the user to ensure that the floating point status is preserved.



 4    14.6         Exceptional values

 5    The IEEE standard specifies the following exceptional floating point values:


 6       � Denormalized values have very small absolute values and lowered precision.

 7       � Infinite values (+infinity and -infinity) are created by overflow or division by zero.

 8       � Not-a-Number ( NaN) values are undefined values or values created by an invalid operation.


 9    In this standard, the term normal is used for values that are not in one of these exceptional classes.

10    The functions IEEE IS FINITE, IEEE IS NAN, IEEE IS NEGATIVE, and IEEE IS NORMAL are pro-
11    vided to test whether a value is finite, NaN, negative, or normal. The function IEEE VALUE is pro-
12    vided to generate an IEEE number of any class, including an infinity or a NaN. The functions IEEE -
13    SUPPORT DENORMAL, IEEE SUPPORT INF, and IEEE SUPPORT NAN are provided to determine
14    whether these facilities are available for a particular kind of real.



15    14.7         IEEE arithmetic

16    The function IEEE SUPPORT DATATYPE can be used to inquire whether IEEE arithmetic is avail-
17    able for a particular kind of real. Complete conformance with the IEEE standard is not required,
18    but the normalized numbers shall be exactly those of IEEE single or IEEE double; the arithmetic
19    operators shall be implemented with at least one of the IEEE rounding modes; and the functions copy-
20    sign, scalb, logb, nextafter, rem, and unordered shall be provided by the functions IEEE COPY SIGN,
21    IEEE SCALB, IEEE LOGB, IEEE NEXT AFTER, IEEE REM, and IEEE UNORDERED. The in-
22    quiry function IEEE SUPPORT DIVIDE is provided to inquire whether the processor supports divide
23    with the accuracy specified by the IEEE standard. For each of the other arithmetic operators and for
24    each implemented IEEE rounding mode, the result shall be as specified in the IEEE standard whenever
25    the operands and IEEE result are normalized.

26    The inquiry function IEEE SUPPORT NAN is provided to inquire whether the processor supports
27    IEEE NaNs. Where these are supported, their behavior for unary and binary operations, including
28    those defined by intrinsic functions and by functions in intrinsic modules, is as specified in the IEEE
29    standard.




      360                                   WORKING DRAFT                                             SEP 2002


      SEP 2002                              WORKING DRAFT                                        J3/02-007R3



 1    The inquiry function IEEE SUPPORT INF is provided to inquire whether the processor supports IEEE
 2    infinities. Where these are supported, their behavior for unary and binary operations, including those
 3    defined by intrinsic functions and by functions in intrinsic modules, is as specified in the IEEE standard.

 4    The IEEE standard specifies a square root function that returns -0.0 for the square root of -0.0 and has
 5    certain accuracy requirements. The function IEEE SUPPORT SQRT can be used to inquire whether
 6    SQRT is implemented in accord with the IEEE standard for a particular kind of real.

 7    The inquiry function IEEE SUPPORT STANDARD is provided to inquire whether the processor sup-
 8    ports all the IEEE facilities defined in this standard for a particular kind of real.



 9    14.8       Tables of the procedures

10    For all of the procedures defined in the modules, the arguments shown are the names that shall be used
11    for argument keywords if the keyword form is used for the actual arguments.

12    The procedure classification terms "inquiry function" and "transformational function" are used here
13    with the same meanings as in 13.1.


14    14.8.1     Inquiry functions

15    The module IEEE EXCEPTIONS contains the following inquiry functions:

16        IEEE SUPPORT FLAG (FLAG [, X])                     Inquire whether the processor supports an
17                                                                exception.
18        IEEE SUPPORT HALTING (FLAG)                        Inquire whether the processor supports control of
19                                                                halting after an exception.

20    The module IEEE ARITHMETIC contains the following inquiry functions:

21        IEEE SUPPORT DATATYPE ([X])                        Inquire whether the processor supports IEEE
22                                                                arithmetic.
23        IEEE SUPPORT DENORMAL ([X])                        Inquire whether the processor supports
24                                                                denormalized numbers.
25        IEEE SUPPORT DIVIDE ([X])                          Inquire whether the processor supports divide
26                                                                with the accuracy specified by the IEEE
27                                                                standard.
28        IEEE SUPPORT INF ([X])                             Inquire whether the processor supports the IEEE
29                                                                infinity.
30        IEEE SUPPORT IO ([X])                              Inquire whether the processor supports IEEE
31                                                                base conversion rounding during formatted
32                                                                input/output.
33        IEEE SUPPORT NAN ([X])                             Inquire whether the processor supports the IEEE
34                                                                Not-a-Number.
          IEEE SUPPORT ROUNDING                              Inquire whether the processor supports a
35              (ROUND VALUE [, X])
36                                                                particular rounding mode,
37        IEEE SUPPORT SQRT ([X])                            Inquire whether the processor supports IEEE
38                                                                square root.
39        IEEE SUPPORT STANDARD ([X])                        Inquire whether processor supports all IEEE
40                                                                facilities.





      SEP 2002                                    WORKING DRAFT                                             361


      J3/02-007R3                           WORKING DRAFT                                     SEP 2002


 1    14.8.2     Elemental functions

 2    The module IEEE ARITHMETIC contains the following elemental functions for reals X and Y for which
 3    IEEE SUPPORT DATATYPE(X) and IEEE SUPPORT DATATYPE(Y) are true:

 4       IEEE CLASS (X)                                 IEEE class.
 5       IEEE COPY SIGN (X,Y)                           IEEE copysign function.
 6       IEEE IS FINITE (X)                             Determine if value is finite.
 7       IEEE IS NAN (X)                                Determine if value is IEEE Not-a-Number.
 8       IEEE IS NORMAL (X)                             Determine if a value is normal, that is, neither an
 9                                                          infinity, a NaN, nor denormalized.
10       IEEE IS NEGATIVE (X)                           Determine if value is negative.
11       IEEE LOGB (X)                                  Unbiased exponent in the IEEE floating point
12                                                          format.
13       IEEE NEXT AFTER (X,Y)                          Returns the next representable neighbor of X in
14                                                          the direction toward Y.
15       IEEE REM (X,Y)                                 The IEEE REM function, that is X - Y*N, where
16                                                          N is the integer nearest to the exact value
17                                                          X/Y.
18       IEEE RINT (X)                                  Round to an integer value according to the
19                                                          current rounding mode.
20       IEEE SCALB (X,I)                               Returns X � 2I .
21       IEEE UNORDERED (X,Y)                           IEEE unordered function. True if X or Y is a
22                                                          NaN and false otherwise.
23       IEEE VALUE (X,CLASS)                           Generate an IEEE value.


24    14.8.3     Kind function

25    The module IEEE ARITHMETIC contains the following transformational function:

26       IEEE SELECTED REAL KIND ([P,][R])              Kind type parameter value for an IEEE real with
27                                                          given precision and range.


28    14.8.4     Elemental subroutines

29    The module IEEE EXCEPTIONS contains the following elemental subroutines:

30       IEEE GET FLAG (FLAG,FLAG VALUE)                Get an exception flag.
         IEEE GET HALTING MODE (FLAG,                   Get halting mode for an exception.
31              HALTING)


32    14.8.5     Nonelemental subroutines

33    The module IEEE EXCEPTIONS contains the following nonelemental subroutines:

34       IEEE GET STATUS (STATUS VALUE)                 Get the current state of the floating point
35                                                          environment.
36       IEEE SET FLAG (FLAG,FLAG VALUE)                Set an exception flag.
         IEEE SET HALTING MODE (FLAG,                   Controls continuation or halting on exceptions.
37              HALTING)
38       IEEE SET STATUS (STATUS VALUE)                 Restore the state of the floating point
39                                                          environment.

40    The module IEEE ARITHMETIC contains the following nonelemental subroutines:





      362                              WORKING DRAFT                                          SEP 2002


      SEP 2002                                 WORKING DRAFT                                 J3/02-007R3



          IEEE GET ROUNDING MODE                              Get the current IEEE rounding mode.
 1               (ROUND VALUE)
          IEEE SET ROUNDING MODE                              Set the current IEEE rounding mode.
 2               (ROUND VALUE)


 3    14.9        Specifications of the procedures

 4    In the detailed descriptions below, procedure names are generic and are not specific. All the functions
 5    are pure. The dummy arguments of the intrinsic module procedures in 14.8.1, 14.8.2, and 14.8.3 have
 6    INTENT(IN). The dummy arguments of the intrinsic module procedures in 14.8.4 and 14.8.5 have
 7    INTENT(IN) if the intent is not stated explicitly. In the examples, it is assumed that the processor
 8    supports IEEE arithmetic for default real.

           NOTE 14.8

           It is intended that a processor should not check a condition given in a paragraph labeled
           "Restriction" at compile time, but rather should rely on the programmer writing code such
           as


                   IF (IEEE_SUPPORT_DATATYPE(X)) THEN

                      C = IEEE_CLASS(X)

                   ELSE

                      .

                      .

                   ENDIF


           to avoid a call being made on a processor for which the condition is violated.


 9    For the elemental functions of IEEE ARITHMETIC, as tabulated in 14.8.2, if X or Y has a value that
10    is an infinity or a NaN, the result shall be consistent with the general rules in 6.1 and 6.2 of the IEEE
11    standard. For example, the result for an infinity shall be constructed as the limiting case of the result
12    with a value of arbitrarily large magnitude, if such a limit exists.


13    14.9.1          IEEE CLASS (X)

14               Description. IEEE class function.

15               Class. Elemental function.

16               Argument. X shall be of type real.

17               Restriction. IEEE CLASS(X) shall not be invoked if IEEE SUPPORT DATATYPE(X) has
18               the value false.

19               Result Characteristics. TYPE(IEEE CLASS TYPE).

20               Result Value. The result value is one of IEEE SIGNALING NAN, IEEE QUIET NAN, IEEE-
21               NEGATIVE INF, IEEE NEGATIVE NORMAL, IEEE NEGATIVE DENORMAL, IEEE -
22               NEGATIVE ZERO, IEEE POSITIVE ZERO, IEEE POSITIVE DENORMAL, IEEE POSI-
23               TIVE NORMAL, or IEEE POSITIVE INF. Neither of the values IEEE SIGNALING NAN and
24               IEEE QUIET NAN shall be returned unless IEEE SUPPORT NAN(X) has the value true. Nei-
25               ther of the values IEEE NEGATIVE INF and IEEE POSITIVE INF shall be returned unless
26               IEEE SUPPORT INF(X) has the value true. Neither of the values IEEE NEGATIVE DENOR-
27               MAL and IEEE POSITIVE DENORMAL shall be returned unless IEEE SUPPORT DENOR-




      SEP 2002                                      WORKING DRAFT                                        363


      J3/02-007R3                               WORKING DRAFT                                         SEP 2002



 1              MAL(X) has the value true.

 2              Example. IEEE CLASS(-1.0) has the value IEEE NEGATIVE NORMAL.


 3    14.9.2         IEEE COPY SIGN (X, Y)

 4              Description. IEEE copysign function.

 5              Class. Elemental function.

 6              Arguments. The arguments shall be of type real.

 7              Restriction.    IEEE COPY SIGN(X,Y) shall not be invoked if IEEE SUPPORT DATA-
 8              TYPE(X) or IEEE SUPPORT DATATYPE(Y) has the value false.

 9              Result Characteristics. Same as X.

10              Result Value. The result has the value of X with the sign of Y. This is true even for IEEE
11              special values, such as a NaN or an infinity (on processors supporting such values).

12              Example. The value of IEEE COPY SIGN(X,1.0) is ABS(X) even when X is NaN.


13    14.9.3         IEEE GET FLAG (FLAG, FLAG VALUE)

14              Description. Get an exception flag.

15              Class. Elemental subroutine.

16              Arguments.

                FLAG              shall be of type TYPE(IEEE FLAG TYPE). It specifies the IEEE flag to be
17                                obtained.

                FLAG VALUE        shall be of type default logical. It is an INTENT(OUT) argument. If the value
                                  of FLAG is IEEE INVALID, IEEE OVERFLOW, IEEE DIVIDE BY ZERO,
                                  IEEE UNDERFLOW, or IEEE INEXACT, the result value is true if the
18                                corresponding exception flag is signaling and is false otherwise.

19              Example. Following CALL IEEE GET FLAG(IEEE OVERFLOW,FLAG VALUE), FLAG -
20              VALUE is true if the IEEE OVERFLOW flag is signaling and is false if it is quiet.


21    14.9.4         IEEE GET HALTING MODE (FLAG, HALTING)

22              Description. Get halting mode for an exception.

23              Class. Elemental subroutine.

24              Arguments.

                FLAG              shall be of type TYPE(IEEE FLAG TYPE). It specifies the IEEE flag. It
                                  shall have one of the values IEEE INVALID, IEEE OVERFLOW, IEEE -
25                                DIVIDE BY ZERO, IEEE UNDERFLOW, or IEEE INEXACT.

                HALTING           shall be of type default logical. It is of INTENT(OUT). The value is true if
                                  the exception specified by FLAG will cause halting. Otherwise, the value is
26                                false.

27              Example. To store the halting mode for IEEE OVERFLOW, do a calculation without halting,
28              and restore the halting mode later:




      364                                   WORKING DRAFT                                             SEP 2002


      SEP 2002                              WORKING DRAFT                                   J3/02-007R3



 1                 USE, INTRINSIC :: IEEE_ARITHMETIC

 2                 LOGICAL HALTING

 3                   ...

 4                 CALL IEEE_GET_HALTING_MODE(IEEE_OVERFLOW,HALTING) ! Store halting mode

 5                 CALL IEEE_SET_HALTING_MODE(IEEE_OVERFLOW,.FALSE.) ! No halting

 6                   ...! calculation without halting

 7                 CALL IEEE_SET_HALTING_MODE(IEEE_OVERFLOW,HALTING) ! Restore halting mode



 8    14.9.5         IEEE GET ROUNDING MODE (ROUND VALUE)

 9              Description. Get the current IEEE rounding mode.

10              Class. Subroutine.

11              Argument. ROUND VALUE shall be scalar of type TYPE(IEEE ROUND TYPE). It is an IN-
12              TENT(OUT) argument and returns the floating point rounding mode, with value IEEE NEAR-
13              EST, IEEE TO ZERO, IEEE UP, or IEEE DOWN if one of the IEEE modes is in operation
14              and IEEE OTHER otherwise.

15              Example. To store the rounding mode, do a calculation with round to nearest, and restore the
16              rounding mode later:



17                 USE, INTRINSIC :: IEEE_ARITHMETIC

18                 TYPE(IEEE_ROUND_TYPE) ROUND_VALUE

19                   ...

20                 CALL IEEE_GET_ROUNDING_MODE(ROUND_VALUE) ! Store the rounding mode

21                 CALL IEEE_SET_ROUNDING_MODE(IEEE_NEAREST)

22                   ... ! calculation with round to nearest

23                 CALL IEEE_SET_ROUNDING_MODE(ROUND_VALUE) ! Restore the rounding mode



24    14.9.6         IEEE GET STATUS (STATUS VALUE)

25              Description. Get the current value of the floating point status (14.5).

26              Class. Subroutine.

27              Argument. STATUS VALUE shall be scalar of type TYPE(IEEE STATUS TYPE). It is an
28              INTENT(OUT) argument and returns the floating point status.

29              Example. To store all the exception flags, do a calculation involving exception handling, and
30              restore them later:



31                 USE, INTRINSIC :: IEEE_ARITHMETIC

32                 TYPE(IEEE_STATUS_TYPE) STATUS_VALUE

33                   ...

34                 CALL IEEE_GET_STATUS(STATUS_VALUE) ! Get the flags

35                 CALL IEEE_SET_FLAG(IEEE_ALL,.FALSE.) ! Set the flags quiet.

36                   ... ! calculation involving exception handling

37                 CALL IEEE_SET_STATUS(STATUS_VALUE) ! Restore the flags




      SEP 2002                                    WORKING DRAFT                                        365


      J3/02-007R3                               WORKING DRAFT                                    SEP 2002


 1    14.9.7              IEEE IS FINITE (X)

 2              Description. Determine if a value is finite.

 3              Class. Elemental function.

 4              Argument. X shall be of type real.

 5              Restriction. IEEE IS FINITE(X) shall not be invoked if IEEE SUPPORT DATATYPE(X)
 6              has the value false.

 7              Result Characteristics. Default logical.

 8              Result Value. The result has the value true if the value of X is finite, that is, IEEE CLASS(X)
 9              has one of the values IEEE NEGATIVE NORMAL, IEEE NEGATIVE DENORMAL, IEEE -
10              NEGATIVE ZERO, IEEE POSITIVE ZERO, IEEE POSITIVE DENORMAL, or IEEE POS-
11              ITIVE NORMAL; otherwise, the result has the value false.

12              Example. IEEE IS FINITE(1.0) has the value true.


13    14.9.8              IEEE IS NAN (X)

14              Description. Determine if a value is IEEE Not-a-Number.

15              Class. Elemental function.

16              Argument. X shall be of type real.

17              Restriction. IEEE IS NAN(X) shall not be invoked if IEEE SUPPORT NAN(X) has the value
18              false.

19              Result Characteristics. Default logical.

20              Result Value. The result has the value true if the value of X is an IEEE NaN; otherwise, it
21              has the value false.

22              Example. IEEE IS NAN(SQRT(-1.0)) has the value true if IEEE SUPPORT SQRT(1.0) has
23              the value true.


24    14.9.9              IEEE IS NEGATIVE (X)

25              Description. Determine if a value is negative.

26              Class. Elemental function.

27              Argument. X shall be of type real.

28              Restriction.       IEEE IS NEGATIVE(X) shall not be invoked if IEEE SUPPORT DATA-
29              TYPE(X) has the value false.

30              Result Characteristics. Default logical.

31              Result Value.       The result has the value true if IEEE CLASS(X) has one of the values
32              IEEE NEGATIVE NORMAL, IEEE NEGATIVE DENORMAL, IEEE NEGATIVE ZERO or
33              IEEE NEGATIVE INF; otherwise, the result has the value false.

34              Example. IEEE IS NEGATIVE(0.0)) has the value false.


35    14.9.10             IEEE IS NORMAL (X)



      366                                  WORKING DRAFT                                         SEP 2002


      SEP 2002                             WORKING DRAFT                                      J3/02-007R3



 1          Description. Determine if a value is normal, that is, neither an infinity, a NaN, nor denormal-
 2          ized.

 3          Class. Elemental function.

 4          Argument. X shall be of type real.

 5          Restriction. IEEE IS NORMAL(X) shall not be invoked if IEEE SUPPORT DATATYPE(X)
 6          has the value false.

 7          Result Characteristics. Default logical.

 8          Result Value.         The result has the value true if IEEE CLASS(X) has one of the values
 9          IEEE NEGATIVE NORMAL, IEEE NEGATIVE ZERO, IEEE POSITIVE ZERO or IEEE -
10          POSITIVE NORMAL; otherwise, the result has the value false.

11          Example. IEEE IS NORMAL(SQRT(-1.0)) has the value false if IEEE SUPPORT SQRT(1.0)
12          has the value true.


13    14.9.11        IEEE LOGB (X)

14          Description. Unbiased exponent in the IEEE floating point format.

15          Class. Elemental function.

16          Argument. X shall be of type real.

17          Restriction. IEEE LOGB(X) shall not be invoked if IEEE SUPPORT DATATYPE(X) has
18          the value false.

19          Result Characteristics. Same as X.

20          Result Value.

21          Case (i):       If the value of X is neither zero, infinity, nor NaN, the result has the value of the
22                          unbiased exponent of X. Note: this value is equal to EXPONENT(X)-1.

23          Case (ii):      If X==0, the result is -infinity if IEEE SUPPORT INF(X) is true and -HUGE(X)
24                          otherwise; IEEE DIVIDE BY ZERO signals.


25          Example. IEEE LOGB(-1.1) has the value 0.0.


26    14.9.12        IEEE NEXT AFTER (X, Y)

27          Description. Returns the next representable neighbor of X in the direction toward Y.

28          Class. Elemental function.

29          Arguments. The arguments shall be of type real.

30          Restriction.        IEEE NEXT AFTER(X,Y) shall not be invoked if IEEE SUPPORT DATA-
31          TYPE(X) or IEEE SUPPORT DATATYPE(Y) has the value false.

32          Result Characteristics. Same as X.

33          Result Value.

34          Case (i):       If X == Y, the result is X and no exception is signaled.

35          Case (ii):      If X /= Y, the result has the value of the next representable neighbor of X
36                          in the direction of Y. The neighbors of zero (of either sign) are both nonzero.




      SEP 2002                                   WORKING DRAFT                                             367


      J3/02-007R3                                 WORKING DRAFT                                 SEP 2002



 1                           IEEE OVERFLOW is signaled when X is finite but IEEE NEXT AFTER(X,Y)
 2                           is infinite; IEEE UNDERFLOW is signaled when IEEE NEXT AFTER(X,Y) is
 3                           denormalized; in both cases, IEEE INEXACT signals.


 4           Example. The value of IEEE NEXT AFTER(1.0,2.0) is 1.0+EPSILON(X).


 5    14.9.13     IEEE REM (X, Y)

 6           Description. IEEE REM function.

 7           Class. Elemental function.

 8           Arguments. The arguments shall be of type real.

 9           Restriction. IEEE REM(X,Y) shall not be invoked if IEEE SUPPORT DATATYPE(X) or
10           IEEE SUPPORT DATATYPE(Y) has the value false.

11           Result Characteristics. Real with the kind type parameter of whichever argument has the
12           greater precision.

13           Result Value. The result value, regardless of the rounding mode, shall be exactly X - Y*N,
14           where N is the integer nearest to the exact value X/Y; whenever |N - X/Y| = 1/2, N shall be
15           even. If the result value is zero, the sign shall be that of X.

16           Examples. The value of IEEE REM(4.0,3.0) is 1.0, the value of IEEE REM(3.0,2.0) is -1.0,
17           and the value of IEEE REM(5.0,2.0) is 1.0.


18    14.9.14     IEEE RINT (X)

19           Description. Round to an integer value according to the current rounding mode.

20           Class. Elemental function.

21           Argument. X shall be of type real.

22           Restriction. IEEE RINT(X) shall not be invoked if IEEE SUPPORT DATATYPE(X) has the
23           value false.

24           Result Characteristics. Same as X.

25           Result Value. The value of the result is the value of X rounded to an integer according to the
26           current rounding mode. If the result has the value zero, the sign is that of X.

27           Examples. If the current rounding mode is round to nearest, the value of IEEE RINT(1.1) is
28           1.0. If the current rounding mode is round up, the value of IEEE RINT(1.1) is 2.0.


29    14.9.15     IEEE SCALB (X, I)

30           Description. Returns X � 2I .

31           Class. Elemental function.

32           Arguments.

33           X                     shall be of type real.

34           I                     shall be of type integer.





      368                                   WORKING DRAFT                                       SEP 2002


      SEP 2002                             WORKING DRAFT                                        J3/02-007R3



 1          Restriction. IEEE SCALB(X) shall not be invoked if IEEE SUPPORT DATATYPE(X) has
 2          the value false.

 3          Result Characteristics. Same as X.

 4          Result Value.

 5          Case (i):       If X � 2I is representable as a normal number, the result has this value.

 6          Case (ii):      If X is finite and X � 2I is too large, the IEEE OVERFLOW exception shall
 7                          occur. If IEEE SUPPORT INF(X) is true, the result value is infinity with the
 8                          sign of X; otherwise, the result value is SIGN(HUGE(X),X).

 9          Case (iii):     If X � 2I is too small and there is loss of accuracy, the IEEE UNDERFLOW
10                          exception shall occur. The result is the representable number having a magnitude
11                          nearest to |2I | and the same sign as X.

12          Case (iv):      If X is infinite, the result is the same as X; no exception signals.


13          Example. The value of IEEE SCALB(1.0,2) is 4.0.

14    14.9.16     IEEE SELECTED REAL KIND ([P, R])

15          Description. Returns a value of the kind type parameter of an IEEE real data type with
16          decimal precision of at least P digits and a decimal exponent range of at least R. For data
17          objects of such a type, IEEE SUPPORT DATATYPE(X) has the value true.

18          Class. Transformational function.

19          Arguments. At least one argument shall be present.

20          P (optional)        shall be scalar and of type integer.

21          R (optional)        shall be scalar and of type integer.

22          Result Characteristics. Default integer scalar.

23          Result Value. The result has a value equal to a value of the kind type parameter of an IEEE
24          real type with decimal precision, as returned by the function PRECISION, of at least P digits
25          and a decimal exponent range, as returned by the function RANGE, of at least R, or if no such
26          kind type parameter is available on the processor, the result is -1 if the precision is not available,
27          -2 if the exponent range is not available, and -3 if neither is available. If more than one kind
28          type parameter value meets the criteria, the value returned is the one with the smallest decimal
29          precision, unless there are several such values, in which case the smallest of these kind values is
30          returned.

31          Example. IEEE SELECTED REAL KIND(6,70) has the value KIND(0.0) on a machine that
32          supports IEEE single precision arithmetic for its default real approximation method.

33    14.9.17     IEEE SET FLAG (FLAG, FLAG VALUE)

34          Description. Assign a value to an exception flag.

35          Class. Subroutine.

36          Arguments.

            FLAG                shall be a scalar or array of type TYPE(IEEE FLAG TYPE). If a value of
                                FLAG is IEEE INVALID, IEEE OVERFLOW, IEEE DIVIDE BY ZERO,
                                IEEE UNDERFLOW, or IEEE INEXACT, the corresponding exception flag
37                              is assigned a value. No two elements of FLAG shall have the same value.



      SEP 2002                                   WORKING DRAFT                                               369


      J3/02-007R3                                 WORKING DRAFT                                       SEP 2002



                FLAG VALUE         shall be a scalar or array of type default logical. It shall be conformable with
                                   FLAG. If an element has the value true, the corresponding flag is set to be
 1                                 signaling; otherwise, the flag is set to be quiet.

 2              Example. CALL IEEE SET FLAG(IEEE OVERFLOW,.TRUE.) sets the IEEE OVERFLOW
 3              flag to be signaling.


 4    14.9.18        IEEE SET HALTING MODE (FLAG, HALTING)

 5              Description. Controls continuation or halting after an exception.

 6              Class. Subroutine.

 7              Arguments.

                FLAG               shall be a scalar or array of type TYPE(IEEE FLAG TYPE). It shall have
                                   only the values IEEE INVALID, IEEE OVERFLOW, IEEE DIVIDE BY -
                                   ZERO, IEEE UNDERFLOW, or IEEE INEXACT. No two elements of FLAG
 8                                 shall have the same value.

                HALTING            shall be a scalar or array of type default logical. It shall be conformable
                                   with FLAG. If an element has the value is true, the corresponding exception
                                   specified by FLAG will cause halting. Otherwise, execution will continue
 9                                 after this exception.

10              Restriction. IEEE SET HALTING MODE(FLAG,HALTING) shall not be invoked if IEEE -
11              SUPPORT HALTING(FLAG) has the value false.

12              Example.     CALL IEEE SET HALTING MODE(IEEE DIVIDE BY ZERO,.TRUE.) causes
13              halting after a divide by zero exception.

             NOTE 14.9

             The initial halting mode is processor dependent. Halting is not precise and may occur some time
             after the exception has occurred.


14    14.9.19        IEEE SET ROUNDING MODE (ROUND VALUE)

15              Description. Set the current IEEE rounding mode.

16              Class. Subroutine.

17              Argument. ROUND VALUE shall be scalar and of type TYPE(IEEE ROUND TYPE). It
18              specifies the mode to be set.

19              Restriction.    IEEE SET ROUNDING MODE(ROUND VALUE) shall not be invoked un-
20              less IEEE SUPPORT ROUNDING(ROUND VALUE,X) is true for some X such that IEEE -
21              SUPPORT DATATYPE(X) is true.

22              Example. To store the rounding mode, do a calculation with round to nearest, and restore the
23              rounding mode later:



24                  USE, INTRINSIC :: IEEE_ARITHMETIC

25                  TYPE(IEEE_ROUND_TYPE) ROUND_VALUE

26                   ...

27                  CALL IEEE_GET_ROUNDING_MODE(ROUND_VALUE) ! Store the rounding mode




      370                                  WORKING DRAFT                                              SEP 2002


      SEP 2002                          WORKING DRAFT                                    J3/02-007R3



 1               CALL IEEE_SET_ROUNDING_MODE(IEEE_NEAREST)

 2               : ! calculation with round to nearest

 3               CALL IEEE_SET_ROUNDING_MODE(ROUND_VALUE) ! Restore the rounding mode



 4    14.9.20     IEEE SET STATUS (STATUS VALUE)

 5          Description. Restore the value of the floating point status (14.5).

 6          Class. Subroutine.

 7          Argument. STATUS VALUE shall be scalar and of type TYPE(IEEE STATUS TYPE). Its
 8          value shall have been set in a previous invocation of IEEE GET STATUS.

 9          Example. To store all the exceptions flags, do a calculation involving exception handling, and
10          restore them later:



11               USE, INTRINSIC :: IEEE_EXCEPTIONS

12               TYPE(IEEE_STATUS_TYPE) STATUS_VALUE

13                ...

14               CALL IEEE_GET_STATUS(STATUS_VALUE) ! Store the flags

15               CALL IEEE_SET_FLAGS(IEEE_ALL,.FALSE.) ! Set them quiet

16                ... ! calculation involving exception handling

17               CALL IEEE_SET_STATUS(STATUS_VALUE) ! Restore the flags



         NOTE 14.10

         On some processors this may be a very time consuming process.


18    14.9.21     IEEE SUPPORT DATATYPE () or IEEE SUPPORT DATATYPE (X)

19          Description. Inquire whether the processor supports IEEE arithmetic.

20          Class. Inquiry function.

21          Argument. X shall be of type real. It may be a scalar or an array.

22          Result Characteristics. Default logical scalar.

23          Result Value. The result has the value true if the processor supports IEEE arithmetic for all
24          reals (X absent) or for real variables of the same kind type parameter as X; otherwise, it has
25          the value false. Here, support means using an IEEE data format and performing the binary
26          operations of +, -, and * as in the IEEE standard whenever the operands and result all have
27          normal values.

28          Example. If default reals are implemented as in the IEEE standard except that underflow values
29          flush to zero instead of being denormal, IEEE SUPPORT DATATYPE(1.0) has the value true.


30    14.9.22     IEEE SUPPORT DENORMAL () or IEEE SUPPORT DENORMAL (X)

31          Description. Inquire whether the processor supports IEEE denormalized numbers.

32          Class. Inquiry function.

33          Argument. X shall be of type real. It may be a scalar or an array.



      SEP 2002                                WORKING DRAFT                                          371


      J3/02-007R3                                   WORKING DRAFT                                       SEP 2002



 1              Result Characteristics. Default logical scalar.

 2              Result Value.

 3              Case (i):         IEEE SUPPORT DENORMAL(X) has the value true if IEEE SUPPORT -
 4                                DATATYPE(X) has the value true and the processor supports arithmetic op-
 5                                erations and assignments with denormalized numbers (biased exponent e = 0
 6                                and fraction f = 0, see section 3.2 of the IEEE standard) for real variables of the
 7                                same kind type parameter as X; otherwise, it has the value false.

 8              Case (ii):        IEEE SUPPORT DENORMAL() has the value true if and only if IEEE SUP-
 9                                PORT DENORMAL(X) has the value true for all real X.


10              Example.         IEEE SUPPORT DENORMAL(X) has the value true if the processor supports
11              denormalized numbers for X.

             NOTE 14.11

             The denormalized numbers are not included in the 13.4 model for real numbers; they satisfy the
             inequality ABS(X) < TINY(X). They usually occur as a result of an arithmetic operation whose
             exact result is less than TINY(X). Such an operation causes IEEE UNDERFLOW to signal unless
             the result is exact. IEEE SUPPORT DENORMAL(X) is false if the processor never returns a
             denormalized number as the result of an arithmetic operation.


12    14.9.23        IEEE SUPPORT DIVIDE () or IEEE SUPPORT DIVIDE (X)

13              Description. Inquire whether the processor supports divide with the accuracy specified by the
14              IEEE standard.

15              Class. Inquiry function.

16              Argument. X shall be of type real. It may be a scalar or an array.

17              Result Characteristics. Default logical scalar.

18              Result Value.

19              Case (i):         IEEE SUPPORT DIVIDE(X) has the value true if the processor supports divide
20                                with the accuracy specified by the IEEE standard for real variables of the same
21                                kind type parameter as X; otherwise, it has the value false.

22              Case (ii):        IEEE SUPPORT DIVIDE() has the value true if and only if IEEE SUPPORT -
23                                DIVIDE(X) has the value true for all real X.


24              Example. IEEE SUPPORT DIVIDE(X) has the value true if the processor supports IEEE
25              divide for X.


26    14.9.24        IEEE SUPPORT FLAG (FLAG) or IEEE SUPPORT FLAG (FLAG, X)

27              Description. Inquire whether the processor supports an exception.

28              Class. Inquiry function.

29              Arguments.

                FLAG                  shall be scalar and of type TYPE(IEEE FLAG TYPE). Its value shall
                                      be one of IEEE INVALID, IEEE OVERFLOW, IEEE DIVIDE BY ZERO,
30                                    IEEE UNDERFLOW, or IEEE INEXACT.

31              X                     shall be of type real. It may be a scalar or an array.



      372                                     WORKING DRAFT                                             SEP 2002


      SEP 2002                              WORKING DRAFT                                  J3/02-007R3



 1          Result Characteristics. Default logical scalar.

 2          Result Value.

 3          Case (i):     IEEE SUPPORT FLAG(FLAG, X) has the value true if the processor supports
 4                        detection of the specified exception for real variables of the same kind type pa-
 5                        rameter as X; otherwise, it has the value false.

 6          Case (ii):    IEEE SUPPORT FLAG(FLAG) has the value true if and only if IEEE SUP-
 7                        PORT FLAG(FLAG, X) has the value true for all real X.


 8          Example. IEEE SUPPORT FLAG(IEEE INEXACT) has the value true if the processor sup-
 9          ports the inexact exception.


10    14.9.25     IEEE SUPPORT HALTING (FLAG)

11          Description. Inquire whether the processor supports the ability to control during program
12          execution whether to abort or continue execution after an exception.

13          Class. Inquiry function.

14          Argument. FLAG shall be scalar and of type TYPE(IEEE FLAG TYPE). Its value shall be
15          one of IEEE INVALID, IEEE OVERFLOW, IEEE DIVIDE BY ZERO, IEEE UNDERFLOW,
16          or IEEE INEXACT.

17          Result Characteristics. Default logical scalar.

18          Result Value. The result has the value true if the processor supports the ability to control
19          during program execution whether to abort or continue execution after the exception specified
20          by FLAG; otherwise, it has the value false. Support includes the ability to change the mode by
21          CALL IEEE SET HALTING(FLAG).

22          Example. IEEE SUPPORT HALTING(IEEE OVERFLOW) has the value true if the proces-
23          sor supports control of halting after an overflow.


24    14.9.26     IEEE SUPPORT INF () or IEEE SUPPORT INF (X)

25          Description. Inquire whether the processor supports the IEEE infinity facility.

26          Class. Inquiry function.

27          Argument. X shall be of type real. It may be a scalar or an array.

28          Result Characteristics. Default logical scalar.

29          Result Value.

30          Case (i):     IEEE SUPPORT INF(X) has the value true if the processor supports IEEE in-
31                        finities (positive and negative) for real variables of the same kind type parameter
32                        as X; otherwise, it has the value false.

33          Case (ii):    IEEE SUPPORT INF() has the value true if and only if IEEE SUPPORT -
34                        INF(X) has the value true for all real X.


35          Example. IEEE SUPPORT INF(X) has the value true if the processor supports IEEE infinities
36          for X.


37    14.9.27     IEEE SUPPORT IO () or IEEE SUPPORT IO (X)





      SEP 2002                                 WORKING DRAFT                                           373


      J3/02-007R3                               WORKING DRAFT                                 SEP 2002



 1           Description. Inquire whether the processor supports IEEE base conversion rounding during
 2           formatted input/output (9.4.5.12, 9.5.1.12, 10.6.1.2.6).

 3           Class. Inquiry function.

 4           Argument. X shall be of type real. It may be a scalar or an array.

 5           Result Characteristics. Default logical scalar.

 6           Result Value.

 7           Case (i):     IEEE SUPPORT IO(X) has the value true if the processor supports IEEE base
 8                         conversion during formatted input/output (9.4.5.12, 9.5.1.12, 10.6.1.2.6) as de-
 9                         scribed in the IEEE standard for the modes UP, DOWN, ZERO, and NEAREST
10                         for real variables of the same kind type parameter as X; otherwise, it has the
11                         value false.

12           Case (ii):    IEEE SUPPORT IO() has the value true if and only if IEEE SUPPORT IO(X)
13                         has the value true for all real X.


14           Example. IEEE SUPPORT IO(X) has the value true if the processor supports IEEE base
15           conversion for X.


16    14.9.28     IEEE SUPPORT NAN () or IEEE SUPPORT NAN (X)

17           Description. Inquire whether the processor supports the IEEE Not-a-Number facility.

18           Class. Inquiry function.

19           Argument. X shall be of type real. It may be a scalar or an array.

20           Result Characteristics. Default logical scalar.

21           Result Value.

22           Case (i):     IEEE SUPPORT NAN(X) has the value true if the processor supports IEEE
23                         NaNs for real variables of the same kind type parameter as X; otherwise, it has
24                         the value false.

25           Case (ii):    IEEE SUPPORT NAN() has the value true if and only if IEEE SUPPORT -
26                         NAN(X) has the value true for all real X.


27           Example. IEEE SUPPORT NAN(X) has the value true if the processor supports IEEE NaNs
28           for X.


      14.9.29     IEEE SUPPORT ROUNDING (ROUND VALUE) or

29                IEEE SUPPORT ROUNDING (ROUND VALUE, X)

30           Description. Inquire whether the processor supports a particular IEEE rounding mode.

31           Class. Inquiry function.

32           Arguments.

33           ROUND VALUE shall be of type TYPE(IEEE ROUND TYPE).

34           X                    shall be of type real. It may be a scalar or an array.

35           Result Characteristics. Default logical scalar.





      374                                  WORKING DRAFT                                      SEP 2002


      SEP 2002                            WORKING DRAFT                                      J3/02-007R3



 1          Result Value.

 2          Case (i):      IEEE SUPPORT ROUNDING(ROUND VALUE, X) has the value true if the
 3                         processor supports the rounding mode defined by ROUND VALUE for real vari-
 4                         ables of the same kind type parameter as X; otherwise, it has the value false. Sup-
 5                         port includes the ability to change the mode by CALL IEEE SET ROUNDING-
 6                         MODE(ROUND VALUE).

 7          Case (ii):     IEEE SUPPORT ROUNDING(ROUND VALUE) has the value true if and only
 8                         if IEEE SUPPORT ROUNDING(ROUND VALUE, X) has the value true for all
 9                         real X.


10          Example. IEEE SUPPORT ROUNDING(IEEE TO ZERO) has the value true if the processor
11          supports rounding to zero for all reals.

12    14.9.30     IEEE SUPPORT SQRT () or IEEE SUPPORT SQRT (X)

13          Description. Inquire whether the processor implements SQRT in accord with the IEEE stan-
14          dard.

15          Class. Inquiry function.

16          Argument. X shall be of type real. It may be a scalar or an array.

17          Result Characteristics. Default logical scalar.

18          Result Value.

19          Case (i):      IEEE SUPPORT SQRT(X) has the value true if the processor implements SQRT
20                         in accord with the IEEE standard for real variables of the same kind type param-
21                         eter as X; otherwise, it has the value false.

22          Case (ii):     IEEE SUPPORT SQRT() has the value true if and only if IEEE SUPPORT -
23                         SQRT(X) has the value true for all real X.


24          Example. IEEE SUPPORT SQRT(X) has the value true if the processor implements SQRT(X)
25          in accord with the IEEE standard. In this case, SQRT(-0.0) has the value -0.0.

26    14.9.31     IEEE SUPPORT STANDARD () or IEEE SUPPORT STANDARD (X)

27          Description. Inquire whether the processor supports all the IEEE facilities defined in this
28          standard.

29          Class. Inquiry function.

30          Argument. X shall be of type real. It may be a scalar or an array.

31          Result Characteristics. Default logical scalar.

32          Result Value.

33          Case (i):      IEEE SUPPORT STANDARD(X) has the value true if the results of all the func-
34                         tions IEEE SUPPORT DATATYPE(X), IEEE SUPPORT DENORMAL(X),
35                         IEEE SUPPORT DIVIDE(X), IEEE SUPPORT FLAG(FLAG,X) for valid
36                         FLAG, IEEE SUPPORT HALTING(FLAG) for valid FLAG, IEEE SUP-
37                         PORT INF(X), IEEE SUPPORT NAN(X), IEEE SUPPORT ROUNDING
38                         (ROUND VALUE,X) for valid ROUND VALUE, and IEEE SUPPORT SQRT
39                         (X) are all true; otherwise, the result has the value false.

40          Case (ii):     IEEE SUPPORT STANDARD() has the value true if and only if IEEE SUP-
41                         PORT STANDARD(X) has the value true for all real X.



      SEP 2002                                  WORKING DRAFT                                            375


      J3/02-007R3                                 WORKING DRAFT                               SEP 2002



 1             Example. IEEE SUPPORT STANDARD() has the value false if the processor supports both
 2             IEEE and non-IEEE kinds of reals.


 3    14.9.32       IEEE UNORDERED (X, Y)

 4             Description. IEEE unordered function. True if X or Y is a NaN, and false otherwise.

 5             Class. Elemental function.

 6             Arguments. The arguments shall be of type real.

 7             Restriction.     IEEE UNORDERED(X,Y) shall not be invoked if IEEE SUPPORT DATA-
 8             TYPE(X) or IEEE SUPPORT DATATYPE(Y) has the value false.

 9             Result Characteristics. Default logical.

10             Result Value. The result has the value true if X or Y is a NaN or both are NaNs; otherwise,
11             it has the value false.

12             Example.      IEEE UNORDERED(0.0,SQRT(-1.0)) has the value true if IEEE SUPPORT -
13             SQRT(1.0) has the value true.


14    14.9.33       IEEE VALUE (X, CLASS)

15             Description. Generate an IEEE value.

16             Class. Elemental function.

17             Arguments.

18             X                   shall be of type real.

               CLASS               shall be of type TYPE(IEEE CLASS TYPE). The value is permitted to
                                   be: IEEE SIGNALING NAN or IEEE QUIET NAN if IEEE SUPPORT -
                                   NAN(X) has the value true, IEEE NEGATIVE INF or IEEE POSITIVE -
                                   INF if IEEE SUPPORT INF(X) has the value true, IEEE NEGATIVE -
                                   DENORMAL or IEEE POSITIVE DENORMAL if IEEE SUPPORT DE-
                                   NORMAL(X) has the value true, IEEE NEGATIVE NORMAL, IEEE NEG-
19                                 ATIVE ZERO, IEEE POSITIVE ZERO or IEEE POSITIVE NORMAL.

20             Restriction.     IEEE VALUE(X,CLASS) shall not be invoked if IEEE SUPPORT DATA-
21             TYPE(X) has the value false.

22             Result Characteristics. Same as X.

23             Result Value. The result value is an IEEE value as specified by CLASS. Although in most
24             cases the value is processor dependent, the value shall not vary between invocations for any
25             particular X kind type parameter and CLASS value.

26             Example. IEEE VALUE(1.0,IEEE NEGATIVE INF) has the value -infinity.



27    14.10         Examples

             NOTE 14.12





      376                                   WORKING DRAFT                                     SEP 2002


SEP 2002                           WORKING DRAFT                                    J3/02-007R3



   NOTE 14.12 (cont.)

   MODULE DOT

   ! Module for dot product of two real arrays of rank 1.

   ! The caller needs to ensure that exceptions do not cause halting.

        USE, INTRINSIC :: IEEE_EXCEPTIONS

        LOGICAL MATRIX_ERROR = .FALSE.

        INTERFACE OPERATOR(.dot.)

           MODULE PROCEDURE MULT

        END INTERFACE

   CONTAINS

        REAL FUNCTION MULT(A,B)

           REAL, INTENT(IN) :: A(:),B(:)

           INTEGER I

           LOGICAL OVERFLOW

           IF (SIZE(A)/=SIZE(B)) THEN

               MATRIX_ERROR = .TRUE.

               RETURN

           END IF

   ! The processor ensures that IEEE_OVERFLOW is quiet

           MULT = 0.0

           DO I = 1, SIZE(A)

               MULT = MULT + A(I)*B(I)

           END DO

           CALL IEEE_GET_FLAG(IEEE_OVERFLOW,OVERFLOW)

           IF (OVERFLOW) MATRIX_ERROR = .TRUE.

        END FUNCTION MULT

   END MODULE DOT


   This module provides the dot product of two real arrays of rank 1. If the sizes of the arrays are
   different, an immediate return occurs with MATRIX ERROR true. If overflow occurs during the
   actual calculation, the IEEE OVERFLOW flag will signal and MATRIX ERROR will be true.


   NOTE 14.13


   USE, INTRINSIC :: IEEE_EXCEPTIONS

   USE, INTRINSIC :: IEEE_FEATURES, ONLY: IEEE_INVALID_FLAG

   ! The other exceptions of IEEE_USUAL (IEEE_OVERFLOW and

   ! IEEE_DIVIDE_BY_ZERO) are always available with IEEE_EXCEPTIONS

   TYPE(IEEE_STATUS_TYPE) STATUS_VALUE

   LOGICAL, DIMENSION(3) :: FLAG_VALUE

    ...

   CALL IEEE_GET_STATUS(STATUS_VALUE)

   CALL IEEE_SET_HALTING_MODE(IEEE_USUAL,.FALSE.) ! Needed in case the

   !                     default on the processor is to halt on exceptions





SEP 2002                                 WORKING DRAFT                                          377


J3/02-007R3                                 WORKING DRAFT                                       SEP 2002



       NOTE 14.13 (cont.)

       CALL IEEE_SET_FLAG(IEEE_USUAL,.FALSE.)

       ! First try the "fast" algorithm for inverting a matrix:

       MATRIX1 = FAST_INV(MATRIX) ! This shall not alter MATRIX.

       CALL IEEE_GET_FLAG(IEEE_USUAL,FLAG_VALUE)

       IF (ANY(FLAG_VALUE)) THEN

       ! "Fast" algorithm failed; try "slow" one:

          CALL IEEE_SET_FLAG(IEEE_USUAL,.FALSE.)

          MATRIX1 = SLOW_INV(MATRIX)

          CALL IEEE_GET_FLAG(IEEE_USUAL,FLAG_VALUE)

          IF (ANY(FLAG_VALUE)) THEN

               WRITE (*, *) 'Cannot invert matrix'

               STOP

          END IF

       END IF

       CALL IEEE_SET_STATUS(STATUS_VALUE)


       In this example, the function FAST INV may cause a condition to signal. If it does, another try is
       made with SLOW INV. If this still fails, a message is printed and the program stops. Note, also,
       that it is important to set the flags quiet before the second try. The state of all the flags is stored
       and restored.


       NOTE 14.14


       USE, INTRINSIC :: IEEE_EXCEPTIONS

       LOGICAL FLAG_VALUE

        ...

       CALL IEEE_SET_HALTING_MODE(IEEE_OVERFLOW,.FALSE.)

       ! First try a fast algorithm for inverting a matrix.

       CALL IEEE_SET_FLAG(IEEE_OVERFLOW,.FALSE.)

       DO K = 1, N

        ...

          CALL IEEE_GET_FLAG(IEEE_OVERFLOW,FLAG_VALUE)

          IF (FLAG_VALUE) EXIT

       END DO

       IF (FLAG_VALUE) THEN

       ! Alternative code which knows that K--1 steps have executed normally.

        ...

       END IF


       Here the code for matrix inversion is in line and the transfer is made more precise by adding extra
       tests of the flag.


       NOTE 14.15





378                                   WORKING DRAFT                                             SEP 2002


SEP 2002                             WORKING DRAFT                                       J3/02-007R3



   NOTE 14.15 (cont.)

   REAL FUNCTION HYPOT(X, Y)

   ! In rare circumstances this may lead to the signaling of IEEE_OVERFLOW

   ! The caller needs to ensure that exceptions do not cause halting.

      USE, INTRINSIC :: IEEE_ARITHMETIC

      USE, INTRINSIC :: IEEE_FEATURES, ONLY: IEEE_UNDERFLOW_FLAG

   ! IEEE_OVERFLOW is always available with IEEE_ARITHMETIC

      REAL X, Y

      REAL SCALED_X, SCALED_Y, SCALED_RESULT

      LOGICAL, DIMENSION(2) :: FLAGS

      TYPE(IEEE_FLAG_TYPE), PARAMETER, DIMENSION(2) :: &

              OUT_OF_RANGE = (/ IEEE_OVERFLOW, IEEE_UNDERFLOW /)

      INTRINSIC SQRT, ABS, EXPONENT, MAX, DIGITS, SCALE

   ! The processor clears the flags on entry

   ! Try a fast algorithm first

      HYPOT = SQRT( X**2 + Y**2 )

      CALL IEEE_GET_FLAG(OUT_OF_RANGE,FLAGS)

      IF ( ANY(FLAGS) ) THEN

          CALL IEEE_SET_FLAG(OUT_OF_RANGE,.FALSE.)

          IF ( X==0.0 .OR. Y==0.0 ) THEN

              HYPOT = ABS(X) + ABS(Y)

          ELSE IF ( 2*ABS(EXPONENT(X)--EXPONENT(Y)) > DIGITS(X)+1 ) THEN

              HYPOT = MAX( ABS(X), ABS(Y) )! one of X and Y can be ignored

          ELSE ! scale so that ABS(X) is near 1

              SCALED_X = SCALE( X, --EXPONENT(X) )

              SCALED_Y = SCALE( Y, --EXPONENT(X) )

              SCALED_RESULT = SQRT( SCALED_X**2 + SCALED_Y**2 )

              HYPOT = SCALE( SCALED_RESULT, EXPONENT(X) ) ! may cause overflow

          END IF

      END IF

   ! The processor resets any flag that was signaling on entry

   END FUNCTION HYPOT


   An attempt is made to evaluate this function directly in the fastest possible way. This will work
   almost every time, but if an exception occurs during this fast computation, a safe but slower way
   evaluates the function. This slower evaluation might involve scaling and unscaling, and in (very
   rare) extreme cases this unscaling can cause overflow (after all, the true result might overflow if X
   and Y are both near the overflow limit). If the IEEE OVERFLOW or IEEE UNDERFLOW flag
   is signaling on entry, it is reset on return by the processor, so that earlier exceptions are not lost.





SEP 2002                                   WORKING DRAFT                                              379


J3/02-007R3       WORKING DRAFT    SEP 2002





380            WORKING DRAFT       SEP 2002


      SEP 2002                               WORKING DRAFT                                     J3/02-007R3





 1    Section 15: Interoperability with C

 2    Fortran provides a means of referencing procedures that are defined by means of the C programming
 3    language or procedures that can be described by C prototypes as defined in 6.7.5.3 of the C standard,
 4    even if they are not actually defined by means of C. Conversely, there is a means of specifying that a
 5    procedure defined by a Fortran subprogram can be referenced from a function defined by means of C.
 6    In addition, there is a means of declaring global variables that are linked with C variables that have
 7    external linkage as defined in 6.2.2 of the C standard.

 8    The ISO C BINDING module provides access to named constants that represent kind type parameters
 9    of data representations compatible with C types. Fortran also provides facilities for defining derived
10    types (4.5), enumerations (4.7), and type aliases (4.6) that correspond to C types.



11    15.1         The ISO C BINDING intrinsic module

12    The processor shall provide the intrinsic module ISO C BINDING. This module shall make accessible
13    the following entities: named constants with the names listed in the second column of Table 15.2 and the
14    first column of Table 15.1, the procedures specified in 15.1.2, C PTR, and C NULL PTR. A processor
15    may provide other public entities in the ISO C BINDING intrinsic module in addition to those listed
16    here.

               NOTE 15.1

               To avoid potential name conflicts with program entities, it is recommended that a program use
               the ONLY option in any USE statement that accesses the ISO C BINDING intrinsic module.



17    15.1.1        Named constants and derived types in the module

18    The entities listed in the second column of Table 15.2, shall be named constants of type default integer.

19    The value of C INT shall be a valid value for an integer kind parameter on the processor.            The
20    values of C SHORT, C LONG, C LONG LONG, C SIGNED CHAR, C SIZE T, C INT LEAST8 T,
21    C INT LEAST16 T, C INT LEAST32 T, C INT LEAST64 T, C INT FAST8 T, C INT FAST16 T, C-
22    INT FAST32 T, C INT FAST64 T, and C INTMAX T shall each be a valid value for an integer kind
23    type parameter on the processor or shall be -1.

24    The values of C FLOAT, C DOUBLE, and C LONG DOUBLE shall each be a valid value for a real
25    kind type parameter on the processor or shall be -1 if the C processor's type does not have a precision
26    equal to the precision of any of the Fortran processor's real kinds, -2 if the C processor's type does not
27    have a range equal to the range of any of the Fortran processor's real kinds, -3 if the C processor's
28    type has neither the precision nor range of any of the Fortran processor's real kinds, and equal to -4
29    if there is no interoperating Fortran processor kind for other reasons. The values of C COMPLEX,
30    C DOUBLE COMPLEX, and C LONG DOUBLE COMPLEX shall be the same as those of C FLOAT,
31    C DOUBLE, and C LONG DOUBLE, respectively.

               NOTE 15.2

               If the C processor supports more than one variety of float, double or long double, the Fortran
               processor may find it helpful to select from among more than one ISO C BINDING module by a
               processor dependent means.




      SEP 2002                                     WORKING DRAFT                                           381


      J3/02-007R3                                  WORKING DRAFT                                    SEP 2002



 1    The value of C BOOL shall be a valid value for a logical kind parameter on the processor or shall be -1.

 2    The value of C CHAR shall be a valid value for a character kind type parameter on the processor or
 3    shall be -1. The value of C CHAR is known as the C character kind.

 4    The following entities shall be named constants of type character with a length parameter of one. The
 5    kind parameter value shall be equal to the value of C CHAR unless C CHAR = -1, in which case the
 6    kind parameter value shall be the same as for default kind. The values of these constants are specified
 7    in Table 15.1. In the case that C CHAR = -1 the value is specified using C syntax. The semantics of
 8    these values are explained in 5.2.1 and 5.2.2 of the C standard.


                            Table 15.1: Names of C characters with special semantics
                                                                                  Value
                    Name                          C definition        C CHAR = -1      C CHAR = -1

                    C NULL CHAR                   null character     CHAR(0)               '\0'
                    C ALERT                       alert              ACHAR(7)              '\a'
                    C BACKSPACE                   backspace          ACHAR(8)              '\b'
                    C FORM FEED                   form feed          ACHAR(12)             '\f'
                    C NEW LINE                    new line           ACHAR(10)             '\n'
                    C CARRIAGE RETURN             carriage return    ACHAR(13)             '\r'
                    C HORIZONTAL TAB              horizontal tab     ACHAR(9)              '\t'
                    C VERTICAL TAB                vertical tab       ACHAR(11)             '\v'



 9    The entity C PTR is described in 15.2.2.

10    The entity C NULL PTR shall be a named constant of type C PTR. The value of C NULL PTR shall
11    be the same as the value NULL in C.


12    15.1.2        Procedures in the module

13    A C procedure argument is often defined in terms of a C address.               The C LOC function is pro-
14    vided so that Fortran applications can determine the appropriate value to use with C facilities. The
15    C ASSOCIATED function is provided so that Fortran programs can compare C addresses. The C F -
16    POINTER subroutine provides a means of associating a Fortran pointer with the target of a C pointer.

17    C LOC (X)

18              Description. Returns the C address of the argument.

19              Class. Inquiry function.

20              Argument. X shall

21           (1)     be

22                   (a)    a procedure that is interoperable, or

23                   (b)    a procedure pointer associated with an interoperable procedure,

24           (2)     have interoperable type and type parameters and be

25                   (a)    a variable that has the TARGET attribute and is interoperable,

26                   (b)    an allocated allocatable variable that has the TARGET attribute, or

27                   (c)    an associated scalar pointer, or

28           (3)     be a nonpolymorphic scalar and have no nonkind type parameters and be

29                   (a)    a nonallocatable, nonpointer variable that has the TARGET attribute,




      382                                    WORKING DRAFT                                          SEP 2002


      SEP 2002                               WORKING DRAFT                                       J3/02-007R3



 1              (b)       an allocated allocatable variable that has the TARGET attribute, or

 2              (c)       an associated scalar pointer.


 3          Result.

 4          The result is determined as if a pointer assignment PX => X were made.

 5          If X is interoperable or has interoperable type and type parameters, then the result is the value
 6          that the C processor returns as the result of applying the unary "&" operator (as defined in the
 7          C standard, 6.5.3.2.) to the target of PX.

 8          If X is scalar, the result is a value that can be used as an actual CPTR argument in a call to
 9          C F POINTER where FPTR is scalar and has the same type and type parameters as X. Such
10          a call to C F POINTER shall have the effect of the pointer assignment FPTR => PX.

          NOTE 15.3

         When the actual argument is of noninteroperable type or type parameters, the result of C LOC
         provides an opaque "handle" for it. In an actual implementation, this handle may be the C "base"
         address of the argument; however, portable C functions should treat it as a void (generic) C pointer
         that cannot be dereferenced (6.5.3.2 in the C standard).


11    C ASSOCIATED (C PTR 1 [, C PTR 2]))

12          Description. Indicates the association status of C PTR 1 or indicates whether C PTR 1 and
13          C PTR 2 are associated with the same entity.

14          Class. Inquiry function.

15          Arguments.

16          C PTR 1               shall be a scalar of type C PTR.

            C PTR 2               shall be a scalar of type C PTR.
17          (optional)

18          Result Characteristics. Default logical scalar.

19          Result Value.

20          Case (i):         If C PTR 2 is absent, the result is false if C PTR 1 is a C null pointer and true
21                            otherwise.

22          Case (ii):        If C PTR 2 is present, the result is false if C PTR 1 is a C null pointer. Otherwise,
23                            the result is true if C PTR 1 compares equal to C PTR 2 in the sense of 6.3.2.3
24                            and 6.5.9 of the C standard, and false otherwise.


          NOTE 15.4

         The following example illustrates the use of C LOC and C ASSOCIATED.


         USE, INTRINSIC :: ISO_C_BINDING, ONLY: C_PTR, C_FLOAT, C_ASSOCIATED, C_LOC

         INTERFACE

           SUBROUTINE FOO(GAMMA), BIND(C)

             IMPORT C_PTR

             TYPE(C_PTR), VALUE :: GAMMA





      SEP 2002                                     WORKING DRAFT                                              383


      J3/02-007R3                                 WORKING DRAFT                                  SEP 2002



             NOTE 15.4 (cont.)

               END SUBROUTINE FOO

             END INTERFACE

             REAL(C_FLOAT), TARGET, DIMENSION(100) :: ALPHA

             TYPE(C_PTR) :: BETA

             ...

             IF (.NOT. C_ASSOCIATED(BETA)) THEN

               BETA = C_LOC(ALPHA)

             ENDIF

             CALL FOO(BETA)



 1    C F POINTER (CPTR, FPTR [, SHAPE])

 2              Description. Associates a pointer with the target of a C pointer and specifies its shape.

 3              Class. Subroutine.

 4              Arguments.

 5              CPTR               shall be a scalar of type C PTR. It is an INTENT(IN) argument.

 6              FPTR               shall be a pointer. It is an INTENT(OUT) argument.

                SHAPE              shall be of type integer and rank one. It is an INTENT(IN) argument. If
                (optional)         SHAPE is present, its size shall be equal to the rank of FPTR. If FPTR is
 7                                 an array, SHAPE shall be present.

 8              Case (i):      The value of CPTR is the C address of an entity that is interoperable with
 9                             variables of the type and type parameters of FPTR and is not a Fortran variable
10                             that does not have the TARGET attribute.

11                             FPTR shall have interoperable type and type parameters. It becomes pointer
12                             associated with the target of CPTR. If it is an array, its shape is specified by
13                             SHAPE, and each lower bound is 1.

14              Case (ii):     The value of CPTR is the result of a reference to C LOC(X) with a scalar ar-
15                             gument X of the same type and type parameters as FPTR. That reference to
16                             C LOC behaves as if a pointer assignment PX => X were made. The association
17                             status of PX has not changed since the reference to C LOC. The target of PX
18                             shall not have been deallocated or have become undefined due to execution of a
19                             RETURN or END statement since the reference to C LOC.

20                             FPTR shall be scalar. It becomes pointer associated with the target of PX.


             NOTE 15.5

             Execution of this subroutine could cause FPTR to become associated with a target that has a
             different type and type parameters from FPTR. In such a case, definition of either FPTR or the
             original target causes the other to become undefined.


             NOTE 15.6

             The term "target" in the description of C F POINTER denotes the entity referenced by a C
             pointer, as described in 6.2.5 of the C standard.





      384                                   WORKING DRAFT                                        SEP 2002


      SEP 2002                             WORKING DRAFT                                          J3/02-007R3


 1    15.2      Interoperability between Fortran and C entities

 2    The following subclauses define the conditions under which a Fortran entity is interoperable. If a Fortran
 3    entity is interoperable, an equivalent entity may be defined by means of C and the Fortran entity is said
 4    to be interoperable with the C entity. There does not have to be such an interoperating C entity.

           NOTE 15.7

          A Fortran entity can be interoperable with more than one C entity.



 5    15.2.1    Interoperability of intrinsic types

 6    Table 15.2 shows the interoperability between Fortran intrinsic types and C types. A Fortran intrinsic
 7    type with particular type parameter values is interoperable with a C type if the type and kind type
 8    parameter value are listed in the table on the same row as that C type; if the type is character, inter-
 9    operability also requires that the length type parameter be omitted or be specified by an initialization
10    expression whose value is one. A combination of Fortran type and type parameters that is interoperable
11    with a C type listed in the table is also interoperable with any unqualified C type that is compatible
12    with the listed C type.

13    The second column of the table refers to the named constants made accessible by the ISO C BINDING
14    intrinsic module. If the value of any of these named constants is negative, there is no combination of
15    Fortran type and type parameters interoperable with the C type shown in that row.

16    A combination of intrinsic type and type parameters is interoperable if it is interoperable with a C
17    type.


                         Table 15.2: Interoperability between Fortran and C types
                            Named constant from the ISO C BINDING module
        Fortran type                                                               C type
                            (kind type parameter if value is positive)

                            C INT                                                  int

                            C SHORT                                                short int

                            C LONG                                                 long int

                            C LONG LONG                                            long long int
                                                                                   signed char
                            C SIGNED CHAR                                          unsigned char
                            C SIZE T                                               size t

                            C INT LEAST8 T                                         int least8 t

        INTEGER             C INT LEAST16 T                                        int least16 t

                            C INT LEAST32 T                                        int least32 t

                            C INT LEAST64 T                                        int least64 t

                            C INT FAST8 T                                          int fast8 t

                            C INT FAST16 T                                         int fast16 t

                            C INT FAST32 T                                         int fast32 t

                            C INT FAST64 T                                         int fast64 t

                            C INTMAX T                                             intmax t

                            C FLOAT                                                float

        REAL                C DOUBLE                                               double

                            C LONG DOUBLE                                          long double

                            C FLOAT COMPLEX                                        float Complex




      SEP 2002                                   WORKING DRAFT                                             385


     J3/02-007R3                                 WORKING DRAFT                                      SEP 2002



                             Interoperability between Fortran and C types                                (cont.)
                             Named constant from the ISO C BINDING module
       Fortran type                                                                  C type
                             (kind type parameter if value is positive)

       COMPLEX               C DOUBLE COMPLEX                                        double Complex

                             C LONG DOUBLE COMPLEX                                   long double Complex

       LOGICAL               C BOOL                                                  Bool

       CHARACTER             C CHAR                                                  char

       The above mentioned C types are defined in the C standard, clauses 6.2.5, 7.17, and 7.18.1.



            NOTE 15.8

            For example, the type integer with a kind type parameter of C SHORT is interoperable with the
            C type short or any C type derived (via typedef) from short.


            NOTE 15.9

            The C standard specifies that the representations for nonnegative signed integers are the same as
            the corresponding values of unsigned integers. Because Fortran does not provide direct support
            for unsigned kinds of integers, the ISO C BINDING module does not make accessible named
            constants for their kind type parameter values. Instead a user can use the signed kinds of integers
            to interoperate with the unsigned types and all their qualified versions as well. This has the
            potentially surprising side effect that the C type unsigned char is interoperable with the type
            integer with a kind type parameter of C SIGNED CHAR.



1    15.2.2       Interoperability with C pointer types

2    C PTR shall be a derived type with private components or shall be a type alias name. It is interoperable
3    with any C pointer type.

            NOTE 15.10

            This implies that a C processor is required to have the same representation method for all C
            pointer types if the C processor is to be the target of interoperability of a Fortran processor. The
            C standard does not impose this requirement.


            NOTE 15.11

            The function C LOC can be used to return an entity of type C PTR with the C address of a
            procedure or allocated allocatable variable. The entity of type C PTR is interoperable and thus
            may be used in contexts where the procedure or allocatable variable is not directly allowed. For
            example, it could be passed as an actual argument to a C function.

            Similarly, type C PTR can be used in a dummy argument or structure component and can have
            a value that is the C address of a procedure or allocatable variable, even in contexts where a
            procedure or allocatable variable is not directly allowed.



4    15.2.3       Interoperability of derived types and C struct types

5    A Fortran derived type is interoperable if it has the BIND attribute.

6    C1501     (R423) A derived type with the BIND attribute shall not be a SEQUENCE type.

7    C1502     (R423) A derived type with the BIND attribute shall not have type parameters.



     386                                   WORKING DRAFT                                            SEP 2002


      SEP 2002                              WORKING DRAFT                                     J3/02-007R3



 1    C1503    (R423) A derived type with the BIND attribute shall not have the EXTENSIBLE or EXTENDS
 2             attribute.

 3    C1504    (R423) A derived type with the BIND attribute shall not have a type-bound-procedure-part .

 4    C1505    (R423) Each component of a derived type with the BIND attribute shall be a nonpointer,
 5             nonallocatable data component with interoperable type and type parameters.

           NOTE 15.12

           The syntax rules and their constraints require that a derived type that is interoperable has compo-
           nents that are all data objects that are interoperable. No component is permitted to be a procedure
           or allocatable, but a component of type C PTR may hold the C address of such an entity.


 6    A Fortran derived type is interoperable with a C struct type if the derived-type definition of the Fortran
 7    type specifies BIND(C) (4.5.1), the Fortran derived type and the C struct type have the same number
 8    of components, and the components of the Fortran derived type have types and type parameters that
 9    are interoperable with the types of the corresponding components of the struct type. A component of
10    a Fortran derived type and a component of a C struct type correspond if they are declared in the same
11    relative position in their respective type definitions.

           NOTE 15.13

           The names of the corresponding components of the derived type and the C struct type need not
           be the same.


12    There is no Fortran type that is interoperable with a C struct type that contains a bit field or that
13    contains a flexible array member. There is no Fortran type that is interoperable with a C union type.

           NOTE 15.14

           For example, the C type myctype, declared below, is interoperable with the Fortran type myftype,
           declared below.


           typedef struct {

               int m, n;

               float r;

           } myctype


           USE, INTRINSIC :: ISO_C_BINDING

           TYPE, BIND(C) :: MYFTYPE

               INTEGER(C_INT) :: I, J

               REAL(C_FLOAT) :: S

           END TYPE MYFTYPE


           The names of the types and the names of the components are not significant for the purposes of
           determining whether a Fortran derived type is interoperable with a C struct type.


           NOTE 15.15

           The C standard requires the names and component names to be the same in order for the types
           to be compatible (C standard, clause 6.2.7). This is similar to Fortran's rule describing when
           sequence derived types are considered to be the same type. This rule was not extended to determine





      SEP 2002                                     WORKING DRAFT                                          387


      J3/02-007R3                                     WORKING DRAFT                                              SEP 2002



             NOTE 15.15 (cont.)

             whether a Fortran derived type is interoperable with a C struct type because the case of identifiers
             is significant in C but not in Fortran.



 1    15.2.4         Interoperability of scalar variables

 2    A scalar Fortran variable is interoperable if its type and type parameters are interoperable and it has
 3    neither the pointer nor the allocatable attribute.

 4    An interoperable scalar Fortran variable is interoperable with a scalar C entity if their types and type
 5    parameters are interoperable.


 6    15.2.5         Interoperability of array variables

 7    An array Fortran variable is interoperable if its type and type parameters are interoperable and it is
 8    of explicit shape or assumed size.

 9    An explicit-shape or assumed-size array of rank r, with a shape of          e1    . . .    er    is interoperable with
10    a C array if

11            (1)     either

12                    (a)       the array is assumed size, and the C array does not specify a size or specifies a size
13                              of [*], or

14                    (b)       the array is an explicit shape array, and the extent of the last dimension (er) is the
15                              same as the size of the C array, and

16            (2)     either

17                    (a)       r is equal to one, and an element of the array is interoperable with an element of the
18                              C array, or

19                    (b)       r is greater than one, and an explicit-shape array with shape of           e1    . . .    er-1 ,
20                              with the same type and type parameters as the original array, is interoperable with a
21                              C array of a type equal to the element type of the original C array.


             NOTE 15.16

             An element of a multi-dimensional C array is an array type, so a Fortran array of rank one is not
             interoperable with a multidimensional C array.


             NOTE 15.17

             A polymorphic, allocatable, or pointer array is never interoperable. Such arrays are not explicit
             shape or assumed size.


             NOTE 15.18

             For example, a Fortran array declared as


             INTEGER :: A(18, 3:7, *)


             is interoperable with a C array declared as


             int b[][5][18]





      388                                       WORKING DRAFT                                                    SEP 2002


      SEP 2002                                   WORKING DRAFT                                        J3/02-007R3



           NOTE 15.19

           The C programming language defines null-terminated strings, which are actually arrays of the C
           type char that have a C null character in them to indicate the last valid element. A Fortran array
           of type character with a kind type parameter equal to C CHAR is interoperable with a C string.

           Fortran's rules of sequence association (12.4.1.5) permit a character scalar actual argument to be
           associated with a dummy argument array. This makes it possible to argument associate a Fortran
           character string with a C string.

           Note 15.23 has an example of interoperation between Fortran and C strings.



 1    15.2.6       Interoperability of procedures and procedure interfaces

 2    A Fortran procedure is interoperable if it has the BIND attribute, that is, if its interface is specified
 3    with a proc-language-binding-spec.

 4    A Fortran procedure interface is interoperable with a C function prototype if

 5          (1)     the interface has the BIND attribute;

 6          (2)     either

 7                  (a)       the interface describes a function whose result variable is a scalar that is interoperable
 8                            with the result of the prototype or

 9                  (b)       the interface describes a subroutine, and the prototype has a result type of void;

10          (3)     the number of dummy arguments of the interface is equal to the number of formal parameters
11                  of the prototype;

12          (4)     any dummy argument with the VALUE attribute is interoperable with the corresponding
13                  formal parameter of the prototype;

14          (5)     any dummy argument without the VALUE attribute corresponds to a formal parameter of
15                  the prototype that is of a pointer type, and the dummy argument is interoperable with an
16                  entity of the referenced type (C standard, 6.2.5, 7.17, and 7.18.1) of the formal parameter;
17                  and

18          (6)     the prototype does not have variable arguments as denoted by the ellipsis (...).

           NOTE 15.20

           The referenced type of a C pointer type is the C type of the object that the C pointer type
           points to. For example, the referenced type of the pointer type int * is int.


           NOTE 15.21

           The C language allows specification of a C function that can take a variable number of argu-
           ments (C standard, 7.15). This standard does not provide a mechanism for Fortran procedures to
           interoperate with such C functions.


19    A formal parameter of a C function prototype corresponds to a dummy argument of a Fortran interface if
20    they are in the same relative positions in the C parameter list and the dummy argument list, respectively.

           NOTE 15.22

           For example, a Fortran procedure interface described by


           INTERFACE





      SEP 2002                                          WORKING DRAFT                                              389


J3/02-007R3                                 WORKING DRAFT                                        SEP 2002



       NOTE 15.22 (cont.)

         FUNCTION FUNC(I, J, K, L, M), BIND(C)

             USE, INTRINSIC :: ISO_C_BINDING

             INTEGER(C_SHORT) :: FUNC

             INTEGER(C_INT), VALUE :: I

             REAL(C_DOUBLE) :: J

             INTEGER(C_INT) :: K, L(10)

             TYPE(C_PTR), VALUE :: M

         END FUNCTION FUNC

       END INTERFACE


       is interoperable with the C function prototype


       short func(int i; double *j; int *k; int l[10]; void *m)


       A C pointer may correspond to a Fortran dummy argument of type C PTR or to a Fortran scalar
       that does not have the VALUE attribute. In the above example, the C pointers j and k correspond
       to the Fortran scalars J and K, respectively, and the C pointer m corresponds to the Fortran dummy
       argument M of type C PTR.


       NOTE 15.23

       The interoperability of Fortran procedure interfaces with C function prototypes is only one part of
       invocation of a C function from Fortran. There are four pieces to consider in such an invocation:
       the procedure reference, the Fortran procedure interface, the C function prototype, and the C
       function. Conversely, the invocation of a Fortran procedure from C involves the function reference,
       the C function prototype, the Fortran procedure interface, and the Fortran procedure. In order to
       determine whether a reference is allowed, it is necessary to consider all four pieces.

       For example, consider a C function that can be described by the C function prototype


       void copy(char in[], char out[]);


       Such a function may be invoked from Fortran as follows:


         USE, INTRINSIC :: ISO_C_BINDING, ONLY: C_CHAR, C_NULL_CHAR

         INTERFACE

             SUBROUTINE COPY(IN, OUT), BIND(C)

               IMPORT C_CHAR

               CHARACTER(KIND=C_CHAR), DIMENSION(*) :: IN, OUT

             END SUBROUTINE COPY

         END INTERFACE


         CHARACTER(LEN=10, KIND=C_CHAR) :: &

        &       DIGIT_STRING = C_CHAR_'123456789' // C_NULL_CHAR

         CHARACTER(KIND=C_CHAR) :: DIGIT_ARR(10)


         CALL COPY(DIGIT_STRING, DIGIT_ARR)





390                                   WORKING DRAFT                                              SEP 2002


      SEP 2002                                WORKING DRAFT                                     J3/02-007R3



          NOTE 15.23 (cont.)

              PRINT '(1X, A1)', DIGIT_ARR(1:9)

              END


          The procedure reference has character string actual arguments. These correspond to character
          array dummy arguments in the procedure interface body as allowed by Fortran's rules of sequence
          association (12.4.1.5). Those array dummy arguments in the procedure interface are interoperable
          with the formal parameters of the C function prototype. The C function is not shown here, but is
          assumed to be compatible with the C function prototype.



 1    15.3         Interoperation with C global variables

 2    A C variable with external linkage may interoperate with a common block or with a variable declared
 3    in the scope of a module. The common block or variable shall be specified to have the BIND attribute.

 4    At most one variable that is associated with a particular C variable with external linkage is permitted
 5    to be declared within a program. A variable shall not be initially defined by more than one processor.

 6    If a common block is specified in a BIND statement, it shall be specified in a BIND statement with
 7    the same binding label in each scoping unit in which it is declared. A C variable with external linkage
 8    interoperates with a common block that has been specified in a BIND statement

 9          (1)      if the C variable is of a struct type and the variables that are members of the common block
10                   are interoperable with corresponding components of the struct type, or

11          (2)      if the common block contains a single variable, and the variable is interoperable with the C
12                   variable.

13    There does not have to be an associated C entity for a Fortran entity with the BIND attribute.

          NOTE 15.24

          The following are examples of the usage of the BIND attribute for variables and for a common
          block. The Fortran variables, C EXTERN and C2, interoperate with the C variables, c extern and
          myVariable, respectively. The Fortran common blocks, COM and SINGLE, interoperate with the
          C variables, com and single, respectively.


          MODULE LINK_TO_C_VARS

              USE, INTRINSIC :: ISO_C_BINDING

              INTEGER(C_INT), BIND(C) :: C_EXTERN

              INTEGER(C_LONG) :: C2

              BIND(C, NAME='myVariable') :: C2


              COMMON /COM/ R, S

              REAL(C_FLOAT) :: R, S, T

              BIND(C) :: /COM/, /SINGLE/

              COMMON /SINGLE/ T

          END MODULE LINK_TO_C_VARS

          int c_extern;

          long myVariable;





      SEP 2002                                      WORKING DRAFT                                           391


      J3/02-007R3                                  WORKING DRAFT                                   SEP 2002



             NOTE 15.24 (cont.)

             struct {float r, s;} com;

             float single;



 1    15.3.1         Binding labels for common blocks and variables

 2    The binding label of a variable or common block is a value of type default character that specifies the
 3    name by which the variable or common block is known to the companion processor.

 4    If a variable or common block has the BIND attribute specified with a NAME= specifier, the binding
 5    label is the value of the expression specified for the NAME= specifier. The case of letters in the binding
 6    label is significant, but leading and trailing blanks are ignored. If a variable or common block has the
 7    BIND attribute specified without a NAME= specifier, the binding label is the same as the name of the
 8    entity using lower case letters.

 9    The binding label of a C variable with external linkage is the same as the name of the C variable. A
10    Fortran variable or common block with the BIND attribute that has the same binding label as a C
11    variable with external linkage is associated with that variable.



12    15.4           Interoperation with C functions

13    A procedure that is interoperable may be defined either by means other than Fortran or by means of a
14    Fortran subprogram, but not both.

15    If the procedure is defined by means other than Fortran, it shall

16            (1)     be describable by a C prototype that is interoperable with the interface,

17            (2)     have external linkage as defined by 6.2.2 of the C standard, and

18            (3)     have the same binding label as the interface.

19    A reference to such a procedure causes the function described by the C prototype to be called as specified
20    in the C standard.

21    A reference in C to a procedure that has the BIND attribute, has the same binding label, and is defined
22    by means of Fortran, causes the Fortran procedure to be invoked.

23    A procedure defined by means of Fortran shall not invoke setjmp or longjmp (C standard, 7.13). If a
24    procedure defined by means other than Fortran invokes setjmp or longjmp, that procedure shall not
25    cause any procedure defined by means of Fortran to be invoked. A procedure defined by means of
26    Fortran shall not be invoked as a signal handler (C standard, 7.14.1).


27    15.4.1         Binding labels for procedures

28    A binding label is a value of type default character that specifies the name by which a procedure with
29    the BIND attribute is known to the companion processor.

30    If a procedure has the BIND attribute with the NAME= specifier, the procedure has a binding label
31    whose value is that of the expression in the NAME= specifier. The case of letters in the binding label is
32    significant, but leading and trailing blanks are ignored. If a procedure has the BIND attribute with no
33    NAME= specifier, and the procedure is not a dummy procedure, then the binding label of the procedure
34    is the same as the name of the procedure using lower case letters.

35    The binding label for a C function with external linkage is the same as the C function name.



      392                                    WORKING DRAFT                                         SEP 2002


SEP 2002                           WORKING DRAFT                                     J3/02-007R3



   NOTE 15.25

   In the following sample, the binding label of C SUB is "c sub", and the binding label of C FUNC
   is "C funC".


   SUBROUTINE C_SUB, BIND(C)

     ...

   END SUBROUTINE C_SUB


   INTEGER(C_INT) FUNCTION C_FUNC(), BIND(C, NAME="C_funC")

     USE, INTRINSIC :: ISO_C_BINDING

     ...

   END FUNCTION C_FUNC


   The C standard permits functions to have names that are not permitted as Fortran names; it also
   distinguishes between names that would be considered as the same name in Fortran. For example,
   a C name may begin with an underscore, and C names that differ in case are distinct names.

   The specification of a binding label allows a program to use a Fortran name to refer to a procedure
   defined by a companion processor.





SEP 2002                                 WORKING DRAFT                                           393


J3/02-007R3       WORKING DRAFT    SEP 2002





394            WORKING DRAFT       SEP 2002


      SEP 2002                                 WORKING DRAFT                                   J3/02-007R3





 1    Section 16: Scope, association, and definition

 2    Entities are identified by lexical tokens within a scope that is a program, a scoping unit, a construct, a
 3    single statement, or part of a statement.


 4       � A global entity is an entity that has a scope of a program (2.2.1);

 5       � A local entity is an entity that has a scope of a scoping unit (2.2);

 6       � A construct entity is an entity that has a scope of a construct (7.4.3, 7.4.4, 8.1);

 7       � A statement entity is an entity that has a scope of a statement or part of a statement (3.3).


 8    An entity may be identified by

 9          (1)       A name (3.2.1),

10          (2)       A statement label (3.2.4),

11          (3)       An external input/output unit number (9.4),

12          (4)       An identifier of a pending data transfer operation (9.5.1.8, 9.6),

13          (5)       A generic identifier (12.3.2.1), or

14          (6)       A binding label (15.4.1, 15.3.1).

15    By means of association, an entity may be referred to by the same identifier or a different identifier in
16    a different scoping unit, or by a different identifier in the same scoping unit.



17    16.1         Scope of global entities

18    Program units, common blocks, external procedures, procedure binding labels, and variables that have
19    the BIND attribute are global entities of a program. A name that identifies a program unit, common
20    block or external procedure shall not be used to identify any other such global entity in the same program.
21    A binding label that identifies a global entity of the program shall not be used to identify any other
22    global entity of the program; nor shall it be the same as a name used to identify any other global entity
23    of the program, ignoring differences in case.

           NOTE 16.1

           The name of a global entity may be the same as a binding label that identifies the same global
           entity.


           NOTE 16.2

           Of the various types of procedures, only external procedures have global names. An implemen-
           tation may wish to assign global names to other entities in the Fortran program such as internal
           procedures, intrinsic procedures, procedures implementing intrinsic operators, procedures imple-
           menting input/output operations, etc. If this is done, it is the responsibility of the processor to
           ensure that none of these names conflicts with any of the names of the external procedures, with
           other globally named entities in a standard-conforming program, or with each other. For example,
           this might be done by including in each such added name a character that is not allowed in a
           standard-conforming name or by using such a character to combine a local designation with the
           global name of the program unit in which it appears.




      SEP 2002                                       WORKING DRAFT                                          395


      J3/02-007R3                                    WORKING DRAFT                                       SEP 2002



 1    External input/output units and pending data transfer operations are global entities.



 2    16.2           Scope of local entities

 3    Within a scoping unit, entities in the following classes:

 4            (1)      Named variables that are not statement or construct entities (16.3), named constants, named
 5                     constructs, statement functions, internal procedures, module procedures, dummy procedures,
 6                     intrinsic procedures, abstract interfaces, generic names, derived types, type aliases, namelist
 7                     group names, and statement labels,

 8            (2)      Type parameters, components, and binding names, in a separate class for each type, and

 9            (3)      Argument keywords, in a separate class for each procedure with an explicit interface

10    are local entities of that scoping unit.

11    Except for a common block name (16.2.1), an external procedure name that is also a generic name, or
12    an external function name within its defining subprogram (16.2.2), a name that identifies a global entity
13    in a scoping unit shall not be used to identify a local entity of class (1) in that scoping unit.

14    Within a scoping unit, an identifier of a local entity of one class shall not be used to identify another
15    local entity of the same class, except that a generic name may be the same as the name of a procedure
16    as explained in 12.3.2.1 or the same as the name of a derived type (4.5.8). A name that identifies a local
17    entity of one class may be used to identify a local entity of another class.

             NOTE 16.3

             An intrinsic procedure is inaccessible in a scoping unit containing another local entity of the same
             class and having the same name. For example, in the program fragment


             SUBROUTINE SUB

                ...

                A = SIN (K)

                ...

             CONTAINS

                FUNCTION SIN (X)

                      ...

                END FUNCTION SIN

             END SUBROUTINE SUB


             any reference to function SIN in subroutine SUB refers to the internal function SIN, not to the
             intrinsic function of the same name.


18    The name of a local entity identifies that entity in a scoping unit and may be used to identify any local
19    or global entity in another scoping unit except in the following cases:

20            (1)      The name that appears as a subroutine-name in a subroutine-stmt has limited use within
21                     the scope established by the subroutine-stmt . It can be used to identify recursive references
22                     of the subroutine or to identify a common block (the latter is possible only for internal and
23                     module subroutines).

24            (2)      The name that appears as a function-name in a function-stmt has limited use within the
25                     scope established by that function-stmt . It can be used to identify the result variable, to
26                     identify recursive references of the function, or to identify a common block (the latter is
27                     possible only for internal and module functions).



      396                                      WORKING DRAFT                                             SEP 2002


      SEP 2002                               WORKING DRAFT                                     J3/02-007R3



 1          (3)     The name that appears as an entry-name in an entry-stmt has limited use within the scope
 2                  of the subprogram in which the entry-stmt appears. It can be used to identify the result
 3                  variable if the subprogram is a function, to identify recursive references, or to identify a
 4                  common block (the latter is possible only if the entry-stmt is in a module subprogram).


 5    16.2.1       Local entities that have the same names as common blocks

 6    A name that identifies a common block in a scoping unit shall not be used to identify a constant or an
 7    intrinsic procedure in that scoping unit. If a name is used for both a common block and a local entity,
 8    the appearance of that name in any context other than as a common block name in a COMMON or
 9    SAVE statement identifies only the local entity.

           NOTE 16.4

           An intrinsic procedure name may be a common block name in a scoping unit that does not reference
           the intrinsic procedure.



10    16.2.2       Function results

11    For each FUNCTION statement or ENTRY statement in a function subprogram, there is a result
12    variable. If there is no RESULT clause, the result variable has the same name as the function being
13    defined; otherwise, the result variable has the name specified in the RESULT clause.


14    16.2.3       Restrictions on generic declarations

15    This subclause contains the rules that shall be satisfied by every pair of specific or type-bound procedures
16    that have the same generic identifier within a scoping unit. If an intrinsic operator or assignment is
17    extended, the rules apply as if the intrinsic consisted of a collection of specific procedures, one for each
18    allowed combination of type, kind type parameters, and rank for each operand. If a generic procedure is
19    accessed from a module, the rules apply to all the specific versions even if some of them are inaccessible
20    by their specific names.

           NOTE 16.5

           In most scoping units, the possible sources of procedures with a particular generic identifier are the
           accessible interface blocks and the type-bound generic bindings other than names for the accessible
           objects in that scoping unit. In a type definition, they are the generic bindings, including those
           from a parent type.


21    Within a scoping unit, if two procedures have the same generic operator and the same number of
22    arguments or both define assignment, one shall have a dummy argument that corresponds by position
23    in the argument list to a dummy argument of the other that is TKR incompatible with it.

24    Within a scoping unit, if two procedures have the same dtio-generic-spec (12.3.2.1), their dtv arguments
25    shall be type incompatible or have different kind type parameters.

26    Within a scoping unit, two procedures that have the same generic name shall both be subroutines or
27    both be functions, and

28          (1)     there is a non-passed-object dummy argument in one or the other of them such that

29                  (a)    the number of dummy arguments in one that are nonoptional, are not passed-object,
30                         and with which that dummy argument is TKR compatible (5.1.1.8), possibly including
31                         that dummy argument itself,

32                  exceeds




      SEP 2002                                     WORKING DRAFT                                            397


      J3/02-007R3                                  WORKING DRAFT                                     SEP 2002



 1                    (b)    the number of non-passed-object dummy arguments, both optional and nonoptional,
 2                           in the other that are not TKR incompatible with that dummy argument;

 3            (2)     both have passed-object dummy arguments and the passed-object dummy arguments are
 4                    TKR incompatible; or

 5            (3)     at least one of them shall have both

 6                    (a)    A nonoptional non-passed-object dummy argument at an effective position such that
 7                           either the other procedure has no dummy argument at that effective position or the
 8                           dummy argument at that position is TKR incompatible with it; and

 9                    (b)    A nonoptional non-passed-object dummy argument whose name is such that either
10                           the other procedure has no dummy argument with that name or the dummy argument
11                           with that name is TKR incompatible with it.

12                    Further, the dummy argument that disambiguates by position shall either be the same as
13                    or occur earlier in the argument list than the one that disambiguates by name.

14    The effective position of a dummy argument is its position in the argument list after any passed-object
15    dummy argument has been removed.

16    Within a scoping unit, if a generic name is the same as the name of a generic intrinsic procedure, the
17    generic intrinsic procedure is not accessible if the procedures in the interface and the intrinsic procedure
18    are not all functions or not all subroutines. If a generic invocation applies to both a specific procedure
19    from an interface and an accessible generic intrinsic procedure, it is the specific procedure from the
20    interface that is referenced.

             NOTE 16.6

             An extensive explanation of the application of these rules may be found in C.11.2.



21    16.2.4         Components, type parameters, and bindings

22    A component name has the scope of its derived-type definition. Outside the type definition, it may
23    appear only within a designator of a component of a structure of that type or as a component keyword
24    in a structure constructor for that type.

25    A type parameter name has the scope of its derived-type definition. Outside the derived-type definition,
26    it may appear only as a type parameter keyword in a derived-type-spec for the type or as the type-param-
27    name of a type-param-inquiry.

28    A binding name or a generic binding for which the generic-spec is a generic-name has the scope of its
29    derived-type definition. Outside of the derived-type definition, it may appear only as the binding-name
30    in a procedure reference.

31    A generic binding for which the generic-spec is not a generic-name has a scope that consists of all scoping
32    units in which an entity of the type is accessible.

33    A component name or binding name may appear only in scoping units in which it is accessible.

34    The accessibility of components and bindings is specified in 4.5.1.8.


35    16.2.5         Argument keywords

36    A dummy argument name in an internal procedure, module procedure, or an interface body has a
37    scope as an argument keyword of the scoping unit of the host of the procedure or interface body. As an
38    argument keyword, it may appear only in a procedure reference for the procedure of which it is a dummy
39    argument. If the procedure or interface body is accessible in another scoping unit by use association or




      398                                     WORKING DRAFT                                          SEP 2002


      SEP 2002                                     WORKING DRAFT                                               J3/02-007R3



 1    host association (16.4.1.2, 16.4.1.3), the argument keyword is accessible for procedure references for that
 2    procedure in that scoping unit.

 3    A dummy argument name in an intrinsic procedure has a scope as an argument keyword of the scoping
 4    unit in which the reference to the procedure occurs. As an argument keyword, it may appear only in a
 5    procedure reference for the procedure of which it is a dummy argument.



 6    16.3        Statement and construct entities

 7    A variable that appears as a DO variable of an implied-DO in a DATA statement or an array constructor,

 8    as a dummy argument in a statement function statement, or as an index-name in a FORALL statement is a
 9    statement entity. A variable that appears as an index-name in a FORALL construct or an associate-
10    name in a SELECT TYPE or ASSOCIATE construct is a construct entity.

11    The name of a variable that appears as the DO variable of an implied-DO in a DATA statement or
12    an array constructor has a scope of the implied-DO. It is a scalar variable that has the type and type
13    parameters that it would have if it were the name of a variable in the scoping unit that includes the
14    DATA statement or array constructor, and this type shall be integer type; it has no other attributes.
15    The appearance of a name as the DO variable of an implied-DO in a DATA statement or an array
16    constructor is not an implicit declaration of a variable whose scope is the scoping unit that contains the
17    statement.

18    The name of a variable that appears as an index-name in a FORALL statement or FORALL construct
19    has a scope of the statement or construct. It is a scalar variable that has the type and type parameters
20    that it would have if it were the name of a variable in the scoping unit that includes the FORALL, and
21    this type shall be integer type; it has no other attributes. The appearance of a name as an index-name
22    in a FORALL statement or FORALL construct is not an implicit declaration of a variable whose scope
23    is the scoping unit that contains the statement or construct.


24    The name of a variable that appears as a dummy argument in a statement function statement has a scope of the statement

25    in which it appears. It is a scalar that has the type and type parameters that it would have if it were the name of a variable

26    in the scoping unit that includes the statement function; it has no other attributes.


27    Except for a common block name or a scalar variable name, a name that identifies a global entity or
28    local entity of class 1 (16.2) accessible in the scoping unit that contains a statement shall not be the
29    name of a statement entity of that statement. Within the scope of a statement entity, another statement
30    entity shall not have the same name.

31    If the name of a global or local entity accessible in the scoping unit of a statement is the same as the
32    name of a statement entity in that statement, the name is interpreted within the scope of the statement
33    entity as that of the statement entity. Elsewhere in the scoping unit, including parts of the statement
34    outside the scope of the statement entity, the name is interpreted as that of the global or local entity.

35    Except for a common block name or a scalar variable name, a name that identifies a global entity
36    or a local entity of class 1 (16.2) accessible in the scoping unit of a FORALL statement or FORALL
37    construct shall not be the same as any of its index-names. Within the scope of a FORALL construct,
38    an index-name of a FORALL statement or FORALL construct shall not be the same as an index-name
39    of a containing FORALL construct.

40    If the name of a global or local entity accessible in the scoping unit of a FORALL statement or FORALL
41    construct is the same as the index-name, the name is interpreted within the scope of the FORALL
42    statement or FORALL construct as that of the index-name. Elsewhere in the scoping unit, the name is
43    interpreted as that of the global or local entity.

44    The associate name of a SELECT TYPE construct has a separate scope for each block of the construct.




      SEP 2002                                            WORKING DRAFT                                                       399


      J3/02-007R3                                 WORKING DRAFT                                  SEP 2002



 1    Within each block, it has the declared type, dynamic type, type parameters, rank, and bounds specified
 2    in 8.1.5.2.

 3    The associate names of an ASSOCIATE construct have the scope of the block. They have the declared
 4    type, dynamic type, type parameters, rank, and bounds specified in 8.1.4.2.

 5    If the name of a global or local entity accessible in the scoping unit of a SELECT TYPE or ASSOCIATE
 6    construct is the same as an associate name, the name is interpreted within the blocks of the SELECT
 7    TYPE or ASSOCIATE construct as that of the associate name. Elsewhere in the scoping unit, the name
 8    is interpreted as that of the global or local entity.



 9    16.4           Association

10    Two entities may become associated by name association, pointer association, storage association, or
11    inheritance association.


12    16.4.1         Name association

13    There are five forms of name association: argument association, use association, host association,
14    linkage association, and construct association. Argument, use, and host association provide mechanisms
15    by which entities known in one scoping unit may be accessed in another scoping unit.


16    16.4.1.1       Argument association

17    The rules governing argument association are given in Section 12. As explained in 12.4, execution of a
18    procedure reference establishes an association between an actual argument and its corresponding dummy
19    argument. Argument association may be sequence association (12.4.1.5).

20    The name of the dummy argument may be different from the name, if any, of its associated actual
21    argument. The dummy argument name is the name by which the associated actual argument is known,
22    and by which it may be accessed, in the referenced procedure.

             NOTE 16.7

             An actual argument may be a nameless data entity, such as an expression that is not simply a
             variable or constant.


23    Upon termination of execution of a procedure reference, all argument associations established by that
24    reference are terminated. A dummy argument of that procedure may be associated with an entirely
25    different actual argument in a subsequent invocation of the procedure.


26    16.4.1.2       Use association

27    Use association is the association of names in different scoping units specified by a USE statement. The
28    rules governing use association are given in 11.2.2. They allow for renaming of entities being accessed.
29    Use association allows access in one scoping unit to entities defined in another scoping unit; it remains
30    in effect throughout the execution of the program.


31    16.4.1.3       Host association

32    An internal subprogram, a module subprogram, or a derived-type definition has access to the named
33    entities from its host via host association. An interface body has access via host association to the
34    named entities from its host that are made accessible by IMPORT statements in the interface body.
35    The accessed entities are known by the same name and have the same attributes as in the host; they



      400                                    WORKING DRAFT                                       SEP 2002


      SEP 2002                                 WORKING DRAFT                                        J3/02-007R3



 1    are named data objects, derived types, abstract interfaces, procedures, generic identifiers (12.3.2.1), and
 2    namelist groups.

 3    If an entity that is accessed by use association has the same nongeneric name as a host entity, the host
 4    entity is inaccessible by that name. Within the scoping unit, a name that is declared to be an external
 5    procedure name by an external-stmt , procedure-declaration-stmt , or interface-body, or that appears as a
 6    module-name in a use-stmt is a global name; any entity of the host that has this as its nongeneric name
 7    is inaccessible by that name. A name that appears in the scoping unit as

 8          (1)     A function-name in a stmt-function-stmt or in an entity-decl in a type-declaration-stmt ;

 9          (2)     An object-name in an entity-decl in a type-declaration-stmt , in a pointer-stmt , in a save-stmt ,
10                  in an allocatable-stmt , or in a target-stmt ;

11          (3)     A type-param-name in a derived-type-stmt ;

12          (4)     A named-constant in a named-constant-def in a parameter-stmt ;

13          (5)     An array-name in a dimension-stmt ;

14          (6)     A variable-name in a common-block-object in a common-stmt ;

15          (7)     A proc-pointer-name in a common-block-object in a common-stmt ;

16          (8)     The name of a variable that is wholly or partially initialized in a data-stmt ;

17          (9)     The name of an object that is wholly or partially equivalenced in an equivalence-stmt ;

18          (10)    A dummy-arg-name in a function-stmt , in a subroutine-stmt , in an entry-stmt , or in a stmt-

19                  function-stmt ;

20          (11)    A result-name in a function-stmt or in an entry-stmt ;

21          (12)    The name of an entity declared by an interface body;

22          (13)    An intrinsic-procedure-name in an intrinsic-stmt ;

23          (14)    A namelist-group-name in a namelist-stmt ;

24          (15)    A type-alias-name in a type-alias-stmt ;

25          (16)    A generic-name in a generic-spec in an interface-stmt ; or

26          (17)    The name of a named construct

27    is the name of a local entity and any entity of the host that has this as its nongeneric name is inaccessible
28    by that name by host association. If a scoping unit contains a derived-type definition or a subprogram,
29    the name of the derived type or of any procedure defined by the subprogram is the name of a local
30    entity; any entity of the host that has this as its nongeneric name is inaccessible by that name. Entities
31    that are local (16.2) to a subprogram are not accessible to its host.

           NOTE 16.8

           A name that appears in an ASYNCHRONOUS or VOLATILE statement is not necessarily the
           name of a local variable. If a variable that is accessible via host association other than by an
           IMPORT statement is specified in an ASYNCHRONOUS or VOLATILE statement, that host
           variable is given the ASYNCHRONOUS or VOLATILE attribute in the scope of the current
           internal or module procedure.


32    If a host entity is inaccessible only because a local entity with the same name is wholly or partially
33    initialized in a DATA statement, the local entity shall not be referenced or defined prior to the DATA
34    statement.

35    If a derived-type name of a host is inaccessible, data entities of that type or subobjects of such data
36    entities still can be accessible.

           NOTE 16.9

           An interface body accesses by host association only those entities made accessible by IMPORT
           statements.



      SEP 2002                                       WORKING DRAFT                                               401


     J3/02-007R3                                  WORKING DRAFT                                     SEP 2002



1    An external or dummy procedure with an implicit interface that is accessed via host association shall
2    have the EXTERNAL attribute in the host scoping unit; if it is invoked as a function in the inner scoping
3    unit, its type and type parameters shall be explicitly declared in a type declaration statement in the host
4    scoping unit or the module in which it is declared if any host scoping unit of the inner scope accesses
5    it by use association, or it shall be used as a function in the scoping unit from which it is accessed.
6    An intrinsic procedure that is accessed via host association shall explicitly be given the INTRINSIC
7    attribute in the host scoping unit or the module where it is declared if any host scoping unit of the inner
8    scope accesses it by use association, or it shall be used as an intrinsic procedure in the scoping unit from
9    which it is accessed.

            NOTE 16.10

            A host subprogram and an internal subprogram may contain the same and differing use-associated
            entities, as illustrated in the following example.


            MODULE B; REAL BX, Q; INTEGER IX, JX; END MODULE B

            MODULE C; REAL CX; END MODULE C

            MODULE D; REAL DX, DY, DZ; END MODULE D

            MODULE E; REAL EX, EY, EZ; END MODULE E

            MODULE F; REAL FX; END MODULE F

            MODULE G; USE F; REAL GX; END MODULE G

            PROGRAM A

            USE B; USE C; USE D

               ...

            CONTAINS

               SUBROUTINE INNER_PROC (Q)

                     USE C               ! Not needed

                     USE B, ONLY: BX     ! Entities accessible are BX, IX, and JX

                                         ! if no other IX or JX

                                         ! is accessible to INNER_PROC

                                         ! Q is local to INNER_PROC,

                                         ! since Q is a dummy argument

                     USE D, X => DX      ! Entities accessible are DX, DY, and DZ

                                         ! X is local name for DX in INNER_PROC

                                         ! X and DX denote same entity if no other

                                         ! entity DX is local to INNER_PROC

                     USE E, ONLY: EX     ! EX is accessible in INNER_PROC, not in program A

                                         ! EY and EZ are not accessible in INNER_PROC

                                         ! or in program A

                     USE G               ! FX and GX are accessible in INNER_PROC

                     ...

               END SUBROUTINE INNER_PROC

            END PROGRAM A


            Because program A contains the statement


            USE B





     402                                   WORKING DRAFT                                            SEP 2002


      SEP 2002                                   WORKING DRAFT                                  J3/02-007R3



           NOTE 16.10 (cont.)

           all of the entities in module B, except for Q, are accessible in INNER PROC, even though IN-
           NER PROC contains the statement


           USE B, ONLY: BX


           The USE statement with the ONLY keyword means that this particular statement brings in only
           the entity named, not that this is the only variable from the module accessible in this scoping unit.


           NOTE 16.11

           For more examples of host association, see section C.11.1.



 1    16.4.1.4    Linkage association

 2    Linkage association occurs between a module variable that has the BIND attribute and the C variable
 3    with which it interoperates, or between a Fortran common block and the C variable with which it
 4    interoperates (15.3). Such association remains in effect throughout the execution of the program.


 5    16.4.1.5    Construct association

 6    Execution of a SELECT TYPE statement establishes an association between the selector and the asso-
 7    ciate name of the construct. Execution of an ASSOCIATE statement establishes an association between
 8    each selector and the corresponding associate name of the construct.

 9    If the selector is allocatable, it shall be allocated; the associate name is associated with the data object
10    and does not have the ALLOCATABLE attribute.

11    If the selector has the POINTER attribute, it shall be associated; the associate name is associated with
12    the target of the pointer and does not have the POINTER attribute.

13    If the selector is a variable other than an array section having a vector subscript, the association is
14    with the data object specified by the selector; otherwise, the association is with the value of the selector
15    expression, which is evaluated prior to execution of the block.

16    Each associate name remains associated with the corresponding selector throughout the execution of the
17    executed block. Within the block, each selector is known by and may be accessed by the corresponding
18    associate name. Upon termination of the construct, the association is terminated.

           NOTE 16.12

           The association between the associate name and a data object is established prior to execution of
           the block and is not affected by subsequent changes to variables that were used in subscripts or
           substring ranges in the selector .



19    16.4.2      Pointer association

20    Pointer association between a pointer and a target allows the target to be referenced by a reference to the
21    pointer. At different times during the execution of a program, a pointer may be undefined, associated
22    with different targets, or be disassociated. If a pointer is associated with a target, the definition status
23    of the pointer is either defined or undefined, depending on the definition status of the target. If the
24    pointer has deferred type parameters or shape, their values are assumed from the target. If the pointer
25    is polymorphic, its dynamic type is the dynamic type of the target.





      SEP 2002                                      WORKING DRAFT                                            403


      J3/02-007R3                                    WORKING DRAFT                                     SEP 2002



 1    16.4.2.1       Pointer association status

 2    A pointer may have a pointer association status of associated, disassociated, or undefined.                  Its
 3    association status may change during execution of a program. Unless a pointer is initialized (explicitly
 4    or by default), it has an initial association status of undefined. A pointer may be initialized to have an
 5    association status of disassociated.

             NOTE 16.13

             A pointer from a module program unit may be accessible in a subprogram via use association.
             Such pointers have a lifetime that is greater than targets that are declared in the subprogram,
             unless such targets are saved. Therefore, if such a pointer is associated with a local target, there is
             the possibility that when a procedure defined by the subprogram completes execution, the target
             will cease to exist, leaving the pointer "dangling". This standard considers such pointers to have
             an undefined association status. They are neither associated nor disassociated. They shall not be
             used again in the program until their status has been reestablished. There is no requirement on a
             processor to be able to detect when a pointer target ceases to exist.



 6    16.4.2.1.1      Events that cause pointers to become associated

 7    A pointer becomes associated when

 8            (1)     The pointer is allocated (6.3.1) as the result of the successful execution of an ALLOCATE
 9                    statement referencing the pointer, or

10            (2)     The pointer is pointer-assigned to a target (7.4.2) that is associated or is specified with the
11                    TARGET attribute and, if allocatable, is allocated.


12    16.4.2.1.2      Events that cause pointers to become disassociated

13    A pointer becomes disassociated when

14            (1)     The pointer is nullified (6.3.2),

15            (2)     The pointer is deallocated (6.3.3),

16            (3)     The pointer is pointer-assigned (7.4.2) to a disassociated pointer, or

17            (4)     The pointer is an ultimate component of a nonpointer nonallocatable object of a type for
18                    which default initialization is specified for the component and

19                    (a)    a procedure is invoked with this object as an actual argument corresponding to a
20                           dummy argument with INTENT (OUT),

21                    (b)    a procedure with this object as an unsaved local object that is not accessed by use or
22                           host association is invoked, or

23                    (c)    this object is allocated.

24            (5)     The pointer is an ultimate component of an object of a type for which default initialization
25                    is specified for the component and the object is allocated.


26    16.4.2.1.3      Events that cause the association status of pointers to become undefined

27    The association status of a pointer becomes undefined when

28            (1)     The pointer is pointer-assigned to a target that has an undefined association status,

29            (2)     The target of the pointer is deallocated other than through the pointer,

30            (3)     Execution of a RETURN or END statement causes the pointer's target to become undefined
31                    (item (3) of 16.5.6),

32            (4)     A RETURN or END statement is executed in a subprogram where the pointer was either
33                    declared or, with the exceptions described in 6.3.3.2, accessed,



      404                                      WORKING DRAFT                                           SEP 2002


      SEP 2002                                  WORKING DRAFT                                     J3/02-007R3



 1          (5)      The pointer is an ultimate component of an object, default initialization is not specified
 2                   for the component, and a procedure is invoked with this object as an actual argument
 3                   corresponding to a dummy argument with INTENT(OUT), or

 4          (6)      A procedure is invoked with the pointer as an actual argument corresponding to a pointer
 5                   dummy argument with INTENT(OUT).


 6    16.4.2.1.4     Other events that change the association status of pointers

 7    When a pointer becomes associated with another pointer by argument association, construct association,
 8    or host association, the effects on its association status are specified in 16.4.5.

 9    While two pointers are name associated, storage associated, or inheritance associated, if the association
10    status of one pointer changes, the association status of the other changes accordingly.


11    16.4.2.2      Pointer definition status

12    The definition status of a pointer is that of its target. If a pointer is associated with a definable target,
13    the definition status of the pointer may be defined or undefined according to the rules for a variable
14    (16.5).


15    16.4.2.3      Relationship between association status and definition status

16    If the association status of a pointer is disassociated or undefined, the pointer shall not be referenced
17    or deallocated. Whatever its association status, a pointer always may be nullified, allocated, or pointer
18    assigned. A nullified pointer is disassociated. When a pointer is allocated, it becomes associated but
19    undefined. When a pointer is pointer assigned, its association and definition status become those of the
20    specified data-target or proc-target .


21    16.4.3        Storage association

22    Storage sequences are used to describe relationships that exist among variables, common blocks, and
23    result variables. Storage association is the association of two or more data objects that occurs when
24    two or more storage sequences share or are aligned with one or more storage units.


25    16.4.3.1      Storage sequence

26    A storage sequence is a sequence of storage units. The size of a storage sequence is the number
27    of storage units in the storage sequence. A storage unit is a character storage unit, a numeric storage
28    unit, a file storage unit(9.2.4), or an unspecified storage unit.

29    In a storage association context

30          (1)      A nonpointer scalar object of type default integer, default real, or default logical occupies a
31                   single numeric storage unit;

32          (2)      A nonpointer scalar object of type double precision real or default complex occupies two
33                   contiguous numeric storage units;

34          (3)      A nonpointer scalar object of type default character and character length len occupies len
35                   contiguous character storage unit s;

36          (4)      A nonpointer scalar object of type character with the C character kind (15.1) and character
37                   length len occupies len contiguous unspecified storage units.

38          (5)      A nonpointer scalar object of sequence type with no type parameters occupies a sequence
39                   of storage sequences corresponding to the sequence of its ultimate components;





      SEP 2002                                       WORKING DRAFT                                             405


      J3/02-007R3                                     WORKING DRAFT                                      SEP 2002



 1            (6)        A nonpointer scalar object of any type not specified in items (1)-(5) occupies a single
 2                       unspecified storage unit that is different for each case and each set of type parameter values,
 3                       and that is different from the unspecified storage units of item (4);

 4            (7)        A nonpointer array occupies a sequence of contiguous storage sequences, one for each array
 5                       element, in array element order (6.2.2.2); and

 6            (8)        A pointer occupies a single unspecified storage unit that is different from that of any non-
 7                       pointer object and is different for each combination of type, type parameters, and rank.

 8    A sequence of storage sequences forms a storage sequence. The order of the storage units in such a
 9    composite storage sequence is that of the individual storage units in each of the constituent storage
10    sequences taken in succession, ignoring any zero-sized constituent sequences.

11    Each common block has a storage sequence (5.5.2.1).


12    16.4.3.2       Association of storage sequences

13    Two nonzero-sized storage sequences s1 and s2 are storage associated if the ith storage unit of s1 is
14    the same as the jth storage unit of s2. This causes the (i + k)th storage unit of s1 to be the same as
15    the (j + k)th storage unit of s2, for each integer k such that 1  i + k  size of s1 and 1  j + k 
16    size of s2.

17    Storage association also is defined between two zero-sized storage sequences, and between a zero-sized
18    storage sequence and a storage unit. A zero-sized storage sequence in a sequence of storage sequences is
19    storage associated with its successor, if any. If the successor is another zero-sized storage sequence, the
20    two sequences are storage associated. If the successor is a nonzero-sized storage sequence, the zero-sized
21    sequence is storage associated with the first storage unit of the successor. Two storage units that are
22    each storage associated with the same zero-sized storage sequence are the same storage unit.

             NOTE 16.14

             Zero-sized objects may occur in a storage association context as the result of changing a parameter.
             For example, a program might contain the following declarations:


             INTEGER, PARAMETER :: PROBSIZE = 10

             INTEGER, PARAMETER :: ARRAYSIZE = PROBSIZE * 100

             REAL, DIMENSION (ARRAYSIZE) :: X

             INTEGER, DIMENSION (ARRAYSIZE) :: IX

                  ...

             COMMON / EXAMPLE / A, B, C, X, Y, Z

             EQUIVALENCE (X, IX)

                  ...


             If the first statement is subsequently changed to assign zero to PROBSIZE, the program still will
             conform to the standard.


23    16.4.3.3       Association of scalar data objects

24    Two scalar data objects are storage associated if their storage sequences are storage associated. Two
25    scalar entities are totally associated if they have the same storage sequence. Two scalar entities are
26    partially associated if they are associated without being totally associated.

27    The definition status and value of a data object affects the definition status and value of any storage
28    associated entity. An EQUIVALENCE statement, a COMMON statement, or an ENTRY statement
29    may cause storage association of storage sequences.



      406                                       WORKING DRAFT                                            SEP 2002


      SEP 2002                                  WORKING DRAFT                                     J3/02-007R3



 1    An EQUIVALENCE statement causes storage association of data objects only within one scoping unit,
 2    unless one of the equivalenced entities is also in a common block (5.5.1.1 and 5.5.2.1).

 3    COMMON statements cause data objects in one scoping unit to become storage associated with data
 4    objects in another scoping unit.

 5    A common block is permitted to contain a sequence of differing storage units. All scoping units that
 6    access named common blocks with the same name shall specify an identical sequence of storage units.
 7    Blank common blocks may be declared with differing sizes in different scoping units. For any two blank
 8    common blocks, the initial sequence of storage units of the longer blank common block shall be identical
 9    to the sequence of storage units of the shorter common block. If two blank common blocks are the same
10    length, they shall have the same sequence of storage units.

11    An ENTRY statement in a function subprogram causes storage association of the result variables.

12    Partial association may exist only between

13          (1)    An object of default character or character sequence type and an object of default character
14                 or character sequence type or

15          (2)    An object of default complex, double precision real, or numeric sequence type and an object
16                 of default integer, default real, default logical, double precision real, default complex, or
17                 numeric sequence type.

18    For noncharacter entities, partial association may occur only through the use of COMMON, EQUIV-
19    ALENCE, or ENTRY statements. For character entities, partial association may occur only through
20    argument association or the use of COMMON or EQUIVALENCE statements.

           NOTE 16.15

           In the example:


           REAL A (4), B

           COMPLEX C (2)

           DOUBLE PRECISION D

           EQUIVALENCE (C (2), A (2), B), (A, D)


           the third storage unit of C, the second storage unit of A, the storage unit of B, and the second
           storage unit of D are specified as the same. The storage sequences may be illustrated as:


           Storage unit            1       2        3       4       5

                                ----C(1)----|---C(2)----

                                          A(1)    A(2)     A(3)    A(4)

                                                  --B--

                                        ------D------


           A (2) and B are totally associated. The following are partially associated: A (1) and C (1), A (2)
           and C (2), A (3) and C (2), B and C (2), A (1) and D, A (2) and D, B and D, C (1) and D, and
           C (2) and D. Although C (1) and C (2) are each storage associated with D, C (1) and C (2) are
           not storage associated with each other.


21    Partial association of character entities occurs when some, but not all, of the storage units of the entities
22    are the same.





      SEP 2002                                      WORKING DRAFT                                             407


      J3/02-007R3                                    WORKING DRAFT                                       SEP 2002



             NOTE 16.16

             In the example:


             CHARACTER A*4, B*4, C*3

             EQUIVALENCE (A (2:3), B, C)


             A, B, and C are partially associated.


 1    A storage unit shall not be explicitly initialized more than once in a program. Explicit initialization
 2    overrides default initialization, and default initialization for an object of derived type overrides default
 3    initialization for a component of the object (4.5.1). Default initialization may be specified for a storage
 4    unit that is storage associated provided the objects supplying the default initialization are of the same
 5    type and type parameters, and supply the same value for the storage unit.


 6    16.4.4         Inheritance association

 7    Inheritance association occurs between components of the parent component and components inherited
 8    by type extension into an extended type (4.5.3.1). This association is persistent; it is not affected by the
 9    accessibility of the parent component or the inherited components.


10    16.4.5         Establishing associations

11    When an association is established between two entities by argument association, host association,
12    or construct association, certain characteristics of the associating entity become those of the pre-
13    existing entity.

14    For argument association, the associating entity is the dummy argument and the pre-existing entity
15    is the actual argument. For host association, the associating entity is the entity in the host scoping
16    unit and the pre-existing entity is the entity in the contained scoping unit. If the host scoping unit
17    is a recursive procedure, the pre-existing entity that participates in the association is the one from the
18    innermost procedure instance that invoked, directly or indirectly, the contained procedure. For construct
19    association, the associating entity is identified by the associate name and the pre-existing entity is the
20    selector.

21    When an association is established by argument association, host association, or construct association,
22    the following applies:

23            (1)     If the associating entity has the POINTER attribute, its pointer association status becomes
24                    the same as that of the pre-existing entity. If the pre-existing entity has a pointer association
25                    status of associated, the associating entity becomes pointer associated with the same target
26                    and, if they are arrays, the bounds of the associating entity become the same as those of
27                    the pre-existing entity.

28            (2)     If the associating entity has the ALLOCATABLE attribute, its allocation status becomes
29                    the same as that of the pre-existing entity. If the pre-existing entity is allocated, the bounds
30                    (if it is an array), values of deferred type parameters, definition status, and value (if it is
31                    defined) become the same as those of the pre-existing entity. If the associating entity is
32                    polymorphic and the pre-existing entity is allocated, the dynamic type of the associating
33                    entity becomes the same as that of the pre-existing entity.

34    If the associating entity is neither a pointer nor allocatable, its definition status and value (if it is defined)
35    become the same as those of the pre-existing entity. If the entities are arrays and the association is not
36    argument association, the bounds of the associating entity become the same as those of the pre-existing
37    entity.




      408                                         WORKING DRAFT                                          SEP 2002


      SEP 2002                                WORKING DRAFT                                       J3/02-007R3


 1    16.5         Definition and undefinition of variables

 2    A variable may be defined or may be undefined and its definition status may change during execution of
 3    a program. An action that causes a variable to become undefined does not imply that the variable was
 4    previously defined. An action that causes a variable to become defined does not imply that the variable
 5    was previously undefined.


 6    16.5.1       Definition of objects and subobjects

 7    Arrays, including sections, and variables of derived, character, or complex type are objects that consist of
 8    zero or more subobjects. Associations may be established between variables and subobjects and between
 9    subobjects of different variables. These subobjects may become defined or undefined.

10          (1)     An array is defined if and only if all of its elements are defined.

11          (2)     A derived-type scalar object is defined if and only if all of its nonpointer components are
12                  defined.

13          (3)     A complex or character scalar object is defined if and only if all of its subobjects are defined.

14          (4)     If an object is undefined, at least one (but not necessarily all) of its subobjects are undefined.


15    16.5.2       Variables that are always defined

16    Zero-sized arrays and zero-length strings are always defined.


17    16.5.3       Variables that are initially defined

18    The following variables are initially defined:

19          (1)     Variables specified to have initial values by DATA statements,

20          (2)     Variables specified to have initial values by type declaration statements,

21          (3)     Nonpointer default-initialized subcomponents of variables that do not have the ALLOCAT-
22                  ABLE or POINTER attribute, and are either saved or are declared in a main program,
23                  MODULE, or BLOCK DATA scoping unit,

24          (4)     Variables that are always defined, and

25          (5)     Variables with the BIND attribute that are initialized by means other than Fortran.

           NOTE 16.17

           Fortran code:


           module mod

              integer, bind(c,name="blivet") :: foo

           end module mod


           C code:


           int blivet = 123;


           In the above example, the Fortran variable foo is initially defined to have the value 123 by means
           other than Fortran.


26    16.5.4       Variables that are initially undefined

27    All other variables are initially undefined.



      SEP 2002                                       WORKING DRAFT                                             409


      J3/02-007R3                                  WORKING DRAFT                                       SEP 2002


 1    16.5.5         Events that cause variables to become defined

 2    Variables become defined as follows:

 3           (1)      Execution of an intrinsic assignment statement other than a masked array assignment or
 4                    FORALL assignment statement causes the variable that precedes the equals to become
 5                    defined. Execution of a defined assignment statement may cause all or part of the variable
 6                    that precedes the equals to become defined.

 7           (2)      Execution of a masked array assignment or FORALL assignment statement may cause some
 8                    or all of the array elements in the assignment statement to become defined (7.4.3).

 9           (3)      As execution of an input statement proceeds, each variable that is assigned a value from
10                    the input file becomes defined at the time that data is transferred to it. (See (4) in 16.5.6.)
11                    Execution of a WRITE statement whose unit specifier identifies an internal file causes each
12                    record that is written to become defined.

13           (4)      Execution of a DO statement causes the DO variable, if any, to become defined.

14           (5)      Beginning of execution of the action specified by an implied-DO list in a synchronous in-
15                    put/output statement causes the implied-DO variable to become defined.

16           (6)      A reference to a procedure causes the entire dummy argument data object to become defined
17                    if the dummy argument does not have INTENT(OUT) and the entire corresponding actual
18                    argument is defined.

19                    A reference to a procedure causes a subobject of a dummy argument to become defined if
20                    the dummy argument does not have INTENT(OUT) and the corresponding subobject of
21                    the corresponding actual argument is defined.

22           (7)      Execution of an input/output statement containing an IOSTAT= specifier causes the spec-
23                    ified integer variable to become defined.

24           (8)      Execution of a synchronous READ statement containing a SIZE= specifier causes the spec-
25                    ified integer variable to become defined.

26           (9)      Execution of a wait operation corresponding to an asynchronous input statement containing
27                    a SIZE= specifier causes the specified integer variable to become defined.

28           (10)     Execution of an INQUIRE statement causes any variable that is assigned a value during the
29                    execution of the statement to become defined if no error condition exists.

30           (11)     If an error, end-of-file, or end-of-record condition occurs during execution of an input/output
31                    statement that has an IOMSG= specifier, the iomsg-variable becomes defined.

32           (12)     When a character storage unit becomes defined, all associated character storage units be-
33                    come defined.

34                    When a numeric storage unit becomes defined, all associated numeric storage units of the
35                    same type become defined. When an entity of double precision real type becomes defined,
36                    all totally associated entities of double precision real type become defined.

37                    When an unspecified storage unit becomes defined, all associated unspecified storage units
38                    become defined.

39           (13)     When a default complex entity becomes defined, all partially associated default real entities
40                    become defined.

41           (14)     When both parts of a default complex entity become defined as a result of partially associ-
42                    ated default real or default complex entities becoming defined, the default complex entity
43                    becomes defined.

44           (15)     When all components of a structure of a numeric sequence type or character sequence type
45                    become defined as a result of partially associated objects becoming defined, the structure
46                    becomes defined.

47           (16)     Execution of an ALLOCATE or DEALLOCATE statement with a STAT= specifier causes
48                    the variable specified by the STAT= specifier to become defined.

49           (17)     If an error condition occurs during execution of an ALLOCATE or DEALLOCATE state-




      410                                    WORKING DRAFT                                             SEP 2002


      SEP 2002                               WORKING DRAFT                                       J3/02-007R3



 1                  ment that has an ERRMSG= specifier, the errmsg-variable becomes defined.

 2         (18)     Allocation of a zero-sized array causes the array to become defined.

 3         (19)     Allocation of an object that has a nonpointer default-initialized subcomponent causes that
 4                  subcomponent to become defined.

 5         (20)     Invocation of a procedure causes any automatic object of zero size in that procedure to
 6                  become defined.

 7         (21)     Execution of a pointer assignment statement that associates a pointer with a target that is
 8                  defined causes the pointer to become defined.

 9         (22)     Invocation of a procedure that contains an unsaved nonpointer nonallocatable local variable
10                  causes all nonpointer default-initialized subcomponents of the object to become defined.

11         (23)     Invocation of a procedure that has a nonpointer nonallocatable INTENT (OUT) dummy
12                  argument causes all nonpointer default-initialized subcomponents of the dummy argument
13                  to become defined.

14         (24)     Invocation of a nonpointer function of a derived type causes all nonpointer default-initialized
15                  subcomponents of the function result to become defined.

16         (25)     In a FORALL construct, the index-name becomes defined when the index-name value set
17                  is evaluated.

18         (26)     An object with the VOLATILE attribute that is changed by a means listed in 5.1.2.16
19                  becomes defined.


20    16.5.6       Events that cause variables to become undefined

21    Variables become undefined as follows:

22         (1)      When a variable of a given type becomes defined, all associated variables of different type
23                  become undefined. However, when a variable of type default real is partially associated with
24                  a variable of type default complex, the complex variable does not become undefined when
25                  the real variable becomes defined and the real variable does not become undefined when
26                  the complex variable becomes defined. When a variable of type default complex is partially
27                  associated with another variable of type default complex, definition of one does not cause
28                  the other to become undefined.

29         (2)      If the evaluation of a function may cause an argument of the function or a variable in a
30                  module or in a common block to become defined and if a reference to the function appears in
31                  an expression in which the value of the function is not needed to determine the value of the
32                  expression, the argument or variable becomes undefined when the expression is evaluated.

33         (3)      When execution of an instance of a subprogram completes,

34                  (a)    its unsaved local variables become undefined,

35                  (b)    unsaved variables in a named common block that appears in the subprogram become
36                         undefined if they have been defined or redefined, unless another active scoping unit
37                         is referencing the common block,

38                  (c)    unsaved nonfinalizable variables in a module become undefined unless another active
39                         scoping unit is referencing the module, and

          NOTE 16.18

          A module subprogram inherently references the module that is its host. Therefore, for processors
          that keep track of when modules are in use, a module is in use whenever any procedure in the
          module is active, even if no other active scoping units reference the module; this situation can arise
          if a module procedure is invoked via a procedure pointer or a companion processor.

40                  (d)    unsaved finalizable variables in a module may be finalized if no other active scoping
41                         unit is referencing the module � following which they become undefined.





      SEP 2002                                      WORKING DRAFT                                             411


      J3/02-007R3                                  WORKING DRAFT                                       SEP 2002



             NOTE 16.19

             Execution of a defined assignment statement may leave all or part of the variable that precedes
             the equals undefined.

 1            (4)     When an error condition or end-of-file condition occurs during execution of an input state-
 2                    ment, all of the variables specified by the input list or namelist group of the statement
 3                    become undefined.

 4            (5)     When an error condition, end-of-file condition, or end-of-record condition occurs during
 5                    execution of an input/output statement and the statement contains any implied-DOs, all of
 6                    the implied-DO variables in the statement become undefined (9.10).

 7            (6)     Execution of a direct access input statement that specifies a record that has not been written
 8                    previously causes all of the variables specified by the input list of the statement to become
 9                    undefined.

10            (7)     Execution of an INQUIRE statement may cause the NAME=, RECL=, and NEXTREC=
11                    variables to become undefined (9.9).

12            (8)     When a character storage unit becomes undefined, all associated character storage units
13                    become undefined.

14                    When a numeric storage unit becomes undefined, all associated numeric storage units be-
15                    come undefined unless the undefinition is a result of defining an associated numeric storage
16                    unit of different type (see (1) above).

17                    When an entity of double precision real type becomes undefined, all totally associated
18                    entities of double precision real type become undefined.

19                    When an unspecified storage unit becomes undefined, all associated unspecified storage units
20                    become undefined.

21            (9)     When an allocatable entity is deallocated, it becomes undefined.

22            (10)    Successful execution of an ALLOCATE statement for a nonzero-sized object that has a sub-
23                    component for which default initialization has not been specified causes the subcomponent
24                    to become undefined.

25            (11)    Execution of an INQUIRE statement causes all inquiry specifier variables to become un-
26                    defined if an error condition exists, except for any variables in an IOSTAT= or IOMSG=
27                    specifier.

28            (12)    When a procedure is invoked

29                    (a)    An optional dummy argument that is not associated with an actual argument is
30                           undefined;

31                    (b)    A dummy argument with INTENT (OUT) is undefined except for any nonpointer
32                           default-initialized subcomponents the argument;

33                    (c)    An actual argument associated with a dummy argument with INTENT (OUT) be-
34                           comes undefined;

35                    (d)    A subobject of a dummy argument that does not have INTENT (OUT) is undefined
36                           if the corresponding subobject of the actual argument is undefined; and

37                    (e)    The result variable of a function is undefined except for any nonpointer default-
38                           initialized subcomponents of the result.

39            (13)    When the association status of a pointer becomes undefined or disassociated (16.4.2.1.2-
40                    16.4.2.1.3), the pointer becomes undefined.

41            (14)    When the execution of a FORALL construct has completed, the index-name becomes un-
42                    defined.

43            (15)    Execution of an asynchronous READ statement causes all of the variables specified by the
44                    input list or SIZE= specifier to become undefined. Execution of an asynchronous namelist
45                    READ statement causes any variable in the namelist group to become undefined if that
46                    variable will subsequently be defined during the execution of the READ statement or the




      412                                    WORKING DRAFT                                             SEP 2002


      SEP 2002                                 WORKING DRAFT                                       J3/02-007R3



 1                   corresponding WAIT operation.

 2          (16)     When execution of a RETURN or END statement causes a variable to become undefined,
 3                   any variable of type C PTR becomes undefined if its value is the C address of any part of
 4                   the variable that becomes undefined.

 5          (17)     When a variable with the TARGET attribute is deallocated, any variable of type C PTR
 6                   becomes undefined if its value is the C address of any part of the variable that is deallocated.


 7    16.5.7        Variable definition context

 8    Some variables are prohibited from appearing in a syntactic context that would imply definition or un-
 9    definition of the variable (5.1.2.7, 5.1.2.12, 12.6). The following are the contexts in which the appearance
10    of a variable implies such definition or undefinition of the variable:

11          (1)      The variable of an assignment-stmt ,

12          (2)      A pointer-object in a pointer-assignment-stmt or nullify-stmt ,

13          (3)      A do-variable in a do-stmt or io-implied-do,

14          (4)      An input-item in a read-stmt ,

15          (5)      A variable-name in a namelist-stmt if the namelist-group-name appears in a NML= specifier
16                   in a read-stmt ,

17          (6)      An internal-file-variable in a write-stmt ,

18          (7)      An IOSTAT=, SIZE=, or IOMSG= specifier in an input/output statement,

19          (8)      A definable variable in an INQUIRE statement,

20          (9)      A stat-variable, allocate-object , or errmsg-variable in an allocate-stmt or a deallocate-stmt ,

21          (10)     An actual argument in a reference to a procedure with an explicit interface if the associated
22                   dummy argument has the INTENT(OUT) or INTENT(INOUT) attribute, or

23          (11)     A variable that is the selector in a SELECT TYPE or ASSOCIATE construct if the associate
24                   name of that construct appears in a variable definition context.





      SEP 2002                                         WORKING DRAFT                                            413


J3/02-007R3       WORKING DRAFT    SEP 2002





414            WORKING DRAFT       SEP 2002


      SEP 2002                                 WORKING DRAFT                                   J3/02-007R3





 1                                                 Annex A

 2                                                  (Informative)


 3                               Glossary of technical terms

 4    The following is a list of the principal technical terms used in the standard and their definitions. A
 5    reference in parentheses immediately after a term is to the section where the term is defined or explained.
 6    The wording of a definition here is not necessarily the same as in the standard.

 7    action statement (2.1) : A single statement specifying or controlling a computational action (R214).

 8    actual argument (12, 12.4.1) : An expression, a variable, a procedure, or an alternate return specifier that
 9    is specified in a procedure reference.

10    allocatable variable (5.1.2.2) : A variable having the ALLOCATABLE attribute. It may be referenced
11    or defined only when it is allocated. If it is an array, it has a shape only when it is allocated. It may be
12    a named variable or a structure component.

13    argument (12) : An actual argument or a dummy argument.

14    argument association (16.4.1.1) : The relationship between an actual argument and a dummy argu-
15    ment during the execution of a procedure reference.

16    array (2.4.5) : A set of scalar data, all of the same type and type parameters, whose individual elements
17    are arranged in a rectangular pattern. It may be a named array, an array section, a structure component,
18    a function value, or an expression. Its rank is at least one. Note that in Fortran 77, arrays were always
19    named and never constants.

20    array element (2.4.5, 6.2.2) : One of the scalar data that make up an array that is either named or is
21    a structure component.

22    array pointer (5.1.2.5.3) : A pointer to an array.

23    array section (2.4.5, 6.2.2.3) : A subobject that is an array and is not a structure component.

24    assignment statement (7.4.1.1) : A statement of the form "variable = expression".

25    associate name (8.1.4.1) : The name by which a selector of a SELECT TYPE or ASSOCIATE construct
26    is known within the construct.

27    association (16.4) : Name association, pointer association, storage association, or inheritance associa-
28    tion.

29    assumed-shape array (5.1.2.5.2) : A nonpointer dummy array that takes its shape from the associated
30    actual argument.

31    assumed-size array (5.1.2.5.4) : A dummy array whose size is assumed from the associated actual
32    argument. Its last upper bound is specified by an asterisk.

33    attribute (5) : A property of a data object that may be specified in a type declaration statement
34    (R501).

35    automatic data object (5.1) : A data object that is a local entity of a subprogram, that is not a dummy
36    argument, and that has a nonkind type parameter or array bound that is specified by an expression that




      SEP 2002                                    WORKING DRAFT                                             415


      J3/02-007R3                                 WORKING DRAFT                                        SEP 2002



 1    is not an initialization expression.

 2    base type (4.5.3) : An extensible type that is not an extension of another type. A type that is declared
 3    with the EXTENSIBLE attribute.

 4    belong (8.1.6.4.3, 8.1.6.4.4) : If an EXIT or a CYCLE statement contains a construct name, the
 5    statement belongs to the DO construct using that name. Otherwise, it belongs to the innermost DO
 6    construct in which it appears.

 7    binding label (15.4.1, 15.3.1) : A value of type default character that uniquely identifies how a variable,
 8    common block, subroutine, or function is known to a companion processor.

 9    block (8.1) : A sequence of executable constructs embedded in another executable construct, bounded
10    by statements that are particular to the construct, and treated as an integral unit.

11    block data program unit (11.3) : A program unit that provides initial values for data objects in
12    named common blocks.

13    bounds (5.1.2.5.1) : For a named array, the limits within which the values of the subscripts of its array
14    elements shall lie.

15    character (3.1) : A letter, digit, or other symbol.

16    class (5.1.1.8) : A class named N is the set of types extended from the type named N.

17    characteristics (12.2) :

18           (1)    Of a procedure, its classification as a function or subroutine, whether it is pure, whether
19                  it is elemental, whether it has the BIND attribute, the value of its binding label, the char-
20                  acteristics of its dummy arguments, and the characteristics of its function result if it is a
21                  function.

22           (2)    Of a dummy argument, whether it is a data object, is a procedure, is a procedure pointer,

23                  is an asterisk (alternate return indicator), or has the OPTIONAL attribute.

24           (3)    Of a dummy data object, its type, type parameters, shape, the exact dependence of an
25                  array bound or type parameter on other entities, intent, whether it is optional, whether
26                  it is a pointer or a target, whether it is allocatable, whether it has the VALUE, ASYN-
27                  CHRONOUS, or VOLATILE attributes, whether it is polymorphic, and whether the shape,
28                  size, or a type parameter is assumed.

29           (4)    Of a dummy procedure or procedure pointer, whether the interface is explicit, the charac-
30                  teristics of the procedure if the interface is explicit, and whether it is optional.

31           (5)    Of a function result, its type, type parameters, which type parameters are deferred, whether
32                  it is polymorphic, whether it is a pointer or allocatable, whether it is a procedure pointer,
33                  rank if it is a pointer or allocatable, shape if it is not a pointer or allocatable, the exact
34                  dependence of an array bound or type parameter on other entities, and whether the character

35                  length is assumed.


36    character length parameter (2.4.1.1) : The type parameter that specifies the number of characters
37    for an entity of type character.

38    character string (4.4.4) : A sequence of characters numbered from left to right 1, 2, 3, ...

39    character storage unit (16.4.3.1) : The unit of storage for holding a scalar that is not a pointer and
40    is of type default character and character length one.

41    collating sequence (4.4.4.1) : An ordering of all the different characters of a particular kind type
42    parameter.





      416                                     WORKING DRAFT                                            SEP 2002


      SEP 2002                               WORKING DRAFT                                      J3/02-007R3



 1    common block (5.5.2) : A block of physical storage that may be accessed by any of the scoping units
 2    in a program.

 3    companion processor (2.5.10): A mechanism by which global data and procedures may be referenced
 4    or defined. It may be a mechanism that references and defines such entities by means other than Fortran.
 5    The procedures can be described by a C function prototype.

 6    component (4.5) : A constituent of a derived type.

 7    component order (4.5.4) : The ordering of the components of a derived type that is used for intrinsic
 8    formatted input/output and for structure constructors.

 9    conformable (2.4.5) : Two arrays are said to be conformable if they have the same shape. A scalar
10    is conformable with any array.

11    conformance (1.5) : A program conforms to the standard if it uses only those forms and relationships
12    described therein and if the program has an interpretation according to the standard. A program unit
13    conforms to the standard if it can be included in a program in a manner that allows the program to be
14    standard conforming. A processor conforms to the standard if it executes standard-conforming programs
15    in a manner that fulfills the interpretations prescribed in the standard and contains the capability of
16    detection and reporting as listed in 1.5.

17    connected (9.4.3) :

18          (1)     For an external unit, the property of referring to an external file.

19          (2)     For an external file, the property of having an external unit that refers to it.

20    constant (2.4.3.1.2) : A data object whose value shall not change during execution of a program. It
21    may be a named constant or a literal constant.

22    construct (7.4.3, 7.4.4, 8.1) : A sequence of statements starting with an ASSOCIATE, DO, FORALL,
23    IF, SELECT CASE, SELECT TYPE, or WHERE statement and ending with the corresponding terminal
24    statement.

25    construct entity (16) : An entity defined by a lexical token whose scope is a construct.

26    control mask (7.4.3) : In a WHERE statement or construct, an array of type logical whose value
27    determines which elements of an array, in a where-assignment-stmt , will be defined.

28    data : Plural of datum.

29    data entity (2.4.3) : A data object, the result of the evaluation of an expression, or the result of the
30    execution of a function reference (called the function result). A data entity has a type (either intrinsic
31    or derived) and has, or may have, a data value (the exception is an undefined variable). Every data
32    entity has a rank and is thus either a scalar or an array.

33    data object (2.4.3.1) : A data entity that is a constant, a variable, or a subobject of a constant.

34    data type (4) : See type.

35    datum : A single quantity that may have any of the set of values specified for its type.

36    decimal symbol (9.9.1.6, 10.5, 10.7.8) : The character that separates the whole and fractional parts in
37    the decimal representation of a real number in a file. By default the decimal symbol is a decimal point
38    (also known as a period). The current decimal symbol is determined by the current decimal edit mode.

39    declared type (5.1.1.8, 7.1.4) : The type that a data entity is declared to have. May differ from the
40    type during execution (the dynamic type) for polymorphic data entities.




      SEP 2002                                     WORKING DRAFT                                             417


      J3/02-007R3                                WORKING DRAFT                                       SEP 2002



 1    default initialization (4.5) : If initialization is specified in a type definition, an object of the type will
 2    be automatically initialized. Nonpointer components may be initialized with values by default; pointer
 3    components may be initially disassociated by default. Default initialization is not provided for objects
 4    of intrinsic type.

 5    default-initialized (4.5.1.2) : A subcomponent is said to be default-initialized if it will be initialized
 6    by default initialization.

 7    deferred type parameter (4.3) : A nonkind type parameter whose value is not specified in the
 8    declaration of an object, but instead is specified when the object is allocated or pointer-assigned.

 9    definable (2.5.5) : A variable is definable if its value may be changed by the appearance of its
10    designator on the left of an assignment statement. An allocatable variable that has not been allocated
11    is an example of a data object that is not definable. An example of a subobject that is not definable is
12    C (I) when C is an array that is a constant and I is an integer variable.

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

14    defined assignment statement (7.4.1.4, 12.3.2.1.2) : An assignment statement that is not an intrinsic
15    assignment statement; it is defined by a subroutine and a generic interface that specifies ASSIGNMENT
16    (=).

17    defined operation (7.1.3, 12.3.2.1.1) : An operation that is not an intrinsic operation and is defined
18    by a function that is associated with a generic identifier.

19    deleted feature (1.8) : A feature in a previous Fortran standard that is considered to have been
20    redundant and largely unused. See B.1 for a list of features that are in a previous Fortran standard, but
21    are not in this standard. A feature designated as an obsolescent feature in the standard may become a
22    deleted feature in the next revision.

23    derived type (2.4.1.2, 4.5) : A type whose data have components, each of which is either of intrinsic
24    type or of another derived type.

25    designator (2.5.1) : A name, followed by zero or more component selectors, array section selectors,
26    array element selectors, and substring selectors.

27    disassociated (2.4.6) : A disassociated pointer is not associated with a target. A pointer is disassociated
28    following execution of a NULLIFY statement, following pointer assignment with a disassociated pointer,
29    by default initialization, or by explicit initialization.    A data pointer may also be disassociated by
30    execution of a DEALLOCATE statement.

31    dummy argument (12, 12.5.2.1, 12.5.2.2, 12.5.2.4, 12.5.4) : An entity by which an associated actual
32    argument is accessed during execution of a procedure.

33    dummy array : A dummy argument that is an array.

34    dummy data object (12.2.1.1, 12.4.1.2) : A dummy argument that is a data object.

35    dummy pointer : A dummy argument that is a pointer.

36    dummy procedure (12.1.2.3) : A dummy argument that is specified or referenced as a procedure.

37    dynamic type (5.1.1.8, 7.1.4) : The type of a data entity during execution of a program. The dynamic
38    type of a data entity that is not polymorphic is the same as its declared type.

39    effective item (9.5.2) : A scalar object resulting from expanding an input/output list according to the
40    rules in 9.5.2.





      418                                 WORKING DRAFT                                              SEP 2002


      SEP 2002                                WORKING DRAFT                                      J3/02-007R3



 1    elemental (2.4.5, 7.4.1.4, 12.7) : An adjective applied to an operation, procedure, or assignment state-
 2    ment that is applied independently to elements of an array or corresponding elements of a set of con-
 3    formable arrays and scalars.

 4    entity : The term used for any of the following: a program unit, procedure, abstract interface, operator,
 5    generic interface, common block, external unit, statement function, type, data entity, statement label,
 6    construct, type alias, or namelist group.

 7    executable construct (2.1) : An action statement (R214) or an ASSOCIATE, CASE, DO, FORALL,
 8    IF, SELECT TYPE, or WHERE construct.

 9    executable statement (2.3.1) : An instruction to perform or control one or more computational
10    actions.

11    explicit initialization (5.1) : Explicit initialization may be specified for objects of intrinsic or derived
12    type in type declaration statements or DATA statements. An object of a derived type that specifies
13    default initialization shall not appear in a DATA statement.

14    explicit interface (12.3.1) : If a procedure has explicit interface at the point of a reference to it, the
15    processor is able to verify that the characteristics of the reference and declaration are related as required
16    by this standard. A procedure has explicit interface if it is an internal procedure, a module procedure,
17    an intrinsic procedure, an external procedure that has an interface body, a procedure reference in its
18    own scoping unit, or a dummy procedure that has an interface body.

19    explicit-shape array (5.1.2.5.1) : A named array that is declared with explicit bounds.

20    expression (2.4.3.2, 7.1) : A sequence of operands, operators, and parentheses (R722). It may be a
21    variable, a constant, a function reference, or may represent a computation.

22    extended type (4.5.3) : An extensible type that is an extension of another type. A type that is declared
23    with the EXTENDS attribute.

24    extensible type (4.5.3) : A type from which new types may be derived using the EXTENDS attribute.
25    A type that is declared with either the EXTENSIBLE attribute or the EXTENDS attribute.

26    extension type (4.5.3) : A base type is an extension type of itself only. An extended type is an
27    extension type of itself and of all types for which its parent type is an extension.

28    extent (2.4.5) : The size of one dimension of an array.

29    external file (9.2) : A sequence of records that exists in a medium external to the program.

30    external linkage : The characteristic describing that a C entity is global to the program; defined in
31    clause 6.2.2 of the C standard.

32    external procedure (2.2.3.1) : A procedure that is defined by an external subprogram or by a means
33    other than Fortran.

34    external subprogram (2.2) : A subprogram that is not in a main program, module, or another
35    subprogram. Note that a module is not called a subprogram. Note that in Fortran 77, a block data
36    program unit is called a subprogram.

37    external unit (9.4) : A mechanism that is used to refer to an external file. It is identified by a
38    nonnegative integer.

39    file (9) : An internal file or an external file.

40    file storage unit (9.2.4) : The unit of storage for an unformatted or stream file.




      SEP 2002                                     WORKING DRAFT                                              419


      J3/02-007R3                                   WORKING DRAFT                                    SEP 2002



 1    final subroutine (4.5.1.7) : A subroutine that is called automatically by the processor during finaliza-
 2    tion.

 3    finalizable (4.5.1.7) : A type that has final subroutines, or that has a finalizable component. An object
 4    of finalizable type.

 5    finalization (4.5.10) : The process of calling user-defined final subroutines immediately before destroying
 6    an object.

 7    function (2.2.3) : A procedure that is invoked in an expression and computes a value which is then
 8    used in evaluating the expression.

 9    function result (12.5.2.1) : The data object that returns the value of a function.

10    function subprogram (12.5.2.1) : A sequence of statements beginning with a FUNCTION statement
11    that is not in an interface block and ending with the corresponding END statement.

12    generic identifier (12.3.2.1) : A lexical token that appears in an INTERFACE statement and is
13    associated with all the procedures in the interface block.

14    generic interface (4.5.1, 12.3.2.1) : An interface specified by a generic procedure binding or a generic
15    interface block.

16    generic interface block (12.3.2.1) : An interface block with a generic specification.

17    global entity (16.1) : An entity whose scope is a program.

18    host (2.2) : Host scoping unit.

19    host association (16.4.1.3) : The process by which a contained scoping unit accesses entities of its
20    host.

21    host scoping unit (2.2) : A scoping unit that immediately surrounds another scoping unit.

22    implicit interface (12.3.1) : For a procedure referenced in a scoping unit, the property of not having
23    an explicit interface. A statement function always has an implicit interface

24    inherit (4.5.3) : To acquire from a parent. Components or procedure bindings of an extended type that
25    are automatically acquired from its parent type without explicit declaration in the extended type are
26    said to be inherited.

27    inheritance association (4.5.3.1, 16.4.4) : The relationship between the inherited components and the
28    parent component in an extended type.

29    inquiry function (13.1) : A function that is either intrinsic or is defined in an intrinsic module and
30    whose result depends on properties of one or more of its arguments instead of their values.

31    instance of a subprogram (12.5.2.3) : The copy of a subprogram that is created when a procedure
32    defined by the subprogram is invoked.

33    intent (5.1.2.7) : An attribute of a dummy data object that indicates whether it is used to transfer data
34    into the procedure, out of the procedure, or both.

35    interface block (12.3.2.1) : A sequence of statements from an INTERFACE statement to the corre-
36    sponding END INTERFACE statement.

37    interface body (12.3.2.1) : A sequence of statements in an interface block from a FUNCTION or
38    SUBROUTINE statement to the corresponding END statement.





      420                                     WORKING DRAFT                                          SEP 2002


      SEP 2002                                 WORKING DRAFT                                    J3/02-007R3



 1    interface of a procedure (12.3) : See procedure interface.

 2    internal file (9.3) : A character variable that is used to transfer and convert data from internal storage
 3    to internal storage.

 4    internal procedure (2.2.3.3) : A procedure that is defined by an internal subprogram.

 5    internal subprogram (2.2) : A subprogram in a main program or another subprogram.

 6    interoperable (15.2) : The property of a Fortran entity that ensures that an equivalent entity may be
 7    defined by means of C.

 8    intrinsic (2.5.7) : An adjective that may be applied to types, operators, assignment statements, proce-
 9    dures, and modules. Intrinsic types, operators, and assignment statements are defined in this standard
10    and may be used in any scoping unit without further definition or specification. Intrinsic procedures are
11    defined in this standard or provided by a processor, and may be used in a scoping unit without further
12    definition or specification. Intrinsic modules are defined in this standard or provided by a processor,
13    and may be accessed by use association; procedures and types defined in an intrinsic module are not
14    themselves intrinsic.

15    Intrinsic procedures and modules that are not defined in this standard are called nonstandard intrinsic
16    procedures and modules.

17    invoke (2.2.3) :

18          (1)    To call a subroutine by a CALL statement or by a defined assignment statement.

19          (2)    To call a function by a reference to it by name or operator during the evaluation of an
20                 expression.

21    keyword (2.5.2) : A word that is part of the syntax of a statement or a name that is used to identify
22    an item in a list.

23    kind type parameter (2.4.1.1, 4.4.1, 4.4.2, 4.4.3, 4.4.4, 4.4.5) : A parameter whose values label the
24    available kinds of an intrinsic type.

25    label : See statement label.

26    length of a character string (4.4.4) : The number of characters in the character string.

27    lexical token (3.2) : A sequence of one or more characters with a specified interpretation.

28    line (3.3) : A sequence of 0 to 132 characters, which may contain Fortran statements, a comment, or
29    an INCLUDE line.

30    linked (12.5.3) : When a C function with external linkage has the same binding label as a Fortran
31    procedure, they are said to be linked. It is also possible for two Fortran entities to be linked.

32    literal constant (2.4.3.1.2, 4.4) : A constant without a name. Note that in Fortran 77, this was
33    called simply a constant.

34    local entity (16.2) : An entity identified by a lexical token whose scope is a scoping unit.

35    local variable (2.4.3.1.1) : A variable local to a particular scoping unit; not imported through use or
36    host association, not a dummy argument, and not a variable in common.

37    main program (2.3.4, 11.1) : A Fortran main program or a replacement defined by means other than
38    Fortran.





      SEP 2002                                    WORKING DRAFT                                            421


      J3/02-007R3                                 WORKING DRAFT                                       SEP 2002



 1    many-one array section (6.2.2.3.2) : An array section with a vector subscript having two or more
 2    elements with the same value.

 3    module (2.2.4, 11.2) : A program unit that contains or accesses definitions to be accessed by other
 4    program units.

 5    module procedure (2.2.3.2) : A procedure that is defined by a module subprogram.

 6    module subprogram (2.2) : A subprogram that is in a module but is not an internal subprogram.

 7    name (3.2.1) : A lexical token consisting of a letter followed by up to 62 alphanumeric characters
 8    (letters, digits, and underscores). Note that in Fortran 77, this was called a symbolic name.

 9    name association (16.4.1) : Argument association, use association, or host association.

10    named : Having a name. That is, in a phrase such as "named variable," the word "named" signifies that
11    the variable name is not qualified by a subscript list, substring specification, and so on. For example,
12    if X is an array variable, the reference "X" is a named variable while the reference "X(1)" is an object
13    designator.

14    named constant (2.4.3.1.2) : A constant that has a name. Note that in Fortran 77, this was called
15    a symbolic constant.

16    NaN (14.6) : A Not-a-Number value of IEEE arithmetic. It represents an undefined value or a value
17    created by an invalid operation.

18    nonexecutable statement (2.3.1) : A statement used to configure the program environment in which
19    computational actions take place.

20    numeric storage unit (16.4.3.1) : The unit of storage for holding a scalar that is not a pointer and is
21    of type default real, default integer, or default logical.

22    numeric type (4.4) : Integer, real or complex type.

23    object (2.4.3.1) :Data object.

24    object designator (2.5.1) : A designator for a data object.

25    obsolescent feature (1.8) : A feature that is considered to have been redundant but that is still in
26    frequent use.

27    operand (2.5.8) : An expression that precedes or succeeds an operator.

28    operation (7.1.2) : A computation involving one or two operands.

29    operator (2.5.8) : A lexical token that specifies an operation.

30    override (4.5.1, 4.5.3) : When explicit initialization or default initialization overrides default initializa-
31    tion, it is as if only the overriding initialization were specified. If a procedure is bound to an extensible
32    type, it overrides the one that would have been inherited from the parent type.

33    parent type (4.5.3) : The extensible type from which an extended type is derived.

34    parent component (4.5.3.1) : The component of an entity of extended type that corresponds to its
35    inherited portion.

36    passed-object dummy argument (4.5.1) : The dummy argument of a type-bound procedure or
37    procedure pointer component that becomes associated with the object through which the procedure was
38    invoked.




      422                                  WORKING DRAFT                                              SEP 2002


      SEP 2002                             WORKING DRAFT                                      J3/02-007R3



 1    pointer (2.4.6) : An entity that has the POINTER attribute.

 2    pointer assignment (7.4.2) : The pointer association of a pointer with a target by the execution of a
 3    pointer assignment statement or the execution of an assignment statement for a data object of derived
 4    type having the pointer as a subobject.

 5    pointer assignment statement (7.4.2) : A statement of the form "pointer-object => target".

 6    pointer associated (6.3, 7.4.2) : The relationship between a pointer and a target following a pointer
 7    assignment or a valid execution of an ALLOCATE statement.

 8    pointer association (16.4.2) : The process by which a pointer becomes pointer associated with a target.

 9    polymorphic (5.1.1.8) : Able to be of differing types during program execution. An object declared
10    with the CLASS keyword is polymorphic.

11    preconnected (9.4.4) : A property describing a unit that is connected to an external file at the beginning
12    of execution of a program. Such a unit may be specified in input/output statements without an OPEN
13    statement being executed for that unit.

14    procedure (2.2.3, 12.1) : A computation that may be invoked during program execution. It may be a
15    function or a subroutine. It may be an intrinsic procedure, an external procedure, a module procedure,
16    an internal procedure, a dummy procedure, or a statement function. A subprogram may define more than
17    one procedure if it contains ENTRY statements.

18    procedure designator (2.5.1) : A designator for a procedure.

19    procedure interface (12.3) : The characteristics of a procedure, the name of the procedure, the name
20    of each dummy argument, and the generic identifiers (if any) by which it may be referenced.

21    processor (1.2) : The combination of a computing system and the mechanism by which programs are
22    transformed for use on that computing system.

23    processor dependent (1.5) : The designation given to a facility that is not completely specified by
24    this standard. Such a facility shall be provided by a processor, with methods or semantics determined
25    by the processor.

26    program (2.2.1) : A set of program units that includes exactly one main program.

27    program unit (2.2) : The fundamental component of a program. A sequence of statements, comments,
28    and INCLUDE lines. It may be a main program, a module, an external subprogram, or a block data
29    program unit.

30    prototype : The C analog of a function interface body; defined in 6.7.5.3 of the C standard.

31    pure procedure (12.6) : A procedure that is a pure intrinsic procedure (13.1), is defined by a pure
32    subprogram, or is a statement function that references only pure functions.

33    rank (2.4.4, 2.4.5) : The number of dimensions of an array. Zero for a scalar.

34    record (9.1) : A sequence of values or characters that is treated as a whole within a file.

35    reference (2.5.6) : The appearance of an object designator in a context requiring the value at that point
36    during execution, the appearance of a procedure name, its operator symbol, or a defined assignment
37    statement in a context requiring execution of the procedure at that point, or the appearance of a module
38    name in a USE statement. Neither the act of defining a variable nor the appearance of the name of a
39    procedure as an actual argument is regarded as a reference.





      SEP 2002                                   WORKING DRAFT                                            423


      J3/02-007R3                                   WORKING DRAFT                                        SEP 2002



 1    result variable (2.2.3, 12.5.2.1) : The variable that returns the value of a function.

 2    rounding mode (14.3, 10.6.1.2.6) : The method used to choose the result of an operation that cannot
 3    be represented exactly. In IEEE arithmetic, there are four modes; nearest, towards zero, up (towards
 4    ), and down (towards -). In addition, for input/output the two additional modes COMPATIBLE
 5    and PROCESSOR DEFINED are provided.

 6    scalar (2.4.4) :

 7           (1)    A single datum that is not an array.

 8           (2)    Not having the property of being an array.

 9    scope (16) : That part of a program within which a lexical token has a single interpretation. It may be
10    a program, a scoping unit, a construct, a single statement, or a part of a statement.

11    scoping unit (2.2) : One of the following:

12           (1)    A program unit or subprogram, excluding any scoping units in it,

13           (2)    A derived-type definition, or

14           (3)    An interface body, excluding any scoping units in it.

15    section subscript (6.2.2) : A subscript, vector subscript, or subscript triplet in an array section selector.

16    selector (6.1.1, 6.1.2, 6.1.3, 8.1.3, 8.1.4) : A syntactic mechanism for designating

17           (1)    Part of a data object. It may designate a substring, an array element, an array section, or
18                  a structure component.

19           (2)    The set of values for which a CASE block is executed.

20           (3)    The object whose type determines which branch of a SELECT TYPE construct is executed.

21           (4)    The object that is associated with the associate-name in an ASSOCIATE construct.

22    shape (2.4.5) : The rank and extents of an array. The shape may be represented by the rank-one array
23    whose elements are the extents in each dimension.

24    size (2.4.5) : The total number of elements of an array.

25    specification expression (7.1.6) : An expression with limitations that make it suitable for use in
26    specifications such as nonkind type parameters or array bounds.

27    specification function (7.1.6) : A nonintrinsic function that may be used in a specification expression.

28    standard-conforming program (1.5) : A program that uses only those forms and relationships de-
29    scribed in this standard, and that has an interpretation according to this standard.

30    statement (3.3) : A sequence of lexical tokens. It usually consists of a single line, but a statement may
31    be continued from one line to another and the semicolon symbol may be used to separate statements
32    within a line.

33    statement entity (16) : An entity identified by a lexical token whose scope is a single statement or
34    part of a statement.

35    statement function (12.5.4) : A procedure specified by a single statement that is similar in form to an assignment

36    statement.


37    statement label (3.2.4) : A lexical token consisting of up to five digits that precedes a statement and
38    may be used to refer to the statement.

39    storage association (16.4.3) : The relationship between two storage sequences if a storage unit of one
40    is the same as a storage unit of the other.



      424                                   WORKING DRAFT                                                SEP 2002


      SEP 2002                              WORKING DRAFT                                         J3/02-007R3



 1    storage sequence (16.4.3.1) : A sequence of contiguous storage units.

 2    storage unit (16.4.3.1) : A character storage unit, a numeric storage unit, a file storage unit, or an
 3    unspecified storage unit.

 4    stride (6.2.2.3.1) : The increment specified in a subscript triplet.

 5    struct : The C analog of a sequence derived type; defined in 6.2.5 of the C standard.

 6    structure (2.4.1.2) : A scalar data object of derived type.

 7    structure component (6.1.2) : A part of an object of derived type. It may be referenced by an object
 8    designator.

 9    structure constructor (4.5.8) : A syntactic mechanism for constructing a value of derived type.

10    subcomponent (6.1.2) : A subcomponent of an object of derived type is a component of that object
11    or of a subobject of that object.

12    subobject (2.4.3.1) : A portion of a data object that may be referenced or defined independently of
13    other portions. It may be an array element, an array section, a structure component, a substring, or the
14    real or imaginary part of a complex object.

15    subprogram (2.2) : A function subprogram or a subroutine subprogram. Note that in Fortran 77, a
16    block data program unit was called a subprogram.

17    subroutine (2.2.3) : A procedure that is invoked by a CALL statement or by a defined assignment
18    statement.

19    subroutine subprogram (12.5.2.2) : A sequence of statements beginning with a SUBROUTINE state-
20    ment that is not in an interface block and ending with the corresponding END statement.

21    subscript (6.2.2) : One of the list of scalar integer expressions in an array element selector. Note that
22    in Fortran 77, the whole list was called the subscript.

23    subscript triplet (6.2.2) : An item in the list of an array section selector that contains a colon and
24    specifies a regular sequence of integer values.

25    substring (6.1.1) : A contiguous portion of a scalar character string. Note that an array section can
26    include a substring selector; the result is called an array section and not a substring.

27    target (2.4.6, 5.1.2.14, 6.3.1.2) : A data entity that has the TARGET attribute, or an entity that is
28    associated with a pointer.

29    transformational function (13.1) : A function that is either intrinsic or is defined in an intrinsic
30    module and that is neither an elemental function nor an inquiry function.

31    type (2.4.1) : A named category of data that is characterized by a set of values, together with a way to
32    denote these values and a collection of operations that interpret and manipulate the values. The set of
33    data values depends on the values of the type parameters.

34    type-bound procedure (4.5.1.5) : A procedure binding in a type definition. The procedure may be
35    referenced by the binding-name via any object of that dynamic type, as a defined operator, or by defined
36    assignment.

37    type compatible (5.1.1.8) : All entities are type compatible with other entities of the same type.
38    Unlimited polymorphic entities are type compatible with all entities of extensible type; other polymorphic
39    entities are type compatible with entities whose dynamic type is an extension type of the polymorphic




      SEP 2002                                    WORKING DRAFT                                            425


      J3/02-007R3                                WORKING DRAFT                                     SEP 2002



 1    entity's declared type.

 2    type declaration statement (5) : An INTEGER, REAL, DOUBLE PRECISION, COMPLEX,
 3    CHARACTER, LOGICAL, or TYPE (type-name) statement.

 4    type parameter (2.4.1.1) : A parameter of a data type. KIND and LEN are the type parameters of
 5    intrinsic types. The type parameters of a derived type are defined in the derived-type definition.

 6    type parameter order (4.5.5) : The ordering of the type parameters of a derived type that is used for
 7    derived-type specifiers.

 8    ultimate component (4.5) : For a structure, a component that is of intrinsic type, has the ALLOCAT-
 9    ABLE attribute, or has the POINTER attribute, or an ultimate component of a derived-type component
10    that does not have the POINTER attribute or the ALLOCATABLE attribute.

11    undefined (2.5.5) : For a data object, the property of not having a determinate value.

12    unsigned : A qualifier of a C numeric type indicating that it is comprised only of nonnegative values;
13    defined in 6.2.5 of the C standard. There is nothing analogous in Fortran.

14    unspecified storage unit (16.4.3.1) : A unit of storage for holding a pointer or a scalar that is not a
15    pointer and is of type other than default integer, default character, default real, double precision real,
16    default logical, or default complex.

17    use association (16.4.1.2) : The association of names in different scoping units specified by a USE
18    statement.

19    variable (2.4.3.1.1) : A data object whose value can be defined and redefined during the execution of
20    a program. It may be a named data object, an array element, an array section, a structure component,
21    or a substring. Note that in Fortran 77, a variable was always scalar and named.

22    vector subscript (6.2.2.3.2) : A section subscript that is an integer expression of rank one.

23    void : A C type comprising an empty set of values; defined in 6.2.5 of the C standard. There is nothing
24    analogous in Fortran.

25    whole array (6.2.1) : A named array.





      426                                     WORKING DRAFT                                        SEP 2002


      SEP 2002                                WORKING DRAFT                                      J3/02-007R3





 1                                                  Annex B

 2                                                    (Informative)


 3                                        Decremental features

 4    B.1      Deleted features

 5    The deleted features are those features of Fortran 90 that were redundant and are considered largely
 6    unused. Section 1.8.1 describes the nature of the deleted features. The Fortran 90 features that are not
 7    contained in Fortran 95 or this standard are the following:

 8           (1)    Real and double precision DO variables.

 9                  The ability present in Fortran 77, and for consistency also in Fortran 90, for a DO variable
10                  to be of type real or double precision in addition to type integer, has been deleted. A similar
11                  result can be achieved by using a DO construct with no loop control and the appropriate
12                  exit test.

13           (2)    Branching to an END IF statement from outside its block.

14                  In Fortran 77, and for consistency also in Fortran 90, it was possible to branch to an END
15                  IF statement from outside the IF construct; this has been deleted. A similar result can be
16                  achieved by branching to a CONTINUE statement that is immediately after the END IF
17                  statement.

18           (3)    PAUSE statement.

19                  The PAUSE statement, present in Fortran 66, Fortran 77 and for consistency also in
20                  Fortran 90, has been deleted. A similar result can be achieved by writing a message to the
21                  appropriate unit, followed by reading from the appropriate unit.

22           (4)    ASSIGN and assigned GO TO statements and assigned format specifiers.

23                  The ASSIGN statement and the related assigned GO TO statement, present in Fortran 66,
24                  Fortran 77 and for consistency also in Fortran 90, have been deleted. Further, the ability to
25                  use an assigned integer as a format, present in Fortran 77 and Fortran 90, has been deleted.
26                  A similar result can be achieved by using other control constructs instead of the assigned
27                  GOTO statement and by using a default character variable to hold a format specification
28                  instead of using an assigned integer.

29           (5)    H edit descriptor.

30                  In Fortran 77, and for consistency also in Fortran 90, there was an alternative form of
31                  character string edit descriptor, which had been the only such form in Fortran 66; this has
32                  been deleted. A similar result can be achieved by using a character string edit descriptor.

33    The following is a list of the previous editions of the international Fortran standard, along with their
34    informal names:

                                          ISO/IEC 1539:1972            Fortran 66
                                          ISO/IEC 1539:1978            Fortran 77
                                          ISO/IEC 1539:1991            Fortran 90
                                          ISO/IEC 1539:1997            Fortran 95



35    See the Fortran 90 standard for detailed rules of how these deleted features work.





      SEP 2002                                      WORKING DRAFT                                             427


      J3/02-007R3                                 WORKING DRAFT                                  SEP 2002


 1    B.2      Obsolescent features

 2    The obsolescent features are those features of Fortran 90 that were redundant and for which better
 3    methods were available in Fortran 90. Section 1.8.2 describes the nature of the obsolescent features.
 4    The obsolescent features in this standard are the following:

 5           (1)      Arithmetic IF -- use the IF statement (8.1.2.4) or IF construct (8.1.2).

 6           (2)      Shared DO termination and termination on a statement other than END DO or CON-
 7                    TINUE -- use an END DO or a CONTINUE statement for each DO statement.

 8           (3)      Alternate return -- see B.2.1.

 9           (4)      Computed GO TO statement -- see B.2.2.

10           (5)      Statement functions -- see B.2.3.

11           (6)      DATA statements amongst executable statements -- see B.2.4.

12           (7)      Assumed length character functions -- see B.2.5.

13           (8)      Fixed form source -- see B.2.6.

14           (9)      CHARACTER* form of CHARACTER declaration -- see B.2.7.


15    B.2.1         Alternate return

16    An alternate return introduces labels into an argument list to allow the called procedure to direct the
17    execution of the caller upon return. The same effect can be achieved with a return code that is used
18    in a CASE construct on return. This avoids an irregularity in the syntax and semantics of argument
19    association. For example,

20    CALL SUBR NAME (X, Y, Z, *100, *200, *300)

21    may be replaced by

22    CALL SUBR NAME (X, Y, Z, RETURN CODE)
23    SELECT CASE (RETURN CODE)
24    CASE (1)
25    ...
26    CASE (2)
27    ...
28    CASE (3)
29    ...
30    CASE DEFAULT
31    ...
32    END SELECT


33    B.2.2         Computed GO TO statement

34    The computed GO TO has been superseded by the CASE construct, which is a generalized, easier to
35    use and more efficient means of expressing the same computation.


36    B.2.3         Statement functions

37    Statement functions are subject to a number of nonintuitive restrictions and are a potential source of
38    error since their syntax is easily confused with that of an assignment statement.

39    The internal function is a more generalized form of the statement function and completely supersedes
40    it.





      428                                   WORKING DRAFT                                        SEP 2002


      SEP 2002                               WORKING DRAFT                                     J3/02-007R3


 1    B.2.4     DATA statements among executables

 2    The statement ordering rules of Fortran 66, and hence of Fortran 77 and Fortran 90 for compatibility,
 3    allowed DATA statements to appear anywhere in a program unit after the specification statements. The
 4    ability to position DATA statements amongst executable statements is very rarely used, is unnecessary
 5    and is a potential source of error.


 6    B.2.5     Assumed character length functions

 7    Assumed character length for functions is an irregularity in the language since elsewhere in Fortran
 8    the philosophy is that the attributes of a function result depend only on the actual arguments of the
 9    invocation and on any data accessible by the function through host or use association. Some uses of this
10    facility can be replaced with an automatic character length function, where the length of the function
11    result is declared in a specification expression. Other uses can be replaced by the use of a subroutine
12    whose arguments correspond to the function result and the function arguments.

13    Note that dummy arguments of a function may be assumed character length.


14    B.2.6     Fixed form source

15    Fixed form source was designed when the principal machine-readable input medium for new programs
16    was punched cards. Now that new and amended programs are generally entered via keyboards with
17    screen displays, it is an unnecessary overhead, and is potentially error-prone, to have to locate positions
18    6, 7, or 72 on a line. Free form source was designed expressly for this more modern technology.

19    It is a simple matter for a software tool to convert from fixed to free form source.


20    B.2.7     CHARACTER* form of CHARACTER declaration

21    Fortran 90 had two different forms of specifying the length selector in CHARACTER declarations. The
22    older form (CHARACTER*char-length) was an unnecessary redundancy.





      SEP 2002                                    WORKING DRAFT                                             429


J3/02-007R3       WORKING DRAFT    SEP 2002





430            WORKING DRAFT       SEP 2002


      SEP 2002                               WORKING DRAFT                                    J3/02-007R3





 1                                                Annex C

 2                                                 (Informative)


 3                                           Extended notes

 4    C.1      Section 4 notes

 5    C.1.1       Intrinsic and derived types (4.4, 4.5)

 6    Fortran 77 provided only types explicitly defined in the standard (logical, integer, real, double preci-
 7    sion, complex, and character). This standard provides those intrinsic types and provides derived types
 8    to allow the creation of new types. A derived-type definition specifies a data structure consisting of com-
 9    ponents of intrinsic types and of derived types. Such a type definition does not represent a data object,
10    but rather, a template for declaring named objects of that derived type. For example, the definition



11    TYPE POINT

12       INTEGER X_COORD

13       INTEGER Y_COORD

14    END TYPE POINT


15    specifies a new derived type named POINT which is composed of two components of intrinsic type
16    integer (X COORD and Y COORD). The statement TYPE (POINT) FIRST, LAST declares two data
17    objects, FIRST and LAST, that can hold values of type POINT.


18    Fortran 77 provided REAL and DOUBLE PRECISION intrinsic types as approximations to math-
19    ematical real numbers. This standard generalizes REAL as an intrinsic type with a type parameter
20    that selects the approximation method. The type parameter is named kind and has values that are
21    processor dependent. DOUBLE PRECISION is treated as a synonym for REAL (k), where k is the
22    implementation-defined kind type parameter value KIND (0.0D0).

23    Real literal constants may be specified with a kind type parameter to ensure that they have a particular
24    kind type parameter value (4.4.2).

25    For example, with the specifications



26    INTEGER Q

27    PARAMETER (Q = 8)

28    REAL (Q) B


29    the literal constant 10.93 Q has the same precision as the variable B.


30    Fortran 77 did not allow zero-length character strings. They are permitted by this standard (4.4.4).

31    Objects are of different derived type if they are declared using different derived-type definitions. For
32    example,



33    TYPE APPLES



      SEP 2002                                   WORKING DRAFT                                            431


      J3/02-007R3                                WORKING DRAFT                                   SEP 2002



 1       INTEGER NUMBER

 2    END TYPE APPLES

 3    TYPE ORANGES

 4       INTEGER NUMBER

 5    END TYPE ORANGES

 6    TYPE (APPLES) COUNT1

 7    TYPE (ORANGES) COUNT2

 8    COUNT1 = COUNT2 ! Erroneous statement mixing apples and oranges



 9    Even though all components of objects of type APPLES and objects of type ORANGES have identical
10    intrinsic types, the objects are of different types.


11    C.1.2     Selection of the approximation methods (4.4.2)

12    One can select the real approximation method for an entire program through the use of a module and
13    the parameterized real type. This is accomplished by defining a named integer constant to have a
14    particular kind type parameter value and using that named constant in all real, complex, and derived-
15    type declarations. For example, the specification statements



16    INTEGER, PARAMETER :: LONG_FLOAT = 8

17    REAL (LONG_FLOAT) X, Y

18    COMPLEX (LONG_FLOAT) Z



19    specify that the approximation method corresponding to a kind type parameter value of 8 is supplied for
20    the data objects X, Y, and Z in the program unit. The kind type parameter value LONG FLOAT can
21    be made available to an entire program by placing the INTEGER specification statement in a module
22    and accessing the named constant LONG FLOAT with a USE statement. Note that by changing 8 to 4
23    once in the module, a different approximation method is selected.

24    To avoid the use of the processor-dependent values 4 or 8, replace 8 by KIND (0.0) or KIND (0.0D0).
25    Another way to avoid these processor-dependent values is to select the kind value using the intrinsic
26    inquiry function SELECTED REAL KIND. This function, given integer arguments P and R specifying
27    minimum requirements for decimal precision and decimal exponent range, respectively, returns the kind
28    type parameter value of the approximation method that has at least P decimal digits of precision and
29    at least a range for positive numbers of 10-R to 10R. In the above specification statement, the 8 may be
30    replaced by, for instance, SELECTED REAL KIND (10, 50), which requires an approximation method
31    to be selected with at least 10 decimal digits of precision and a range from 10-50 to 1050. There are no
32    magnitude or ordering constraints placed on kind values, in order that implementers may have flexibility
33    in assigning such values and may add new kinds without changing previously assigned kind values.

34    As kind values have no portable meaning, a good practice is to use them in programs only through
35    named constants as described above (for example, SINGLE, IEEE SINGLE, DOUBLE, and QUAD),
36    rather than using the kind values directly.


37    C.1.3     Extensible types (4.5.3)

38    The default accessibility of an extended type may be specified in the type definition. The accessibility
39    of its components may be specified individually.



40      module types



      432                                 WORKING DRAFT                                          SEP 2002


      SEP 2002                             WORKING DRAFT                                    J3/02-007R3



 1        type, extensible :: base_type

 2             private                    !-- Sets default accessibility

 3             integer :: i               !-- a private component

 4             integer, private :: j      !-- another private component

 5             integer, public :: k       !-- a public component

 6        end type base_type

 7

 8        type, extends(public :: base_type) :: my_type

 9             private                   !-- Sets default for components of my_type

10             integer :: l              !-- A private component.

11             integer, public :: m      !-- A public component.

12        end type my_type

13

14        type, extends(private :: my_type) :: another_type

15             !-- No new components.

16        end type another_type

17

18      end module types

19

20      subroutine sub

21        use types

22        type (my_type) :: x

23        type (another_type) :: y

24

25        ....

26

27        call another_sub( &

28             x%base_type,      &    !-- ok because base_type is a public subobject of x

29             x%base_type%k,    &    !-- ok because x%base_type is ok and has k as a

30                                    !-- public component.

31             x%k,              &    !-- ok because it is shorthand for x%base_type%k

32             x%base_type%i,    &    !-- Invalid because i is private.

33             x%i,              &    !-- Invalid because it is shorthand for x%base_type%i

34             y%my_type,        &    !-- Invalid because my_type is a private subobject.

35             y%my_type%m,      &    !-- Invalid because my_type is a private subobject.

36             y%m )                  !-- Invalid because it is shorthand for x%my_type%m.

37      end subroutine sub



38    C.1.4       Pointers (4.5.1)

39    Pointers are names that can change dynamically their association with a target object. In a sense, a
40    normal variable is a name with a fixed association with a particular object. A normal variable name
41    refers to the same storage space throughout the lifetime of the variable. A pointer name may refer
42    to different storage space, or even no storage space, at different times. A variable may be considered
43    to be a descriptor for space to hold values of the appropriate type, type parameters, and array rank
44    such that the values stored in the descriptor are fixed when the variable is created. A pointer also may



      SEP 2002                                   WORKING DRAFT                                          433


      J3/02-007R3                               WORKING DRAFT                                    SEP 2002



 1    be considered to be a descriptor, but one whose values may be changed dynamically so as to describe
 2    different pieces of storage. When a pointer is declared, space to hold the descriptor is created, but the
 3    space for the target object is not created.

 4    A derived type may have one or more components that are defined to be pointers. It may have a
 5    component that is a pointer to an object of the same derived type. This "recursive" data definition
 6    allows dynamic data structures such as linked lists, trees, and graphs to be constructed. For example:



 7    TYPE NODE                 ! Define a ''recursive'' type

 8          INTEGER :: VALUE = 0

 9          TYPE (NODE), POINTER :: NEXT_NODE => NULL ( )

10    END TYPE NODE

11

12    TYPE (NODE), TARGET :: HEAD               ! Automatically initialized

13    TYPE (NODE), POINTER :: CURRENT, TEMP          ! Declare pointers

14    INTEGER :: IOEM, K

15

16    CURRENT => HEAD                          ! CURRENT points to head of list

17

18    DO

19          READ (*, *, IOSTAT = IOEM) K       ! Read next value, if any

20          IF (IOEM /= 0) EXIT

21          ALLOCATE (TEMP)                    ! Create new cell each iteration

22          TEMP % VALUE = K                   ! Assign value to cell

23          CURRENT % NEXT_NODE => TEMP        ! Attach new cell to list

24          CURRENT => TEMP                    ! CURRENT points to new end of list

25    END DO



26    A list is now constructed and the last linked cell contains a disassociated pointer. A loop can be used
27    to "walk through" the list.



28    CURRENT => HEAD

29    DO

30          IF (.NOT. ASSOCIATED (CURRENT % NEXT_NODE)) EXIT

31          CURRENT => CURRENT % NEXT_NODE

32          WRITE (*, *) CURRENT % VALUE

33    END DO



34    C.1.5      Structure constructors and generic names

35    A generic name may be the same as a type name. This can be used to emulate user-defined structure
36    constructors for that type, even if the type has private components. For example:



37    MODULE mytype_module

38      TYPE mytype

39           PRIVATE



      434                                 WORKING DRAFT                                          SEP 2002


      SEP 2002                           WORKING DRAFT                                   J3/02-007R3



 1           COMPLEX value

 2           LOGICAL exact

 3      END TYPE

 4      INTERFACE mytype

 5           MODULE PROCEDURE int_to_mytype

 6      END INTERFACE

 7      ! Operator definitions etc.

 8      ...

 9    CONTAINS

10      TYPE(mytype) FUNCTION int_to_mytype(i)

11           INTEGER,INTENT(IN) :: i

12           int_to_mytype%value = i

13           int_to_mytype%exact = .TRUE.

14      END FUNCTION

15      ! Procedures to support operators etc.

16      ...

17    END

18

19    PROGRAM example

20      USE mytype_module

21      TYPE(mytype) x

22      x = mytype(17)

23    END



24    The type name may still be used as a generic name if the type has type parameters. For example:



25    MODULE m

26      TYPE t(kind)

27           INTEGER, KIND :: kind

28           COMPLEX(kind) value

29      END TYPE

30      INTEGER,PARAMETER :: single = KIND(0.0), double = KIND(0d0)

31      INTERFACE t

32           MODULE PROCEDURE real_to_t1, dble_to_t2, int_to_t1, int_to_t2

33      END INTERFACE

34      ...

35    CONTAINS

36      TYPE(t(single)) FUNCTION real_to_t1(x)

37           REAL(single) x

38           real_to_t1%value = x

39      END FUNCTION

40      TYPE(t(double)) FUNCTION dble_to_t2(x)

41           REAL(double) x

42           dble_to_t2%value = x

43      END FUNCTION



      SEP 2002                                 WORKING DRAFT                                             435


      J3/02-007R3                             WORKING DRAFT                            SEP 2002



 1      TYPE(t(single)) FUNCTION int_to_t1(x,mold)

 2           INTEGER x

 3           TYPE(t(single)) mold

 4           int_to_t1%value = x

 5      END FUNCTION

 6      TYPE(t(double)) FUNCTION int_to_t2(x,mold)

 7           INTEGER x

 8           TYPE(t(double)) mold

 9           int_to_t2%value = x

10      END FUNCTION

11      ...

12    END

13

14    PROGRAM example

15      USE m

16      TYPE(t(single)) x

17      TYPE(t(double)) y

18      x = t(1.5)                      ! References real_to_t1

19      x = t(17,mold=x)                ! References int_to_t1

20      y = t(1.5d0)                    ! References dble_to_t2

21      y = t(42,mold=y)                ! References int_to_t2

22      y = t(kind(0d0)) ((0,1))        ! Uses the structure constructor for type t

23    END



24    C.1.6       Final subroutines (4.5.1.7, 4.5.10, 4.5.10.1, 4.5.10.2)

25    Example of a parameterized derived type with final subroutines:



26    MODULE m

27      TYPE t(k)

28           INTEGER, KIND :: k

29           REAL(k),POINTER :: vector(:) => NULL()

30      CONTAINS

31           FINAL :: finalize_t1s, finalize_t1v, finalize_t2e

32      END TYPE

33    CONTAINS

34      SUBROUTINE finalize_t1s(x)

35           TYPE(t(KIND(0.0))) x

36           IF (ASSOCIATED(x%vector)) DEALLOCATE(x%vector)

37      END SUBROUTINE

38      SUBROUTINE finalize_t1v(x)

39           TYPE(t(KIND(0.0))) x(:)

40           DO i=LBOUND(x,1),UBOUND(x,1)

41             IF (ASSOCIATED(x(i)%vector)) DEALLOCATE(x(i)%vector)

42           END DO



      436                                WORKING DRAFT                                 SEP 2002


      SEP 2002                            WORKING DRAFT                         J3/02-007R3



 1      END SUBROUTINE

 2      ELEMENTAL SUBROUTINE finalize_t2e(x)

 3           TYPE(t(KIND(0.0d0))),INTENT(INOUT) :: x

 4           IF (ASSOCIATED(x%vector)) DEALLOCATE(x%vector)

 5      END SUBROUTINE

 6    END MODULE

 7

 8    SUBROUTINE example(n)

 9      USE m

10      TYPE(t(KIND(0.0))) a,b(10),c(n,2)

11      TYPE(t(KIND(0.0d0))) d(n,n)

12      ...

13      ! Returning from this subroutine will effectively do

14      !        CALL finalize_t1s(a)

15      !        CALL finalize_t1v(b)

16      !        CALL finalize_t2e(d)

17      ! No final subroutine will be called for variable C because the user

18      ! omitted to define a suitable specific procedure for it.

19    END SUBROUTINE


20    Example of extended types with final subroutines:



21    MODULE m

22      TYPE,EXTENSIBLE :: t1

23           REAL a,b

24      END TYPE

25      TYPE,EXTENDS(t1) :: t2

26           REAL,POINTER :: c(:),d(:)

27      CONTAINS

28           FINAL :: t2f

29      END TYPE

30      TYPE,EXTENDS(t2) :: t3

31           REAL,POINTER :: e

32      CONTAINS

33           FINAL :: t3f

34      END TYPE

35      ...

36    CONTAINS

37      SUBROUTINE t2f(x) ! Finalizer for TYPE(t2)'s extra components

38           TYPE(t2) :: x

39           IF (ASSOCIATED(x%c)) DEALLOCATE(x%c)

40           IF (ASSOCIATED(x%d)) DEALLOCATE(x%d)

41      END SUBROUTINE

42      SUBROUTINE t3f(y) ! Finalizer for TYPE(t3)'s extra components

43           TYPE(t3) :: y



      SEP 2002                                 WORKING DRAFT                           437


      J3/02-007R3                               WORKING DRAFT                                     SEP 2002



 1           IF (ASSOCIATED(y%e)) DEALLOCATE(y%e)

 2      END SUBROUTINE

 3    END MODULE

 4

 5    SUBROUTINE example

 6      USE m

 7      TYPE(t1) x1

 8      TYPE(t2) x2

 9      TYPE(t3) x3

10      ...

11      ! Returning from this subroutine will effectively do

12      !        ! Nothing to x1; it is not finalizable

13      !        CALL t2f(x2)

14      !        CALL t3f(x3)

15      !        CALL t2f(x3%t2)

16    END SUBROUTINE



17    C.2        Section 5 notes

18    C.2.1       The POINTER attribute (5.1.2.11)

19    The POINTER attribute shall be specified to declare a pointer. The type, type parameters, and rank,
20    which may be specified in the same statement or with one or more attribute specification statements,
21    determine the characteristics of the target objects that may be associated with the pointers declared
22    in the statement. An obvious model for interpreting declarations of pointers is that such declarations
23    create for each name a descriptor. Such a descriptor includes all the data necessary to describe fully
24    and locate in memory an object and all subobjects of the type, type parameters, and rank specified.
25    The descriptor is created empty; it does not contain values describing how to access an actual memory
26    space. These descriptor values will be filled in when the pointer is associated with actual target space.

27    The following example illustrates the use of pointers in an iterative algorithm:


28    PROGRAM DYNAM_ITER

29       REAL, DIMENSION (:, :), POINTER :: A, B, SWAP             ! Declare pointers

30       ...

31       READ (*, *) N, M

32       ALLOCATE (A (N, M), B (N, M))         ! Allocate target arrays

33       ! Read values into A

34       ...

35       ITER: DO

36             ...

37             ! Apply    transformation of values in A to produce values in B

38             ...

39             IF (CONVERGED) EXIT ITER

40             ! Swap A and B

41             SWAP => A; A => B; B => SWAP

42       END DO ITER



      438                                 WORKING DRAFT                                           SEP 2002


      SEP 2002                             WORKING DRAFT                                      J3/02-007R3



 1       ...

 2    END PROGRAM DYNAM_ITER



 3    C.2.2        The TARGET attribute (5.1.2.14)

 4    The TARGET attribute shall be specified for any nonpointer object that may, during the execution of the
 5    program, become associated with a pointer. This attribute is defined primarily for optimization purposes.
 6    It allows the processor to assume that any nonpointer object not explicitly declared as a target may
 7    be referred to only by way of its original declared name. It also means that implicitly-declared objects
 8    shall not be used as pointer targets. This will allow a processor to perform optimizations that otherwise
 9    would not be possible in the presence of certain pointers.

10    The following example illustrates the use of the TARGET attribute in an iterative algorithm:



11    PROGRAM ITER

12       REAL, DIMENSION (1000, 1000), TARGET :: A, B

13       REAL, DIMENSION (:, :), POINTER                :: IN, OUT, SWAP

14       ...

15       ! Read values into A

16       ...

17       IN => A                ! Associate IN with target A

18       OUT => B               ! Associate OUT with target B

19       ...

20       ITER:DO

21             ...

22             ! Apply transformation of IN values to produce OUT

23             ...

24             IF (CONVERGED) EXIT ITER

25             ! Swap IN and OUT

26             SWAP => IN; IN => OUT; OUT => SWAP

27       END DO ITER

28       ...

29    END PROGRAM ITER



30    C.2.3        The VOLATILE attribute (5.1.2.16)

31    The following example shows the use of a variable with the VOLATILE attribute to communicate with
32    an asynchronous process, in this case the operating system. The program detects a user keystroke on
33    the terminal and reacts at a convenient point in its processing.

34    The VOLATILE attribute is necessary to prevent an optimizing compiler from storing the communication
35    variable in a register or from doing flow analysis and deciding that the EXIT statement can never be
36    executed.



37    Subroutine Terminate_Iterations

38

39      Logical, VOLATILE      ::    user_hit_any_key




      SEP 2002                                   WORKING DRAFT                                            439


      J3/02-007R3                               WORKING DRAFT                                    SEP 2002



 1           ...

 2

 3    !     Have the OS start to look for a user keystroke and set the variable}

 4    !     ``user_hit_any_key'' to TRUE as soon as it detects a keystroke.}

 5    !     This pseudo call is operating system dependent.

 6

 7           Call       OS_BEGIN_DETECT_USER_KEYSTROKE( user_hit_any_key)

 8

 9           user_hit_any_key = .false.                   !this will ignore any recent keystrokes}

10

11           print *, `` hit any key to terminate iterations!''

12

13             Do I = 1,100

14                 .....    !    compute a value for R

15                 print *, I, R

16                 if (user_hit_any_key)     EXIT

17             Enddo

18

19    ! Have the OS stop looking for user keystrokes

20

21         Call      OS_STOP_DETECT_USER_KEYSTROKE

22

23    End Subroutine Terminate_Iterations



24    C.3          Section 6 notes

25    C.3.1          Structure components (6.1.2)

26    Components of a structure are referenced by writing the components of successive levels of the structure
27    hierarchy until the desired component is described. For example,



28    TYPE ID_NUMBERS

29         INTEGER SSN

30         INTEGER EMPLOYEE_NUMBER

31    END TYPE ID_NUMBERS

32

33    TYPE PERSON_ID

34         CHARACTER (LEN=30) LAST_NAME

35         CHARACTER (LEN=1) MIDDLE_INITIAL

36         CHARACTER (LEN=30) FIRST_NAME

37         TYPE (ID_NUMBERS) NUMBER

38    END TYPE PERSON_ID

39

40    TYPE PERSON

41         INTEGER AGE



      440                                   WORKING DRAFT                                        SEP 2002


      SEP 2002                              WORKING DRAFT                                 J3/02-007R3



 1       TYPE (PERSON_ID) ID

 2    END TYPE PERSON

 3

 4    TYPE (PERSON) GEORGE, MARY

 5

 6    PRINT *, GEORGE % AGE                     ! Print the AGE component

 7    PRINT *, MARY % ID % LAST_NAME            ! Print LAST_NAME of MARY

 8    PRINT *, MARY % ID % NUMBER % SSN ! Print SSN of MAR

 9    PRINT *, GEORGE % ID % NUMBER         ! Print SSN and EMPLOYEE_NUMBER of GEORGE


10    A structure component may be a data object of intrinsic type as in the case of GEORGE % AGE or it
11    may be of derived type as in the case of GEORGE % ID % NUMBER. The resultant component may
12    be a scalar or an array of intrinsic or derived type.



13    TYPE LARGE

14       INTEGER ELT (10)

15       INTEGER VAL

16    END TYPE LARGE

17

18    TYPE (LARGE) A (5)             ! 5 element array, each of whose elements

19                                   ! includes a 10 element array ELT and

20                                   ! a scalar VAL.

21    PRINT *, A (1)                 ! Prints 10 element array ELT and scalar VAL.

22    PRINT *, A (1) % ELT (3) ! Prints scalar element 3

23                                   ! of array element 1 of A.

24    PRINT *, A (2:4) % VAL         ! Prints scalar VAL for array elements

25                                   ! 2 to 4 of A.


26    Components of an object of extensible type that are inherited from the parent type may be accessed as
27    a whole by using the parent component name, or individually, either with or without qualifying them
28    by the parent component name.

29    For example:



30      TYPE, EXTENSIBLE :: POINT                     ! A base type

31         REAL :: X, Y

32      END TYPE POINT

33      TYPE, EXTENDS(POINT) :: COLOR_POINT           ! An extension of TYPE(POINT)

34         ! Components X and Y, and component name POINT, inherited from parent

35         INTEGER :: COLOR

36      END TYPE COLOR_POINT

37

38      TYPE(POINT) :: PV = POINT(1.0, 2.0)

39      TYPE(COLOR_POINT) :: CPV = COLOR_POINT(PV, 3) ! Nested form constructor

40

41      PRINT *, CPV%POINT                            ! Prints 1.0 and 2.0



      SEP 2002                                     WORKING DRAFT                                      441


      J3/02-007R3                               WORKING DRAFT                                       SEP 2002



 1      PRINT *, CPV%POINT%X, CPV%POINT%Y             ! And this does, too

 2      PRINT *, CPV%X, CPV%Y                         ! And this does, too



 3    C.3.2       Allocation with dynamic type (6.3.1)

 4    The following example illustrates the use of allocation with the value and dynamic type of the allocated
 5    object given by another object. The example copies a list of objects of any extensible type. It copies
 6    the list starting at IN LIST. After copying, each element of the list starting at LIST COPY has a
 7    polymorphic component, ITEM, for which both the value and type are taken from the ITEM component
 8    of the corresponding element of the list starting at IN LIST.



 9    TYPE :: LIST ! A list of anything of extensible type

10      TYPE(LIST), POINTER :: NEXT => NULL()

11      CLASS(*), ALLOCATABLE :: ITEM

12    END TYPE LIST

13    ...

14    TYPE(LIST), POINTER :: IN_LIST, LIST_COPY => NULL()

15    TYPE(LIST), POINTER :: IN_WALK, NEW_TAIL

16    ! Copy IN_LIST to LIST_COPY

17    IF (ASSOCIATED(IN_LIST)) THEN

18      IN_WALK => IN_LIST

19      ALLOCATE(LIST_COPY)

20      NEW_TAIL => LIST_COPY

21      DO

22           ALLOCATE(NEW_TAIL%ITEM, SOURCE=IN_WALK%ITEM)

23           IN_WALK => IN_WALK%NEXT

24           IF (.NOT. ASSOCIATED(IN_WALK)) EXIT

25           ALLOCATE(NEW_TAIL%NEXT)

26           NEW_TAIL => NEW_TAIL%NEXT

27      END DO

28    END IF



29    C.3.3       Pointer allocation and association

30    The effect of ALLOCATE, DEALLOCATE, NULLIFY, and pointer assignment is that they are inter-
31    preted as changing the values in the descriptor that is the pointer. An ALLOCATE is assumed to create
32    space for a suitable object and to "assign" to the pointer the values necessary to describe that space.
33    A NULLIFY breaks the association of the pointer with the space. A DEALLOCATE breaks the asso-
34    ciation and releases the space. Depending on the implementation, it could be seen as setting a flag in
35    the pointer that indicates whether the values in the descriptor are valid, or it could clear the descriptor
36    values to some (say zero) value indicative of the pointer not pointing to anything. A pointer assignment
37    copies the values necessary to describe the space occupied by the target into the descriptor that is the
38    pointer. Descriptors are copied, values of objects are not.

39    If PA and PB are both pointers and PB is associated with a target, then

40    PA => PB

41    results in PA being associated with the same target as PB. If PB was disassociated, then PA becomes



      442                                 WORKING DRAFT                                             SEP 2002


      SEP 2002                                  WORKING DRAFT                                  J3/02-007R3



 1    disassociated.

 2    The standard is specified so that such associations are direct and independent. A subsequent statement

 3    PB => D

 4    or

 5    ALLOCATE (PB)

 6    has no effect on the association of PA with its target. A statement

 7    DEALLOCATE (PB)

 8    deallocates the space that is associated with both PA and PB. PB becomes disassociated, but there is
 9    no requirement that the processor make it explicitly recognizable that PA no longer has a target. This
10    leaves PA as a "dangling pointer" to space that has been released. The program shall not use PA again
11    until it becomes associated via pointer assignment or an ALLOCATE statement.

12    DEALLOCATE can be used only to release space that was created by a previous ALLOCATE. Thus
13    the following is invalid:



14    REAL, TARGET :: T

15    REAL, POINTER :: P

16          ...

17    P = >        T

18    DEALLOCATE (P) ! Not allowed: P's target was not allocated



19    The basic principle is that ALLOCATE, NULLIFY, and pointer assignment primarily affect the pointer
20    rather than the target. ALLOCATE creates a new target but, other than breaking its connection with
21    the specified pointer, it has no effect on the old target. Neither NULLIFY nor pointer assignment has
22    any effect on targets. A piece of memory that was allocated and associated with a pointer will become
23    inaccessible to a program if the pointer is nullified or associated with a different target and no other
24    pointer was associated with this piece of memory. Such pieces of memory may be reused by the processor
25    if this is expedient. However, whether such inaccessible memory is in fact reused is entirely processor
26    dependent.



27    C.4          Section 7 notes

28    C.4.1             Character assignment

29    The Fortran 77 restriction that none of the character positions being defined in the character assign-
30    ment statement may be referenced in the expression has been removed (7.4.1.3).


31    C.4.2             Evaluation of function references

32    If more than one function reference appears in a statement, they may be executed in any order (subject to
33    a function result being evaluated after the evaluation of its arguments) and their values shall not depend
34    on the order of execution. This lack of dependence on order of evaluation permits parallel execution of
35    the function references (7.1.8.1).





      SEP 2002                                     WORKING DRAFT                                           443


      J3/02-007R3                                WORKING DRAFT                                        SEP 2002


 1    C.4.3     Pointers in expressions

 2    A pointer is basically considered to be like any other variable when it is used as a primary in an expression.
 3    If a pointer is used as an operand to an operator that expects a value, the pointer will automatically
 4    deliver the value stored in the space described by the pointer, that is, the value of the target object
 5    associated with the pointer.


 6    C.4.4     Pointers on the left side of an assignment

 7    A pointer that appears on the left of an intrinsic assignment statement also is dereferenced and is taken
 8    to be referring to the space that is its current target. Therefore, the assignment statement specifies the
 9    normal copying of the value of the right-hand expression into this target space. All the normal rules of
10    intrinsic assignment hold; the type and type parameters of the expression and the pointer target shall
11    agree and the shapes shall be conformable.

12    For intrinsic assignment of derived types, nonpointer components are assigned and pointer components
13    are pointer assigned. Dereferencing is applied only to entire scalar objects, not selectively to pointer
14    subobjects.

15    For example, suppose a type such as



16    TYPE CELL

17       INTEGER :: VAL

18       TYPE (CELL), POINTER :: NEXT_CELL

19    END TYPE CELL


20    is defined and objects such as HEAD and CURRENT are declared using



21    TYPE (CELL), TARGET :: HEAD

22    TYPE (CELL), POINTER :: CURRENT


23    If a linked list has been created and attached to HEAD and the pointer CURRENT has been allocated
24    space, statements such as

25    CURRENT = HEAD
26    CURRENT = CURRENT % NEXT CELL

27    cause the contents of the cells referenced on the right to be copied to the cell referred to by CURRENT.
28    In particular, the right-hand side of the second statement causes the pointer component in the cell,
29    CURRENT, to be selected. This pointer is dereferenced because it is in an expression context to produce
30    the target's integer value and a pointer to a cell that is in the target's NEXT CELL component. The
31    left-hand side causes the pointer CURRENT to be dereferenced to produce its present target, namely
32    space to hold a cell (an integer and a cell pointer). The integer value on the right is copied to the integer
33    space on the left and the pointer component is pointer assigned (the descriptor on the right is copied
34    into the space for a descriptor on the left). When a statement such as

35    CURRENT => CURRENT % NEXT CELL

36    is executed, the descriptor value in CURRENT % NEXT CELL is copied to the descriptor named
37    CURRENT. In this case, CURRENT is made to point at a different target.

38    In the intrinsic assignment statement, the space associated with the current pointer does not change but
39    the values stored in that space do. In the pointer assignment, the current pointer is made to associate



      444                                  WORKING DRAFT                                              SEP 2002


      SEP 2002                              WORKING DRAFT                                    J3/02-007R3



 1    with different space. Using the intrinsic assignment causes a linked list of cells to be moved up through
 2    the current "window"; the pointer assignment causes the current pointer to be moved down through the
 3    list of cells.


 4    C.4.5      An example of a FORALL construct containing a WHERE construct


 5    INTEGER :: A(5,5)

 6    ...

 7    FORALL (I = 1:5)

 8        WHERE (A(I,:) == 0)

 9             A(:,I) = I

10        ELSEWHERE (A(I,:) > 2)

11             A(I,:) = 6

12        END WHERE

13    END FORALL



14    If prior to execution of the FORALL, A has the value



15    A =          1    0    0    0    0

16                 2    1    1    1    0

17                 1    2    2    0    2

18                 2    1    0    2    3

19                 1    0    0    0    0



20    After execution of the assignment statements following the WHERE statement A has the value A'. The
21    mask created from row one is used to mask the assignments to column one; the mask from row two is
22    used to mask assignments to column two; etc.



23    A' =         1    0    0    0    0

24                 1    1    1    1    5

25                 1    2    2    4    5

26                 1    1    3    2    5

27                 1    2    0    0    5



28    The masks created for assignments following the ELSEWHERE statement are

29    .NOT. (A(I,:)          == 0) .AND. (A'(I,:)    > 2)

30    Thus the only elements affected by the assignments following the ELSEWHERE statement are A(3, 5)
31    and A(4, 5). After execution of the FORALL construct, A has the value



32    A =          1    0    0    0    0

33                 1    1    1    1    5

34                 1    2    2    4    6

35                 1    1    3    2    6

36                 1    2    0    0    5




      SEP 2002                                       WORKING DRAFT                                       445


      J3/02-007R3                                 WORKING DRAFT                                   SEP 2002


 1    C.4.6         Examples of FORALL statements

 2    Example 1:

 3    FORALL (J=1:M, K=1:N) X(K, J) = Y(J, K)
 4    FORALL (K=1:N) X(K, 1:M) = Y(1:M, K)

 5    These statements both copy columns 1 through N of array Y into rows 1 through N of array X. They
 6    are equivalent to

 7    X(1:N, 1:M) = TRANSPOSE (Y(1:M, 1:N) )

 8    Example 2:

 9    The following FORALL statement computes five partial sums of subarrays of J.

10    J = (/ 1, 2, 3, 4, 5 /)
11    FORALL (K = 1:5) J(K) = SUM (J(1:K) )

12    SUM is allowed in a FORALL because intrinsic functions are pure (12.6). After execution of the FORALL
13    statement, J = (/ 1, 3, 6, 10, 15 /).

14    Example 3:

15    FORALL (I = 2:N-1) X(I) = (X(I-1) + 2*X(I) + X(I+1) ) / 4

16    has the same effect as

17    X(2:N-1) = (X(1:N-2) + 2*X(2:N-1) + X(3:N) ) / 4



18    C.5       Section 8 notes

19    C.5.1         Loop control

20    Fortran provides several forms of loop control:

21           (1)      With an iteration count and a DO variable. This is the classic Fortran DO loop.

22           (2)      Test a logical condition before each execution of the loop (DO WHILE).

23           (3)      DO "forever".


24    C.5.2         The CASE construct

25    At most one case block is selected for execution within a CASE construct, and there is no fall-through
26    from one block into another block within a CASE construct. Thus there is no requirement for the user
27    to exit explicitly from a block.


28    C.5.3         Examples of DO constructs

29    The following are all valid examples of block DO constructs.

30    Example 1:



31             SUM = 0.0

32             READ (IUN) N




      446                                   WORKING DRAFT                                         SEP 2002


      SEP 2002                                  WORKING DRAFT                                 J3/02-007R3



 1              OUTER: DO L = 1, N                    ! A DO with a construct name

 2                READ (IUN) IQUAL, M, ARRAY (1:M)

 3                IF (IQUAL < IQUAL_MIN) CYCLE OUTER                     ! Skip inner loop

 4                INNER: DO 40 I = 1, M               ! A DO with a label and a name

 5                       CALL CALCULATE (ARRAY (I), RESULT)

 6                       IF (RESULT < 0.0) CYCLE

 7                       SUM = SUM + RESULT

 8                       IF (SUM > SUM_MAX) EXIT OUTER

 9        40       END DO INNER

10              END DO OUTER



11    The outer loop has an iteration count of MAX (N, 0), and will execute that number of times or until
12    SUM exceeds SUM MAX, in which case the EXIT OUTER statement terminates both loops. The inner
13    loop is skipped by the first CYCLE statement if the quality flag, IQUAL, is too low. If CALCULATE
14    returns a negative RESULT, the second CYCLE statement prevents it from being summed. Both loops
15    have construct names and the inner loop also has a label. A construct name is required in the EXIT
16    statement in order to terminate both loops, but is optional in the CYCLE statements because each
17    belongs to its innermost loop.

18    Example 2:



19              N = 0

20              DO 50, I = 1, 10

21                J = I

22                DO K = 1, 5

23                       L = K

24                       N = N + 1    ! This statement executes 50 times

25                END DO              ! Nonlabeled DO inside a labeled DO

26        50 CONTINUE



27    After execution of the above program fragment, I = 11, J = 10, K = 6, L = 5, and N = 50.

28    Example 3:



29              N = 0

30              DO I = 1, 10

31                J = I

32                DO 60, K = 5, 1         ! This inner loop is never executed

33                       L = K

34                       N = N + 1

35        60       CONTINUE               ! Labeled DO inside a nonlabeled DO

36              END DO



37    After execution of the above program fragment, I = 11, J = 10, K = 5, N = 0, and L is not defined by
38    these statements.


39    The following are all valid examples of nonblock DO constructs:




      SEP 2002                                         WORKING DRAFT                                 447


      J3/02-007R3                                        WORKING DRAFT                                        SEP 2002



 1    Example 4:



 2             DO 70

 3                READ (IUN, '(1X, G14.7)', IOSTAT = IOS) X

 4                IF (IOS /= 0) EXIT

 5                IF (X < 0.) GOTO 70

 6                CALL SUBA (X)

 7                CALL SUBB (X)

 8                         ...

 9                CALL SUBY (X)

10                CYCLE

11       70       CALL SUBNEG (X)        ! SUBNEG called only when X < 0.



12    This is not a block DO construct because it ends with a statement other than END DO or CONTINUE. The loop will

13    continue to execute until an end-of-file condition or input/output error occurs.


14    Example 5:



15             SUM = 0.0

16             READ (IUN) N

17             DO 80, L = 1, N

18                READ (IUN) IQUAL, M, ARRAY (1:M)

19                IF (IQUAL < IQUAL_MIN) M = 0        ! Skip inner loop

20                DO 80 I = 1, M

21                      CALL CALCULATE (ARRAY (I), RESULT)

22                      IF (RESULT < 0.) CYCLE

23                      SUM = SUM + RESULT

24                      IF (SUM > SUM_MAX) GOTO 81

25       80       CONTINUE        ! This CONTINUE is shared by both loops

26       81 CONTINUE



27    This example is similar to Example 1 above, except that the two loops are not block DO constructs because they share

28    the CONTINUE statement with the label 80. The terminal construct of the outer DO is the entire inner DO construct.

29    The inner loop is skipped by forcing M to zero. If SUM grows too large, both loops are terminated by branching to the

30    CONTINUE statement labeled 81. The CYCLE statement in the inner loop is used to skip negative values of RESULT.


31    Example 6:



32             N = 0

33             DO 100 I = 1, 10

34                J = I

35                DO 100 K = 1, 5

36                      L = K

37      100             N = N + 1     ! This statement executes 50 times



38    In this example, the two loops share an assignment statement. After execution of this program fragment, I = 11, J = 10,

39    K = 6, L = 5, and N = 50.


40    Example 7:



41             N = 0

42             DO 200 I = 1, 10

43                J = I




      448                                          WORKING DRAFT                                              SEP 2002


      SEP 2002                                    WORKING DRAFT                                           J3/02-007R3



 1                DO 200 K = 5, 1     ! This inner loop is never executed

 2                    L = K

 3      200           N = N + 1



 4    This example is very similar to the previous one, except that the inner loop is never executed. After execution of this

 5    program fragment, I = 11, J = 10, K = 5, N = 0, and L is not defined by these statements.



 6    C.5.4        Examples of invalid DO constructs

 7    The following are all examples of invalid skeleton DO constructs:

 8    Example 1:


 9    DO I = 1, 10

10        ...

11    END DO LOOP              ! No matching construct name


12    Example 2:


13    LOOP: DO 1000 I = 1, 10               ! No matching construct name

14        ...

15    1000       CONTINUE


16    Example 3:


17    LOOP1: DO

18        ...

19    END DO LOOP2              ! Construct names don't match


20    Example 4:


21    DO I = 1, 10              ! Label required or ...

22        ...

23    1010 CONTINUE             ! ... END DO required


24    Example 5:


25    DO 1020 I = 1, 10

26        ...

27    1021 END DO                   ! Labels don't match


28    Example 6:


29    FIRST: DO I = 1, 10

30        SECOND: DO J = 1, 5

31             ...

32        END DO FIRST             ! Improperly nested DOs

33    END DO SECOND



      SEP 2002                                          WORKING DRAFT                                                  449


      J3/02-007R3                                WORKING DRAFT                                     SEP 2002


 1    C.6        Section 9 notes

 2    C.6.1      External files (9.2)

 3    This standard accommodates, but does not require, file cataloging. To do this, several concepts are
 4    introduced.


 5    C.6.1.1    File connection (9.4)

 6    Before any input/output may be performed on a file, it shall be connected to a unit. The unit then serves
 7    as a designator for that file as long as it is connected. To be connected does not imply that "buffers"
 8    have or have not been allocated, that "file-control tables" have or have not been filled, or that any other
 9    method of implementation has been used. Connection means that (barring some other fault) a READ
10    or WRITE statement may be executed on the unit, hence on the file. Without a connection, a READ
11    or WRITE statement shall not be executed.


12    C.6.1.2    File existence (9.2.1)

13    Totally independent of the connection state is the property of existence, this being a file property. The
14    processor "knows" of a set of files that exist at a given time for a given program. This set would include
15    tapes ready to read, files in a catalog, a keyboard, a printer, etc. The set may exclude files inaccessible
16    to the program because of security, because they are already in use by another program, etc. This
17    standard does not specify which files exist, hence wide latitude is available to a processor to implement
18    security, locks, privilege techniques, etc. Existence is a convenient concept to designate all of the files
19    that a program can potentially process.

20    All four combinations of connection and existence may occur:


                       Connect    Exist    Examples

                       Yes        Yes      A card reader loaded and ready to be read
                       Yes        No       A printer before the first line is written
                       No         Yes      A file named 'JOAN' in the catalog
                       No         No       A file on a reel of tape, not known to the processor



21    Means are provided to create, delete, connect, and disconnect files.


22    C.6.1.3    File names (9.4.5.7)

23    A file may have a name. The form of a file name is not specified. If a system does not have some form of
24    cataloging or tape labeling for at least some of its files, all file names will disappear at the termination
25    of execution. This is a valid implementation. Nowhere does this standard require names to survive for
26    any period of time longer than the execution time span of a program. Therefore, this standard does not
27    impose cataloging as a prerequisite. The naming feature is intended to allow use of a cataloging system
28    where one exists.


29    C.6.1.4    File access (9.2.2)

30    This standard does not address problems of security, protection, locking, and many other concepts that
31    may be part of the concept of "right of access". Such concepts are considered to be in the province of
32    an operating system.

33    The OPEN and INQUIRE statements can be extended naturally to consider these things.





      450                                  WORKING DRAFT                                           SEP 2002


      SEP 2002                               WORKING DRAFT                                     J3/02-007R3



 1    Possible access methods for a file are: sequential and direct. The processor may implement two different
 2    types of files, each with its own access method. It might also implement one type of file with two different
 3    access methods.

 4    Direct access to files is of a simple and commonly available type, that is, fixed-length records. The key
 5    is a positive integer.


 6    C.6.2       Nonadvancing input/output (9.2.3.1)

 7    Data transfer statements affect the positioning of an external file. In Fortran 77, if no error or end-of-
 8    file condition exists, the file is positioned after the record just read or written and that record becomes
 9    the preceding record. This standard contains the record positioning ADVANCE= specifier in a data
10    transfer statement that provides the capability of maintaining a position within the current record from
11    one formatted data transfer statement to the next data transfer statement. The value NO provides this
12    capability. The value YES positions the file after the record just read or written. The default is YES.

13    The tab edit descriptor and the slash are still appropriate for use with this type of record access but the
14    tab will not reposition before the left tab limit.

15    A BACKSPACE of a file that is positioned within a record causes the specified unit to be positioned
16    before the current record.

17    If the last data transfer statement was WRITE and the file is positioned within a record, the file will be
18    positioned implicitly after the current record before an ENDFILE record is written to the file, that is, a
19    REWIND, BACKSPACE, or ENDFILE statement following a nonadvancing WRITE statement causes
20    the file to be positioned at the end of the current output record before the endfile record is written to
21    the file.

22    This standard provides a SIZE= specifier to be used with nonadvancing data transfer statements. The
23    variable in the SIZE= specifier will contain the count of the number of characters that make up the
24    sequence of values read by the data edit descriptors in this input statement.

25    The count is especially helpful if there is only one list item in the input list since it will contain the
26    number of characters that were present for the item.

27    The EOR= specifier is provided to indicate when an end-of-record condition has been encountered during
28    a nonadvancing data transfer statement. The end-of-record condition is not an error condition. If this
29    specifier is present, the current input list item that required more characters than the record contained
30    will be padded with blanks if PAD= 'YES' is in effect. This means that the input list item was successfully
31    completed. The file will then be positioned after the current record. The IOSTAT= specifier, if present,
32    will be defined with the value of the named constant IOSTAT EOR from the ISO Fortran ENV module
33    and the data transfer statement will be terminated. Program execution will continue with the statement
34    specified in the EOR= specifier. The EOR= specifier gives the capability of taking control of execution
35    when the end-of-record has been found. Implied-DO variables retain their last defined value and any
36    remaining items in the input-item-list retain their definition status when an end-of-record condition
37    occurs. The SIZE= specifier, if present, will contain the number of characters read with the data edit
38    descriptors during this READ statement.

39    For nonadvancing input, the processor is not required to read partial records. The processor may read
40    the entire record into an internal buffer and make successive portions of the record available to successive
41    input statements.

42    In an implementation of nonadvancing input/output in which a nonadvancing write to a terminal device
43    causes immediate display of the output, such a write can be used as a mechanism to output a prompt.
44    In this case, the statement





      SEP 2002                                     WORKING DRAFT                                            451


      J3/02-007R3                                 WORKING DRAFT                                      SEP 2002



 1    WRITE (*, FMT='(A)', ADVANCE='NO') 'CONTINUE?(Y/N): '

 2    would result in the prompt

 3    CONTINUE?(Y/N):

 4    being displayed with no subsequent line feed.

 5    The response, which might be read by a statement of the form

 6    READ (*, FMT='(A)') ANSWER

 7    can then be entered on the same line as the prompt as in

 8    CONTINUE?(Y/N): Y

 9    The standard does not require that an implementation of nonadvancing input/output operate in this
10    manner. For example, an implementation of nonadvancing output in which the display of the output is
11    deferred until the current record is complete is also standard conforming. Such an implementation will
12    not, however, allow a prompting mechanism of this kind to operate.


13    C.6.3         Asynchronous input/output

14    Rather than limit support for asynchronous input/output to what has been traditionally provided by
15    facilities such as BUFFERIN/BUFFEROUT, this standard builds upon existing Fortran syntax. This
16    permits alternative approaches for implementing asynchronous input/output, and simplifies the task of
17    adapting existing standard conforming programs to use asynchronous input/output.

18    Not all processors will actually perform input/output asynchronously, nor will every processor that does
19    be able to handle data transfer statements with complicated input/output item lists in an asynchronous
20    manner. Such processors can still be standard conforming. Hopefully, the documentation for each
21    Fortran processor will describe when, if ever, input/output will be performed asynchronously.

22    This standard allows for at least two different conceptual models for asynchronous input/output.

23    Model 1: the processor will perform asynchronous input/output when the item list is simple (perhaps
24    one contiguous named array) and the input/output is unformatted. The implementation cost is reduced,
25    and this is the scenario most likely to be beneficial on traditional "big-iron" machines.

26    Model 2: The processor is free to do any of the following:

27           (1)     on output, create a buffer inside the input/output library, completely formatted, and then
28                   start an asynchronous write of the buffer, and immediately return to the next statement in
29                   the program. The processor is free to wait for previously issued WRITEs, or not, or

30           (2)     pass the input/output list addresses to another processor/process, which will process the
31                   list items independently of the processor that executes the user's code. The addresses of the
32                   list items must be computed before the asynchronous READ/WRITE statement completes.
33                   There is still an ordering requirement on list item processing to handle things like READ
34                   (...) N,(a(i),i=1,N).

35    The standard allows a user to issue a large number of asynchronous input/output requests, without
36    waiting for any of them to complete, and then wait for any or all of them. It may be impossible, and
37    undesirable to keep track of each of these input/output requests individually.

38    It is not necessary for all requests to be tracked by the runtime library. If an ID= specifier does not
39    appear in on a READ or WRITE statement, the runtime is free to forget about this particular request
40    once it has successfully completed. If it gets an ERR or END condition, the processor is free to report
41    this during any input/output operation to that unit. When an ID= specifier is present, the processor's



      452                                     WORKING DRAFT                                          SEP 2002


      SEP 2002                              WORKING DRAFT                                      J3/02-007R3



 1    runtime input/output library is required to keep track of any END or ERR conditions for that particular
 2    input/output request. However, if the input/output request succeeds without any exceptional conditions
 3    occurring, then the runtime can forget that ID= value if it wishes. Typically, a runtime might only keep
 4    track of the last request made, or perhaps a very few. Then, when a user WAITs for a particular request,
 5    either the library knows about it (and does the right thing with respect to error handling, etc.), or will
 6    assume it is one of those requests that successfully completed and was forgotten about (and will just
 7    return without signaling any end or error conditions). It is incumbent on the user to pass valid ID=
 8    values. There is no requirement on the processor to detect invalid ID= values. There is of course,
 9    a processor dependent limit on how many outstanding input/output requests that generate an end or
10    error condition can be handled before the processor runs out of memory to keep track of such conditions.
11    The restrictions on the SIZE= variables are designed to allow the processor to update such variables at
12    any time (after the request has been processed, but before the WAIT operation), and then forget about
13    them. That's why there is no SIZE= specifier allowed in the various WAIT operations. Only exceptional
14    conditions (errors or ends of files) are expected to be tracked by individual request by the runtime, and
15    then only if an ID= specifier was present. The END= and EOR= specifiers have not been added to all
16    statements that can be WAIT operations. Instead, the IOSTAT variable will have to be queried after a
17    WAIT operation to handle this situation. This choice was made because we expect the WAIT statement
18    to be the usual method of waiting for input/output to complete (and WAIT does support the END=
19    and EOR= specifiers). This particular choice is philosophical, and was not based on significant technical
20    difficulties.

21    Note that the requirement to set the IOSTAT variable correctly requires an implementation to remember
22    which input/output requests got an EOR condition, so that a subsequent wait operation will return the
23    correct IOSTAT value. This means there is a processor defined limit on the number of outstanding
24    nonadvancing input/output requests that got an EOR condition (constrained by available memory to
25    keep track of this information, similar to END/ERR conditions).


26    C.6.4    OPEN statement (9.4.5)

27    A file may become connected to a unit either by preconnection or by execution of an OPEN statement.
28    Preconnection is performed prior to the beginning of execution of a program by means external to For-
29    tran. For example, it may be done by job control action or by processor-established defaults. Execution
30    of an OPEN statement is not required to access preconnected files (9.4.4).

31    The OPEN statement provides a means to access existing files that are not preconnected. An OPEN
32    statement may be used in either of two ways: with a file name (open-by-name) and without a file name
33    (open-by-unit). A unit is given in either case. Open-by-name connects the specified file to the specified
34    unit. Open-by-unit connects a processor-dependent default file to the specified unit. (The default file
35    may or may not have a name.)

36    Therefore, there are three ways a file may become connected and hence processed: preconnection, open-
37    by-name, and open-by-unit. Once a file is connected, there is no means in standard Fortran to determine
38    how it became connected.

39    An OPEN statement may also be used to create a new file. In fact, any of the foregoing three connection
40    methods may be performed on a file that does not exist. When a unit is preconnected, writing the first
41    record creates the file. With the other two methods, execution of the OPEN statement creates the file.

42    When an OPEN statement is executed, the unit specified in the OPEN may or may not already be
43    connected to a file. If it is already connected to a file (either through preconnection or by a prior OPEN),
44    then omitting the FILE= specifier in the OPEN statement implies that the file is to remain connected
45    to the unit. Such an OPEN statement may be used to change the values of the blank interpretation
46    mode, decimal edit mode, pad mode, I/O rounding mode, delimiter mode, and sign mode.

47    If the value of the ACTION= specifier is WRITE, then READ statements shall not refer to this connec-




      SEP 2002                                    WORKING DRAFT                                            453


      J3/02-007R3                                 WORKING DRAFT                                  SEP 2002



 1    tion. ACTION = 'WRITE' does not restrict positioning by a BACKSPACE statement or positioning
 2    specified by the POSITION= specifier with the value APPEND. However, a BACKSPACE statement
 3    or an OPEN statement containing POSITION = 'APPEND' may fail if the processor requires reading
 4    of the file to achieve the positioning.

 5    The following examples illustrate these rules. In the first example, unit 10 is preconnected to a SCRATCH
 6    file; the OPEN statement changes the value of PAD= to YES.


 7    CHARACTER (LEN = 20) CH1

 8    WRITE (10, '(A)') 'THIS IS RECORD 1'

 9    OPEN (UNIT = 10, STATUS = 'OLD', PAD = 'YES')

10    REWIND 10

11    READ (10, '(A20)') CH1         ! CH1 now has the value

12                                   ! 'THIS IS RECORD 1          '


13    In the next example, unit 12 is first connected to a file named FRED, with a status of OLD. The second
14    OPEN statement then opens unit 12 again, retaining the connection to the file FRED, but changing the
15    value of the DELIM= specifier to QUOTE.


16    CHARACTER (LEN = 25) CH2, CH3

17    OPEN (12, FILE = 'FRED', STATUS = 'OLD', DELIM = 'NONE')

18    CH2 = '''THIS STRING HAS QUOTES.'''

19                    ! Quotes in string CH2

20    WRITE (12, *) CH2                 ! Written with no delimiters

21    OPEN (12, DELIM = 'QUOTE')        ! Now quote is the delimiter

22    REWIND 12

23    READ (12, *) CH3      ! CH3 now has the value

24                          ! 'THIS STRING HAS QUOTES.       '


25    The next example is invalid because it attempts to change the value of the STATUS= specifier.


26    OPEN (10, FILE = 'FRED', STATUS = 'OLD')

27    WRITE (10, *) A, B, C

28    OPEN (10, STATUS = 'SCRATCH')             ! Attempts to make FRED

29                                              ! a SCRATCH file


30    The previous example could be made valid by closing the unit first, as in the next example.


31    OPEN (10, FILE = 'FRED', STATUS = 'OLD')

32    WRITE (10, *) A, B, C

33    CLOSE (10)

34    OPEN (10, STATUS = 'SCRATCH')             ! Opens a different

35                                              ! SCRATCH file


36    C.6.5      Connection properties (9.4.3)

37    When a unit becomes connected to a file, either by execution of an OPEN statement or by preconnection,
38    the following connection properties, among others, may be established:



      454                                 WORKING DRAFT                                          SEP 2002


      SEP 2002                                  WORKING DRAFT                                       J3/02-007R3



 1           (1)      An access method, which is sequential, direct, or stream, is established for the connection
 2                    (9.4.5.1).

 3           (2)      A form, which is formatted or unformatted, is established for a connection to a file that
 4                    exists or is created by the connection. For a connection that results from execution of an
 5                    OPEN statement, a default form (which depends on the access method, as described in
 6                    9.2.2) is established if no form is specified. For a preconnected file that exists, a form is
 7                    established by preconnection. For a preconnected file that does not exist, a form may be
 8                    established, or the establishment of a form may be delayed until the file is created (for
 9                    example, by execution of a formatted or unformatted WRITE statement) (9.4.5.8).

10           (3)      A record length may be established. If the access method is direct, the connection establishes
11                    a record length that specifies the length of each record of the file. An existing file with records
12                    that are not all of equal length shall not be connected for direct access.

13                    If the access method is sequential, records of varying lengths are permitted. In this case,
14                    the record length established specifies the maximum length of a record in the file (9.4.5.11).

15    A processor has wide latitude in adapting these concepts and actions to its own cataloging and job
16    control conventions. Some processors may require job control action to specify the set of files that
17    exist or that will be created by a program. Some processors may require no job control action prior to
18    execution. This standard enables processors to perform dynamic open, close, or file creation operations,
19    but it does not require such capabilities of the processor.

20    The meaning of "open" in contexts other than Fortran may include such things as mounting a tape,
21    console messages, spooling, label checking, security checking, etc. These actions may occur upon job
22    control action external to Fortran, upon execution of an OPEN statement, or upon execution of the first
23    read or write of the file. The OPEN statement describes properties of the connection to the file and
24    may or may not cause physical activities to take place. It is a place for an implementation to define
25    properties of a file beyond those required in standard Fortran.


26    C.6.6         CLOSE statement (9.4.6)

27    Similarly, the actions of dismounting a tape, protection, etc. of a "close" may be implicit at the end of
28    a run. The CLOSE statement may or may not cause such actions to occur. This is another place to
29    extend file properties beyond those of standard Fortran. Note, however, that the execution of a CLOSE
30    statement on a unit followed by an OPEN statement on the same unit to the same file or to a different
31    file is a permissible sequence of events. The processor shall not deny this sequence solely because the
32    implementation chooses to do the physical act of closing the file at the termination of execution of the
33    program.



34    C.7      Section 10 notes

35    C.7.1         Number of records (10.3, 10.4, 10.7.2)

36    The number of records read by an explicitly formatted advancing input statement can be determined
37    from the following rule: a record is read at the beginning of the format scan (even if the input list is
38    empty), at each slash edit descriptor encountered in the format, and when a format rescan occurs at the
39    end of the format.

40    The number of records written by an explicitly formatted advancing output statement can be determined
41    from the following rule: a record is written when a slash edit descriptor is encountered in the format,
42    when a format rescan occurs at the end of the format, and at completion of execution of the output
43    statement (even if the output list is empty). Thus, the occurrence of n successive slashes between two
44    other edit descriptors causes n - 1 blank lines if the records are printed. The occurrence of n slashes at
45    the beginning or end of a complete format specification causes n blank lines if the records are printed.



      SEP 2002                                        WORKING DRAFT                                              455


      J3/02-007R3                               WORKING DRAFT                                     SEP 2002



 1    However, a complete format specification containing n slashes (n > 0) and no other edit descriptors
 2    causes n + 1 blank lines if the records are printed. For example, the statements

 3      PRINT 3
 4    3 FORMAT (/)

 5    will write two records that cause two blank lines if the records are printed.


 6    C.7.2       List-directed input (10.9.1)

 7    The following examples illustrate list-directed input. A blank character is represented by b.

 8    Example 1:

 9    Program:



10    J = 3

11    READ *, I

12    READ *, J



13    Sequential input file:



14    record 1:     b1b,4bbbbb

15    record 2:     ,2bbbbbbbb



16    Result: I = 1, J = 3.

17    Explanation: The second READ statement reads the second record. The initial comma in the record
18    designates a null value; therefore, J is not redefined.

19    Example 2:

20    Program:



21    CHARACTER A *8, B *1

22    READ *, A, B



23    Sequential input file:



24    record 1:     'bbbbbbbb'

25    record 2:     'QXY'b'Z'



26    Result: A = 'bbbbbbbb', B = 'Q'

27    Explanation: In the first record, the rightmost apostrophe is interpreted as delimiting the constant (it
28    cannot be the first of a pair of embedded apostrophes representing a single apostrophe because this
29    would involve the prohibited "splitting" of the pair by the end of a record); therefore, A is assigned
30    the character constant 'bbbbbbbb'. The end of a record acts as a blank, which in this case is a value
31    separator because it occurs between two constants.




      456                                 WORKING DRAFT                                           SEP 2002


      SEP 2002                                  WORKING DRAFT                                       J3/02-007R3


 1    C.8      Section 11 notes

 2    C.8.1         Main program and block data program unit (11.1, 11.3)

 3    The name of the main program or of a block data program unit has no explicit use within the Fortran
 4    language. It is available for documentation and for possible use by a processor.

 5    A processor may implement an unnamed main program or unnamed block data program unit by assigning
 6    it a default name. However, this name shall not conflict with any other global name in a standard-
 7    conforming program. This might be done by making the default name one that is not permitted in a
 8    standard-conforming program (for example, by including a character not normally allowed in names)
 9    or by providing some external mechanism such that for any given program the default name can be
10    changed to one that is otherwise unused.


11    C.8.2         Dependent compilation (11.2)

12    This standard, like its predecessors, is intended to permit the implementation of conforming processors
13    in which a program can be broken into multiple units, each of which can be separately translated in
14    preparation for execution. Such processors are commonly described as supporting separate compilation.
15    There is an important difference between the way separate compilation can be implemented under this
16    standard and the way it could be implemented under the Fortran 77 standard. Under the Fortran
17    77 standard, any information required to translate a program unit was specified in that program unit.
18    Each translation was thus totally independent of all others. Under this standard, a program unit can use
19    information that was specified in a separate module and thus may be dependent on that module. The
20    implementation of this dependency in a processor may be that the translation of a program unit may
21    depend on the results of translating one or more modules. Processors implementing the dependency this
22    way are commonly described as supporting dependent compilation.

23    The dependencies involved here are new only in the sense that the Fortran processor is now aware
24    of them. The same information dependencies existed under the Fortran 77 standard, but it was the
25    programmer's responsibility to transport the information necessary to resolve them by making redundant
26    specifications of the information in multiple program units. The availability of separate but dependent
27    compilation offers several potential advantages over the redundant textual specification of information:

28           (1)      Specifying information at a single place in the program ensures that different program units
29                    using that information will be translated consistently. Redundant specification leaves the
30                    possibility that different information will erroneously be specified. Even if an INCLUDE line
31                    is used to ensure that the text of the specifications is identical in all involved program units,
32                    the presence of other specifications (for example, an IMPLICIT statement) may change the
33                    interpretation of that text.

34           (2)      During the revision of a program, it is possible for a processor to assist in determining
35                    whether different program units have been translated using different (incompatible) versions
36                    of a module, although there is no requirement that a processor provide such assistance.
37                    Inconsistencies in redundant textual specification of information, on the other hand, tend
38                    to be much more difficult to detect.

39           (3)      Putting information in a module provides a way of packaging it. Without modules, redun-
40                    dant specifications frequently shall be interleaved with other specifications in a program
41                    unit, making convenient packaging of such information difficult.

42           (4)      Because a processor may be implemented such that the specifications in a module are
43                    translated once and then repeatedly referenced, there is the potential for greater efficiency
44                    than when the processor shall translate redundant specifications of information in multiple
45                    program units.

46    The exact meaning of the requirement that the public portions of a module be available at the time of




      SEP 2002                                        WORKING DRAFT                                              457


      J3/02-007R3                               WORKING DRAFT                                      SEP 2002



 1    reference is processor dependent. For example, a processor could consider a module to be available only
 2    after it has been compiled and require that if the module has been compiled separately, the result of
 3    that compilation shall be identified to the compiler when compiling program units that use it.


 4    C.8.2.1    USE statement and dependent compilation (11.2.2)

 5    Another benefit of the USE statement is its enhanced facilities for name management. If one needs to
 6    use only selected entities in a module, one can do so without having to worry about the names of all
 7    the other entities in that module. If one needs to use two different modules that happen to contain
 8    entities with the same name, there are several ways to deal with the conflict. If none of the entities with
 9    the same name are to be used, they can simply be ignored. If the name happens to refer to the same
10    entity in both modules (for example, if both modules obtained it from a third module), then there is no
11    confusion about what the name denotes and the name can be freely used. If the entities are different
12    and one or both is to be used, the local renaming facility in the USE statement makes it possible to give
13    those entities different names in the program unit containing the USE statements.

14    A benefit of using the ONLY specifier consistently, as compared to USE without it, is that the module
15    from which each accessed entity is accessed is explicitly specified in each program unit. This means that
16    one need not search other program units to find where each one is defined. This reduces maintenance
17    costs.

18    A typical implementation of dependent but separate compilation may involve storing the result of trans-
19    lating a module in a file (or file element) whose name is derived from the name of the module. Note,
20    however, that the name of a module is limited only by the Fortran rules and not by the names allowed
21    in the file system. Thus the processor may have to provide a mapping between Fortran names and file
22    system names.

23    The result of translating a module could reasonably either contain only the information textually specified
24    in the module (with "pointers" to information originally textually specified in other modules) or contain
25    all information specified in the module (including copies of information originally specified in other
26    modules). Although the former approach would appear to save on storage space, the latter approach
27    can greatly simplify the logic necessary to process a USE statement and can avoid the necessity of
28    imposing a limit on the logical "nesting" of modules via the USE statement.

29    Variables declared in a module retain their definition status on much the same basis as variables in
30    a common block. That is, saved variables retain their definition status throughout the execution of a
31    program, while variables that are not saved retain their definition status only during the execution of
32    scoping units that reference the module. In some cases, it may be appropriate to put a USE statement
33    such as

34    USE MY MODULE, ONLY:

35    in a scoping unit in order to assure that other procedures that it references can communicate through
36    the module. In such a case, the scoping unit would not access any entities from the module, but the
37    variables not saved in the module would retain their definition status throughout the execution of the
38    scoping unit.

39    There is an increased potential for undetected errors in a scoping unit that uses both implicit typing
40    and the USE statement. For example, in the program fragment



41    SUBROUTINE SUB

42       USE MY_MODULE

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

44       X = F (B)




      458                                 WORKING DRAFT                                            SEP 2002


      SEP 2002                              WORKING DRAFT                                    J3/02-007R3



 1       A = G (X) + H (X + 1)

 2    END SUBROUTINE SUB



 3    X could be either an implicitly typed real variable or a variable obtained from the module MY MODULE
 4    and might change from one to the other because of changes in MY MODULE unrelated to the action
 5    performed by SUB. Logic errors resulting from this kind of situation can be extremely difficult to locate.
 6    Thus, the use of these features together is discouraged.


 7    C.8.2.2    Accessibility attributes (11.2.1)

 8    The PUBLIC and PRIVATE attributes, which can be declared only in modules, divide the entities in a
 9    module into those that are actually relevant to a scoping unit referencing the module and those that are
10    not. This information may be used to improve the performance of a Fortran processor. For example,
11    it may be possible to discard much of the information about the private entities once a module has
12    been translated, thus saving on both storage and the time to search it. Similarly, it may be possible
13    to recognize that two versions of a module differ only in the private entities they contain and avoid
14    retranslating program units that use that module when switching from one version of the module to the
15    other.


16    C.8.3      Examples of the use of modules

17    C.8.3.1    Identical common blocks

18    A common block and all its associated specification statements may be placed in a module named, for
19    example, MY COMMON and accessed by a USE statement of the form

20    USE MY COMMON

21    that accesses the whole module without any renaming. This ensures that all instances of the common
22    block are identical. Module MY COMMON could contain more than one common block.


23    C.8.3.2    Global data

24    A module may contain only data objects, for example:



25    MODULE DATA_MODULE

26       SAVE

27       REAL A (10), B, C (20,20)

28       INTEGER :: I=0

29       INTEGER, PARAMETER :: J=10

30       COMPLEX D (J,J)

31    END MODULE DATA_MODULE



32    Data objects made global in this manner may have any combination of data types.

33    Access to some of these may be made by a USE statement with the ONLY option, such as:

34    USE DATA MODULE, ONLY: A, B, D

35    and access to all of them may be made by the following USE statement:

36    USE DATA MODULE



      SEP 2002                                        WORKING DRAFT                                      459


      J3/02-007R3                                 WORKING DRAFT                                SEP 2002



 1    Access to all of them with some renaming to avoid name conflicts may be made by:

 2    USE DATA MODULE, AMODULE => A, DMODULE => D


 3    C.8.3.3    Derived types

 4    A derived type may be defined in a module and accessed in a number of program units. For example:



 5    MODULE SPARSE

 6       TYPE NONZERO

 7           REAL A

 8           INTEGER        I, J

 9       END TYPE NONZERO

10    END MODULE SPARSE



11    defines a type consisting of a real component and two integer components for holding the numerical
12    value of a nonzero matrix element and its row and column indices.


13    C.8.3.4    Global allocatable arrays

14    Many programs need large global allocatable arrays whose sizes are not known before program execution.
15    A simple form for such a program is:



16    PROGRAM GLOBAL_WORK

17       CALL CONFIGURE_ARRAYS                ! Perform the appropriate allocations

18       CALL COMPUTE                         ! Use the arrays in computations

19    END PROGRAM GLOBAL_WORK

20    MODULE WORK_ARRAYS                      ! An example set of work arrays

21       INTEGER       N

22       REAL, ALLOCATABLE, SAVE :: A (:), B (:, :), C (:, :, :)

23    END MODULE WORK_ARRAYS

24    SUBROUTINE CONFIGURE_ARRAYS             ! Process to set up work arrays

25       USE WORK_ARRAYS

26       READ (*, *)         N

27       ALLOCATE (A (N), B (N, N), C (N, N, 2 * N))

28    END SUBROUTINE CONFIGURE_ARRAYS

29    SUBROUTINE COMPUTE

30       USE WORK_ARRAYS

31       ...     !    Computations involving arrays A, B, and C

32    END SUBROUTINE COMPUTE



33    Typically, many subprograms need access to the work arrays, and all such subprograms would contain
34    the statement

35    USE WORK ARRAYS





      460                                WORKING DRAFT                                         SEP 2002


      SEP 2002                             WORKING DRAFT                                    J3/02-007R3



 1    C.8.3.5    Procedure libraries

 2    Interface bodies for external procedures in a library may be gathered into a module. This permits the
 3    use of argument keywords and optional arguments, and allows static checking of the references. Different
 4    versions may be constructed for different applications, using argument keywords in common use in each
 5    application.

 6    An example is the following library module:



 7    MODULE LIBRARY_LLS

 8       INTERFACE

 9           SUBROUTINE LLS (X, A, F, FLAG)

10               REAL X (:, :)

11               ! The SIZE in the next statement is an intrinsic function

12               REAL, DIMENSION (SIZE (X, 2)) :: A, F

13               INTEGER FLAG

14           END SUBROUTINE LLS

15               ...

16       END INTERFACE

17           ...

18    END MODULE LIBRARY_LLS



19    This module allows the subroutine LLS to be invoked:



20    USE LIBRARY_LLS

21       ...

22    CALL LLS (X = ABC, A = D, F = XX, FLAG = IFLAG)

23       ...



24    C.8.3.6    Operator extensions

25    In order to extend an intrinsic operator symbol to have an additional meaning, an interface block
26    specifying that operator symbol in the OPERATOR option of the INTERFACE statement may be
27    placed in a module.

28    For example, // may be extended to perform concatenation of two derived-type objects serving as varying
29    length character strings and + may be extended to specify matrix addition for type MATRIX or interval
30    arithmetic addition for type INTERVAL.

31    A module might contain several such interface blocks. An operator may be defined by an external
32    function (either in Fortran or some other language) and its procedure interface placed in the module.


33    C.8.3.7    Data abstraction

34    In addition to providing a portable means of avoiding the redundant specification of information in
35    multiple program units, a module provides a convenient means of "packaging" related entities, such as
36    the definitions of the representation and operations of an abstract data type. The following example
37    of a module defines a data abstraction for a SET type where the elements of each set are of type
38    integer. The standard set operations of UNION, INTERSECTION, and DIFFERENCE are provided.
39    The CARDINALITY function returns the cardinality of (number of elements in) its set argument.



      SEP 2002                                   WORKING DRAFT                                          461


      J3/02-007R3                                WORKING DRAFT                                  SEP 2002



 1    Two functions returning logical values are included, ELEMENT and SUBSET. ELEMENT defines the
 2    operator .IN. and SUBSET extends the operator <=. ELEMENT determines if a given scalar integer
 3    value is an element of a given set, and SUBSET determines if a given set is a subset of another given
 4    set. (Two sets may be checked for equality by comparing cardinality and checking that one is a subset
 5    of the other, or checking to see if each is a subset of the other.)

 6    The transfer function SETF converts a vector of integer values to the corresponding set, with duplicate
 7    values removed. Thus, a vector of constant values can be used as set constants. An inverse transfer
 8    function VECTOR returns the elements of a set as a vector of values in ascending order. In this SET
 9    implementation, set data objects have a maximum cardinality of 200.


10    MODULE INTEGER_SETS

11    ! This module is intended to illustrate use of the module facility

12    ! to define a new type, along with suitable operators.

13

14    INTEGER, PARAMETER :: MAX_SET_CARD = 200

15

16    TYPE SET                                         ! Define SET type

17       PRIVATE

18       INTEGER CARD

19       INTEGER ELEMENT (MAX_SET_CARD)

20    END TYPE SET

21

22    INTERFACE OPERATOR (.IN.)

23       MODULE PROCEDURE ELEMENT

24    END INTERFACE OPERATOR (.IN.)

25

26    INTERFACE OPERATOR (<=)

27       MODULE PROCEDURE SUBSET

28    END INTERFACE OPERATOR (<=)

29

30    INTERFACE OPERATOR (+)

31       MODULE PROCEDURE UNION

32    END INTERFACE OPERATOR (+)

33

34    INTERFACE OPERATOR (-)

35       MODULE PROCEDURE DIFFERENCE

36    END INTERFACE OPERATOR (-)

37

38    INTERFACE OPERATOR (*)

39       MODULE PROCEDURE INTERSECTION

40    END INTERFACE OPERATOR (*)

41

42    CONTAINS

43

44    INTEGER FUNCTION CARDINALITY (A)            ! Returns cardinality of set A

45       TYPE (SET), INTENT (IN) :: A



      462                                  WORKING DRAFT                                        SEP 2002


      SEP 2002                          WORKING DRAFT                         J3/02-007R3



 1       CARDINALITY = A % CARD

 2    END FUNCTION CARDINALITY

 3

 4    LOGICAL FUNCTION ELEMENT (X, A)              ! Determines if

 5       INTEGER, INTENT(IN) :: X                 ! element X is in set A

 6       TYPE (SET), INTENT(IN) :: A

 7       ELEMENT = ANY (A % ELEMENT (1 : A % CARD) == X)

 8    END FUNCTION ELEMENT

 9

10    FUNCTION UNION (A, B)                        ! Union of sets A and B

11       TYPE (SET) UNION

12       TYPE (SET), INTENT(IN) :: A, B

13       INTEGER J

14       UNION = A

15       DO J = 1, B % CARD

16          IF (.NOT. (B % ELEMENT (J) .IN. A)) THEN

17             IF (UNION % CARD < MAX_SET_CARD) THEN

18                 UNION % CARD = UNION % CARD + 1

19                 UNION % ELEMENT (UNION % CARD) = &

20                       B % ELEMENT (J)

21             ELSE

22                 ! Maximum set size exceeded . . .

23             END IF

24          END IF

25       END DO

26    END FUNCTION UNION

27

28    FUNCTION DIFFERENCE (A, B)              ! Difference of sets A and B

29       TYPE (SET) DIFFERENCE

30       TYPE (SET), INTENT(IN) :: A, B

31       INTEGER J, X

32       DIFFERENCE % CARD = 0               ! The empty set

33       DO J = 1, A % CARD

34          X = A % ELEMENT (J)

35          IF (.NOT. (X .IN. B)) DIFFERENCE = DIFFERENCE + SET (1, X)

36       END DO

37    END FUNCTION DIFFERENCE

38

39    FUNCTION INTERSECTION (A, B)          ! Intersection of sets A and B

40       TYPE (SET) INTERSECTION

41       TYPE (SET), INTENT(IN) :: A, B

42       INTERSECTION = A - (A - B)

43    END FUNCTION INTERSECTION

44

45    LOGICAL FUNCTION SUBSET (A, B)             ! Determines if set A is




      SEP 2002                              WORKING DRAFT                            463


      J3/02-007R3                           WORKING DRAFT                          SEP 2002



 1       TYPE (SET), INTENT(IN) :: A, B           ! a subset of set B

 2       INTEGER I

 3       SUBSET = A % CARD <= B % CARD

 4       IF (.NOT. SUBSET) RETURN                 ! For efficiency

 5       DO I = 1, A % CARD

 6           SUBSET = SUBSET .AND. (A % ELEMENT (I) .IN. B)

 7       END DO

 8    END FUNCTION SUBSET

 9

10    TYPE (SET) FUNCTION SETF (V)         ! Transfer function between a vector

11       INTEGER V (:)                     ! of elements and a set of elements

12       INTEGER J                         ! removing duplicate elements

13       SETF % CARD = 0

14       DO J = 1, SIZE (V)

15           IF (.NOT. (V (J) .IN. SETF)) THEN

16              IF (SETF % CARD < MAX_SET_CARD) THEN

17                 SETF % CARD = SETF % CARD + 1

18                 SETF % ELEMENT (SETF % CARD) = V (J)

19              ELSE

20                 ! Maximum set size exceeded . . .

21              END IF

22           END IF

23       END DO

24    END FUNCTION SETF

25

26    FUNCTION VECTOR (A)                  ! Transfer the values of set A

27       TYPE (SET), INTENT (IN) :: A      ! into a vector in ascending order

28       INTEGER, POINTER :: VECTOR (:)

29       INTEGER I, J, K

30       ALLOCATE (VECTOR (A % CARD))

31       VECTOR = A % ELEMENT (1 : A % CARD)

32       DO I = 1, A % CARD - 1             ! Use a better sort if

33           DO J = I + 1, A % CARD        ! A % CARD is large

34              IF (VECTOR (I) > VECTOR (J)) THEN

35                 K = VECTOR (J); VECTOR (J) = VECTOR (I); VECTOR (I) = K

36              END IF

37           END DO

38       END DO

39    END FUNCTION VECTOR

40

41    END MODULE INTEGER_SETS



42    Examples of using INTEGER_SETS (A, B, and C are variables of type SET; X

43    is an integer variable):

44    ! Check to see if A has more than 10 elements



      464                              WORKING DRAFT                               SEP 2002


      SEP 2002                               WORKING DRAFT                                   J3/02-007R3



 1    IF (CARDINALITY (A) > 10) ...

 2

 3    ! Check for X an element of A but not of B

 4    IF (X .IN. (A - B)) ...

 5

 6    ! C is the union of A and the result of B intersected

 7    ! with the integers 1 to 100

 8    C = A + B * SETF ((/ (I, I = 1, 100) /))

 9

10    ! Does A have any even numbers in the range 1:100?

11    IF (CARDINALITY (A * SETF ((/ (I, I = 2, 100, 2) /))) > 0) ...

12

13    PRINT *, VECTOR (B) ! Print out the elements of set B, in ascending order



14    C.8.3.8     Public entities renamed

15    At times it may be necessary to rename entities that are accessed with USE statements. Care should be
16    taken if the referenced modules also contain USE statements.

17    The following example illustrates renaming features of the USE statement.



18    MODULE J; REAL JX, JY, JZ; END MODULE J

19    MODULE K

20       USE J, ONLY : KX => JX, KY => JY

21       ! KX and KY are local names to module K

22       REAL KZ           ! KZ is local name to module K

23       REAL JZ           ! JZ is local name to module K

24    END MODULE K

25    PROGRAM RENAME

26       USE J; USE K

27       ! Module J's entity JX is accessible under names JX and KX

28       ! Module J's entity JY is accessible under names JY and KY

29       ! Module K's entity KZ is accessible under name KZ

30       ! Module J's entity JZ and K's entity JZ are different entities

31       ! and shall not be referenced

32       ...

33    END PROGRAM RENAME



34    C.9        Section 12 notes

35    C.9.1       Portability problems with external procedures (12.3.2.2)

36    There is a potential portability problem in a scoping unit that references an external procedure without
37    explicitly declaring it to have the EXTERNAL attribute (5.1.2.6). On a different processor, the name
38    of that procedure may be the name of a nonstandard intrinsic procedure and the processor would
39    be permitted to interpret those procedure references as references to that intrinsic procedure. (On that



      SEP 2002                                   WORKING DRAFT                                           465


      J3/02-007R3                               WORKING DRAFT                                      SEP 2002



 1    processor, the program would also be viewed as not conforming to the standard because of the references
 2    to the nonstandard intrinsic procedure.) Declaration of the EXTERNAL attribute causes the references
 3    to be to the external procedure regardless of the availability of an intrinsic procedure with the same
 4    name. Note that declaration of the type of a procedure is not enough to make it external, even if the
 5    type is inconsistent with the type of the result of an intrinsic of the same name.


 6    C.9.2     Procedures defined by means other than Fortran (12.5.3)

 7    A processor is not required to provide any means other than Fortran for defining external procedures.
 8    Among the means that might be supported are the machine assembly language, other high level lan-
 9    guages, the Fortran language extended with nonstandard features, and the Fortran language as supported
10    by another Fortran processor (for example, a previously existing Fortran 77 processor).

11    Procedures defined by means other than Fortran are considered external procedures because their def-
12    initions are not in a Fortran program unit and because they are referenced using global names. The
13    use of the term external should not be construed as any kind of restriction on the way in which these
14    procedures may be defined. For example, if the means other than Fortran has its own facilities for
15    internal and external procedures, it is permissible to use them. If the means other than Fortran can
16    create an "internal" procedure with a global name, it is permissible for such an "internal" procedure
17    to be considered by Fortran to be an external procedure. The means other than Fortran for defining
18    external procedures, including any restrictions on the structure for organization of those procedures, are
19    entirely processor dependent.

20    A Fortran processor may limit its support of procedures defined by means other than Fortran such that
21    these procedures may affect entities in the Fortran environment only on the same basis as procedures
22    written in Fortran. For example, it might prohibit the value of a local variable from being changed by
23    a procedure reference unless that variable were one of the arguments to the procedure.


24    C.9.3     Procedure interfaces (12.3)

25    In Fortran 77, the interface to an external procedure was always deduced from the form of references
26    to that procedure and any declarations of the procedure name in the referencing program unit. In this
27    standard, features such as argument keywords and optional arguments make it impossible to deduce
28    sufficient information about the dummy arguments from the nature of the actual arguments to be
29    associated with them, and features such as array function results and pointer function results make
30    necessary extensions to the declaration of a procedure that cannot be done in a way that would be
31    analogous with the handling of such declarations in Fortran 77. Hence, mechanisms are provided
32    through which all the information about a procedure's interface may be made available in a scoping
33    unit that references it. A procedure whose interface shall be deduced as in Fortran 77 is described
34    as having an implicit interface. A procedure whose interface is fully known is described as having an
35    explicit interface.

36    A scoping unit is allowed to contain an interface body for a procedure that does not exist in the program,
37    provided the procedure described is never referenced or used in any other way. The purpose of this rule is
38    to allow implementations in which the use of a module providing interface bodies describing the interface
39    of every routine in a library would not automatically cause each of those library routines to be a part of
40    the program referencing the module. Instead, only those library procedures actually referenced would
41    be a part of the program. (In implementation terms, the mere presence of an interface body would not
42    generate an external reference in such an implementation.)


43    C.9.4     Argument association and evaluation (12.4.1.2)

44    There is a significant difference between the argument association allowed in this standard and that
45    supported by Fortran 77 and Fortran 66. In Fortran 77 and 66, actual arguments were limited



      466                                 WORKING DRAFT                                            SEP 2002


      SEP 2002                              WORKING DRAFT                                       J3/02-007R3



 1    to consecutive storage units. With the exception of assumed length character dummy arguments, the
 2    structure imposed on that sequence of storage units was always determined in the invoked procedure and
 3    not taken from the actual argument. Thus it was possible to implement Fortran 66 and Fortran 77
 4    argument association by supplying only the location of the first storage unit (except for character argu-
 5    ments, where the length would also have to be supplied). However, this standard allows arguments that
 6    do not reside in consecutive storage locations (for example, an array section), and dummy arguments that
 7    assume additional structural information from the actual argument (for example, assumed-shape dummy
 8    arguments). Thus, the mechanism to implement the argument association allowed in this standard needs
 9    to be more general.

10    Because there are practical advantages to a processor that can support references to and from pro-
11    cedures defined by a Fortran 77 processor, requirements for explicit interfaces make it possible to
12    determine whether a simple (Fortran 66/Fortran 77) argument association implementation mecha-
13    nism is sufficient or whether the more general mechanism is necessary (12.3.1.1). Thus a processor can
14    be implemented whose procedures expect the simple mechanism to be used whenever the procedure's
15    interface is one that uses only Fortran 77 features and that expects the more general mechanism
16    otherwise (for example, if there are assumed-shape or optional arguments). At the point of reference,
17    the appropriate mechanism can be determined from the interface if it is explicit and can be assumed to
18    be the simple mechanism if it is not. Note that if the simple mechanism is determined to be what the
19    procedure expects, it may be necessary for the processor to allocate consecutive temporary storage for
20    the actual argument, copy the actual argument to the temporary storage, reference the procedure using
21    the temporary storage in place of the actual argument, copy the contents of temporary storage back to
22    the actual argument, and deallocate the temporary storage.

23    While this is the particular implementation method these rules were designed to support, it is not
24    the only one possible. For example, on some processors, it may be possible to implement the general
25    argument association in such a way that the information involved in Fortran 77 argument association
26    may be found in the same places and the "extra" information is placed so it does not disturb a procedure
27    expecting only Fortran 77 argument association. With such an implementation, argument association
28    could be translated without regard to whether the interface is explicit or implicit.

29    The provisions for expression evaluation give the processor considerable flexibility for obtaining expres-
30    sion values in the most efficient way possible. This includes not evaluating or only partially evaluating
31    an operand, for example, if the value of the expression can be determined otherwise (7.1.8.1). This
32    flexibility applies to function argument evaluation, including the order of argument evaluation, delay-
33    ing argument evaluation, and omitting argument evaluation. A processor may delay the evaluation of
34    an argument in a procedure reference until the execution of the procedure refers to the value of that
35    argument, provided delaying the evaluation of the argument does not otherwise affect the results of
36    the program. The processor may, with similar restrictions, entirely omit the evaluation of an argument
37    not referenced in the execution of the procedure. This gives processors latitude for optimization (for
38    example, for parallel processing).


39    C.9.5     Pointers and targets as arguments (12.4.1.2)

40    If a dummy argument is declared to be a pointer, it may be matched only by an actual argument that
41    also is a pointer, and the characteristics of both arguments shall agree. A model for such an association is
42    that descriptor values of the actual pointer are copied to the dummy pointer. If the actual pointer has an
43    associated target, this target becomes accessible via the dummy pointer. If the dummy pointer becomes
44    associated with a different target during execution of the procedure, this target will be accessible via the
45    actual pointer after the procedure completes execution. If the dummy pointer becomes associated with
46    a local target that ceases to exist when the procedure completes, the actual pointer will be left dangling
47    in an undefined state. Such dangling pointers shall not be used.

48    When execution of a procedure completes, any pointer that remains defined and that is associated with
49    a dummy argument that has the TARGET attribute and is either a scalar or an assumed-shape array,



      SEP 2002                                     WORKING DRAFT                                             467


      J3/02-007R3                               WORKING DRAFT                                 SEP 2002



 1    remains associated with the corresponding actual argument if the actual argument has the TARGET
 2    attribute and is not an array section with a vector subscript.



 3    REAL, POINTER           :: PBEST

 4    REAL, TARGET            :: B (10000)

 5    CALL BEST (PBEST, B)                    ! Upon return PBEST is associated

 6       ...                                  ! with the ``best'' element of B

 7    CONTAINS

 8      SUBROUTINE BEST (P, A)

 9           REAL, POINTER, INTENT (OUT)       :: P

10           REAL, TARGET, INTENT (IN)         :: A (:)

11              ...                           ! Find the ``best'' element A(I)

12           P => A (I)

13      RETURN

14      END SUBROUTINE BEST

15    END



16    When procedure BEST completes, the pointer PBEST is associated with an element of B.

17    An actual argument without the TARGET attribute can become associated with a dummy argument
18    with the TARGET attribute. This permits pointers to become associated with the dummy argument
19    during execution of the procedure that contains the dummy argument. For example:



20    INTEGER LARGE(100,100)

21    CALL SUB (LARGE)

22       ...

23    CALL SUB ()

24    CONTAINS

25      SUBROUTINE SUB(ARG)

26           INTEGER, TARGET, OPTIONAL :: ARG(100,100)

27           INTEGER, POINTER, DIMENSION(:,:) :: PARG

28           IF (PRESENT(ARG)) THEN

29             PARG => ARG

30           ELSE

31             ALLOCATE (PARG(100,100))

32             PARG = 0

33           ENDIF

34              ...    ! Code with lots of references to PARG

35           IF (.NOT. PRESENT(ARG)) DEALLOCATE(PARG)

36      END SUBROUTINE SUB

37    END



38    Within subroutine SUB the pointer PARG is either associated with the dummy argument ARG or it is
39    associated with an allocated target. The bulk of the code can reference PARG without further calls to
40    the PRESENT intrinsic.




      468                                 WORKING DRAFT                                       SEP 2002


      SEP 2002                             WORKING DRAFT                                    J3/02-007R3


 1    C.9.6    Polymorphic Argument Association (12.4.1.3)

 2    The following example illustrates polymorphic argument association rules using the derived types defined
 3    in Note 4.49.



 4      TYPE(POINT) :: T2

 5      TYPE(COLOR_POINT) :: T3

 6      CLASS(POINT) :: P2

 7      CLASS(COLOR_POINT) :: P3

 8      ! Dummy argument is polymorphic and actual argument is of fixed type

 9      SUBROUTINE SUB2 ( X2 ); CLASS(POINT) :: X2; ...

10      SUBROUTINE SUB3 ( X3 ); CLASS(COLOR_POINT) :: X3; ...

11

12      CALL SUB2 ( T2 ) ! Valid -- The declared type of T2 is the same as the

13                          !            declared type of X2.

14      CALL SUB2 ( T3 ) ! Valid -- The declared type of T3 is extended from

15                          !            the declared type of X2.

16      CALL SUB3 ( T2 ) ! Invalid -- The declared type of T2 is neither the

17                          !            same as nor extended from the declared type

18                          !            type of X3.

19      CALL SUB3 ( T3 ) ! Valid -- The declared type of T3 is the same as the

20                          !            declared type of X3.

21      ! Actual argument is polymorphic and dummy argument is of fixed type

22      SUBROUTINE TUB2 ( D2 ); TYPE(POINT) :: D2; ...

23      SUBROUTINE TUB3 ( D3 ); TYPE(COLOR_POINT) :: D3 .;..

24

25      CALL TUB2 ( P2 ) ! Valid -- The declared type of P2 is the same as the

26                          !            declared type of D2.

27      CALL TUB2 ( P3 ) ! Valid -- The declared type of P3 is extended from

28                          !            the declared type of D2.

29      CALL TUB3 ( P2 ) ! is valid only if the dynamic type of P2 is the same

30                          !            as the declared type of D2, or a type

31                          !            extended therefrom.

32      CALL TUB3 ( P3 ) ! Valid -- The declared type of P3 is the same as the

33                          !            declared type of D3.

34      ! Both the actual and dummy arguments are of polymorphic type.

35      CALL SUB2 ( P2 ) ! Valid -- The declared type of P2 is the same as the

36                          !            declared type of X2.

37      CALL SUB2 ( P3 ) ! Valid -- The declared type of P3 is extended from

38                          !            the declared type of X2.

39      CALL SUB3 ( P2 ) ! is valid only if the dynamic type of P2 is the same

40                          !            as the declared type of X2, or a type

41                          !            extended therefrom.

42      CALL SUB3 ( P3 ) ! Valid -- The declared type of P3 is the same as the

43                          !            declared type of X3.




      SEP 2002                                   WORKING DRAFT                                          469


      J3/02-007R3                                     WORKING DRAFT                                  SEP 2002


 1    C.9.7           Generic resolution and dynamic dispatch (12.4.4)

 2    A type-bound generic interface consists of a family of generic interfaces, one per type in the inheritance
 3    hierarchy. A declaration of an extensible type may override specific procedures in the generic interfaces
 4    inherited from its parent type, add new specific procedures, or add new type-bound generic interfaces.

 5    When a procedure is invoked by way of a type-bound generic interface, one of the specific procedures of
 6    the generic interface bound to the declared type of the invoking object (or the dtv argument in the case
 7    of user-defined derived-type input/output) is selected according to the usual rules for generic resolution
 8    (12.4.4.1).

 9    Once a specific procedure is selected for the declared type, the corresponding (4.5.3.2) procedure for the
10    dynamic type is invoked. For polymorphic objects, it is expected that the former process is performed
11    when the program is translated, and the latter occurs during program execution. For nonpolymorphic
12    objects, the dynamic and declared types are the same, so the selection is completed during translation.

13    One possible method to support the polymorphic case is for the processor to construct a dispatch table
14    for each type. The elements in the dispatch table are effectively procedure pointers. Either the specific
15    name of a nongeneric binding or the generic identifier and the combination of characteristics used for
16    generic resolution chooses a slot in the dispatch table.

17    During execution, the dynamic type of the object through which the procedure is invoked is used to
18    select which dispatch table to use. One is assured that the slot selected in the first step exists in the
19    dispatch table selected during execution because type extension can only add slots, it cannot delete
20    them.



21    C.10            Section 15 notes

22    C.10.1           Runtime environments

23    This standard allows programs to contain procedures defined by means other than Fortran. That raises
24    the issues of initialization of and interaction between the runtime environments involved.

25    Implementations are free to solve these issues as they see fit, provided that:

26             (1)      Heap allocation/deallocation (e.g., (DE)ALLOCATE in a Fortran subprogram and mal-
27                      loc/free in a C function) can be performed without interference.

28             (2)      I/O to and from external files can be performed without interference, as long as procedures
29                      defined by different means do not do I/O to/from the same external file.

30             (3)      I/O preconnections exist as required by the respective standards.

31             (4)      Initialized data is initialized according to the respective standards.

32             (5)      The command line environment intrinsic routines GET COMMAND, GET COMMAND -
33                      ARGUMENT, COMMAND ARGUMENT COUNT and GET ENVIRONMENT VARIA-
34                      BLE function correctly, even if the main program is defined by means other than Fortran.


35    C.10.2           Examples of Interoperation between Fortran and C Functions

36    The following examples illustrate the interoperation of Fortran and C functions. Two examples are
37    shown: one of Fortran calling C, and one of C calling Fortran. In each of the examples, the correspon-
38    dences of Fortran actual arguments, Fortran dummy arguments, and C formal parameters are described.


39    C.10.2.1         Example of Fortran calling C

40    C Function Prototype:



      470                                      WORKING DRAFT                                         SEP 2002


      SEP 2002                              WORKING DRAFT                                 J3/02-007R3



 1              int C_Library_Function(void* sendbuf, int sendcount, My_Own_Datatype}

 2                           sendtype, int *recvcounts)



 3    Fortran Modules:



 4              MODULE FTN_C_1

 5                  USE, INTRINSIC :: ISO_C_BINDING

 6                  TYPEALIAS ::       MY_OWN_DATATYPE => INTEGER(C_INT)

 7              END MODULE FTN_C_1

 8

 9              MODULE FTN_C_2

10                  INTERFACE

11                        INTEGER (C_INT) FUNCTION C_LIBRARY_FUNCTION &

12                        (SENDBUF, SENDCOUNT, SENDTYPE, RECVCOUNTS),         &

13                        BIND(C, NAME='C_Library_Function')

14                           USE FTN_C_1

15                           IMPLICIT NONE

16                           TYPE (C_PTR), VALUE :: SENDBUF

17                           INTEGER (C_INT), VALUE :: SENDCOUNT

18                           TYPE (MY_OWN_DATATYPE), VALUE :: SENDTYPE

19                           TYPE (C_PTR), VALUE :: RECVCOUNTS

20                        END FUNCTION C_LIBRARY_FUNCTION

21                  END INTERFACE

22              END MODULE FTN_C_2



23    The module FTN C 2 contains the declaration of the Fortran dummy arguments, which correspond to
24    the C formal parameters. The intrinsic module ISO C BINDING is referenced in the module FTN C 1.
25    The NAME specifier is used in the BIND attribute in order to handle the case-sensitive name change
26    between Fortran and C from 'C LIBRARY FUNCTION' to 'C Library Function'. See also Note 12.39.

27    The first C formal parameter is the pointer to void sendbuf, which corresponds to the Fortran dummy
28    argument SENDBUF, which has the type C PTR and the VALUE attribute.

29    The second C formal parameter is the int sendcount, which corresponds to the Fortran dummy argument
30    SENDCOUNT, which has the type INTEGER(C INT) and the VALUE attribute.

31    The third C formal parameter is sendtype, which has the type My Own Datatype defined by C's typedef
32    facility. The TYPEALIAS statement is specified in Fortran in order to define a corresponding type alias
33    name. The C formal parameter sendtype corresponds to the Fortran dummy argument SENDTYPE of
34    type MY OWN DATATYPE.

35    The fourth C formal parameter is the pointer to int recvcounts, which corresponds to the Fortran
36    dummy argument RECVCOUNTS, which has the type C PTR and the VALUE attribute.

37    Fortran Calling Sequence:



38              USE, INTRINSIC :: ISO_C_BINDING, ONLY: C_INT, C_FLOAT, C_LOC

39              USE FTN_C_2

40              ...



      SEP 2002                                  WORKING DRAFT                                         471


      J3/02-007R3                             WORKING DRAFT                                    SEP 2002



 1                REAL (C_FLOAT), TARGET     :: SEND(100)

 2                INTEGER (C_INT)            :: SENDCOUNT

 3                TYPE (MY_OWN_DATATYPE)     :: SENDTYPE

 4                INTEGER (C_INT), ALLOCATABLE, TARGET :: RECVCOUNTS(100)

 5                ...

 6                ALLOCATE( RECVCOUNTS(100) )

 7                ...

 8                CALL C_LIBRARY_FUNCTION(C_LOC(SEND), SENDCOUNT, SENDTYPE, &

 9                C_LOC(RECVCOUNTS))

10                ...


11    The preceding code contains the declaration of the Fortran actual arguments associated with the above-
12    listed Fortran dummy arguments.

13    The first Fortran actual argument is the address of the first element of the array SEND, which has the
14    type REAL(C FLOAT) and the TARGET attribute. This address is returned by the intrinsic function
15    C LOC. This actual argument is associated with the Fortran dummy argument SENDBUF, which has
16    the type C PTR and the VALUE attribute.

17    The second Fortran actual argument is SENDCOUNT of type INTEGER(C INT), which is associated
18    with the Fortran dummy argument SENDCOUNT, which has the type INTEGER(C INT) and the
19    VALUE attribute.

20    The third Fortran actual argument is SENDTYPE of type MY OWN DATATYPE, which is associated
21    with the Fortran dummy argument SENDTYPE, which has the type MY OWN DATATYPE and the
22    VALUE attribute.

23    The fourth Fortran actual argument is the address of the first element of the allocatable array RECV-
24    COUNTS, with has the type REAL(C FLOAT) and the TARGET attribute. This address is returned
25    by the intrinsic function C LOC. This actual argument is associated with the Fortran dummy argument
26    RECVCOUNTS, which has the type C PTR and the VALUE attribute.


27    C.10.2.2    Example of C calling Fortran

28    Fortran Code:


29    SUBROUTINE SIMULATION(ALPHA, BETA, GAMMA, DELTA, ARRAYS), BIND(C)

30       USE, INTRINSIC :: ISO_C_BINDING

31       IMPLICIT NONE

32       INTEGER (C_LONG), VALUE                        :: ALPHA

33       REAL (C_DOUBLE), INTENT(INOUT)                 :: BETA

34       INTEGER (C_LONG), INTENT(OUT)                  :: GAMMA

35       REAL (C_DOUBLE),DIMENSION(*),INTENT(IN) :: DELTA

36       TYPE, BIND(C) :: PASS

37           INTEGER (C_INT) :: LENC, LENF

38           TYPE (C_PTR)      :: C, F

39       END TYPE PASS

40       TYPE (PASS), INTENT(INOUT) :: ARRAYS

41       REAL (C_FLOAT), ALLOCATABLE, TARGET, SAVE :: ETA(:)

42       REAL (C_FLOAT), POINTER :: C_ARRAY(:)



      472                                 WORKING DRAFT                                        SEP 2002


      SEP 2002                            WORKING DRAFT                                    J3/02-007R3



 1       ...

 2       ! Associate C_ARRAY with an array allocated in C

 3       CALL C_F_POINTER (ARRAYS%C, C_ARRAY, (/ARRAYS%LENC/) )

 4       ...

 5       ! Allocate an array and make it available in C

 6       ARRAYS%LENF = 100

 7       ALLOCATE (ETA(ARRAYS%LENF))

 8       ARRAYS%F = C_LOC(ETA)

 9       ...

10    END SUBROUTINE SIMULATION


11    C Struct Declaration



12          struct pass {int lenc, lenf; float* f, c}


13    C Function Prototype:



14          void *simulation(long alpha, double *beta, long *gamma,

15                 double delta[], pass *arrays)


16    C Calling Sequence:

17                   simulation(alpha, &beta, &gamma, delta, &arrays);

18    The above-listed Fortran code specifies a subroutine with the name SIMULATION. This subroutine
19    corresponds to the C function with the name simulation, which returns a pointer to void.

20    The Fortran subroutine references the intrinsic module ISO C BINDING.

21    The first Fortran dummy argument of the subroutine is ALPHA, which has the type INTEGER(C -
22    LONG) and the attribute VALUE. This dummy argument corresponds to the C formal parameter
23    alpha, which is a long. The actual C parameter is also a long.

24    The second Fortran dummy argument of the subroutine is BETA, which has the type REAL(C -
25    DOUBLE) and the INTENT(INOUT) attribute. This dummy argument corresponds to the C formal
26    parameter beta, which is a pointer to double. An address is passed as the actual parameter in the C
27    calling sequence.

28    The third Fortran dummy argument of the subroutine is GAMMA, which has the type INTEGER(C -
29    LONG) and the INTENT(OUT) attribute. This dummy argument corresponds to the C formal param-
30    eter gamma, which is a pointer to long. An address is passed as the actual parameter in the C calling
31    sequence.

32    The fourth Fortran dummy argument is the assumed-size array DELTA, which has the type REAL
33    (C DOUBLE) and the attribute INTENT(IN). This dummy argument corresponds to the C formal
34    parameter delta, which is a double array. The actual C parameter is also a double array.

35    The fifth Fortran dummy argument is ARRAYS, which is a structure for accessing an array allocated
36    in C and an array allocated in Fortran. The lengths of these arrays are held in the components LENC
37    and LENF; their C addresses are help in components C and F.





      SEP 2002                                  WORKING DRAFT                                         473


      J3/02-007R3                                 WORKING DRAFT                             SEP 2002



 1    C.10.2.3     Example of calling C functions with non-interoperable data

 2    Many Fortran processors support 16-byte real numbers, not supported by the C processor. Assume a
 3    Fortran programmer wants to use a C procedure from a message passing library for an array of these
 4    reals. The C prototype of this procedure is



 5    void ProcessBuffer(void *buffer, int n_bytes);


 6    with the corresponding Fortran interface



 7    USE, INTRINSIC :: ISO_C_BINDING

 8

 9    INTERFACE

10       SUBROUTINE PROCESS_BUFFER(BUFFER,N_BYTES), BIND(C,NAME="ProcessBuffer")

11           IMPORT :: C_PTR, C_INT

12           TYPE(C_PTR), VALUE :: BUFFER ! The ``C address'' of the array buffer

13           INTEGER(C_INT), VALUE :: N_BYTES ! Number of bytes in buffer

14       END SUBROUTINE PROCESS_BUFFER

15    END INTERFACE


16    This may be done using C LOC if the particular Fortran processor specifies that C LOC returns an
17    appropriate address:



18    REAL(R_QUAD), DIMENSION(:), ALLOCATABLE, TARGET :: QUAD_ARRAY

19    ...

20    CALL PROCESS_BUFFER(C_LOC(QUAD_ARRAY), INT(16*SIZE(QUAD_ARRAY),C_INT))

21       ! One quad real takes 16 bytes on this processor



22    C.10.2.4     Example of opaque communication between C and Fortran

23    The following example demonstrates how a Fortran processor can make a modern OO random number
24    generator written in Fortran available to a C program:



25    USE, INTRINSIC :: ISO_C_BINDING

26       ! Assume this code is inside a module

27

28    TYPE, EXTENSIBLE :: RANDOM_STREAM

29       ! A (uniform) random number generator (URNG)

30    CONTAINS

31       PROCEDURE(RANDOM_UNIFORM), PASS(STREAM) :: NEXT=>NULL()

32       ! Generates the next number from the stream

33    END TYPE RANDOM_STREAM

34

35    ABSTRACT INTERFACE

36       ! Abstract interface of Fortran URNG

37       FUNCTION RANDOM_UNIFORM(STREAM) RESULT(NUMBER)



      474                                WORKING DRAFT                                      SEP 2002


      SEP 2002                           WORKING DRAFT                                 J3/02-007R3



 1          IMPORT :: RANDOM_STREAM, C_DOUBLE

 2          CLASS(RANDOM_STREAM), INTENT(INOUT) :: STREAM

 3          REAL(C_DOUBLE) :: NUMBER

 4       END FUNCTION RANDOM_UNIFORM

 5    END INTERFACE


 6    A polymorphic object of base type RANDOM STREAM is not interoperable with C. However, we can
 7    make such a random number generator available to C by packaging it inside another nonpolymorphic,
 8    nonparameterized derived type:



 9    TYPE :: URNG_STATE ! No BIND(C), as this type is not interoperable

10       CLASS(RANDOM_STREAM), ALLOCATABLE :: STREAM

11    END TYPE URNG_STATE


12    The following two procedures will enable a C program to use our Fortran URNG:



13    ! Initialize a uniform random number generator:

14    SUBROUTINE INITIALIZE_URNG(STATE_HANDLE, METHOD), &

15                     BIND(C, NAME="InitializeURNG")

16        TYPE(C_PTR), INTENT(OUT) :: STATE_HANDLE

17          ! An opaque handle for the URNG

18        CHARACTER(C_CHAR), DIMENSION(*), INTENT(IN) :: METHOD

19          ! The algorithm to be used

20

21        TYPE(URNG_STATE), POINTER :: STATE

22          ! An actual URNG object

23

24        ALLOCATE(STATE)

25          ! There needs to be a corresponding finalization

26          ! procedure to avoid memory leaks, not shown in this example

27        ! Allocate STATE%STREAM with a dynamic type depending on METHOD

28        ...

29        STATE_HANDLE=C_LOC(STATE)

30          ! Obtain an opaque handle to return to C

31    END SUBROUTINE INITIALIZE_URNG

32

33    ! Generate a random number:

34    FUNCTION GENERATE_UNIFORM(STATE_HANDLE) RESULT(NUMBER), &

35                 BIND(C, NAME="GenerateUniform")

36        TYPE(C_PTR), INTENT(IN), VALUE :: STATE_HANDLE

37          ! An opaque handle: Obtained via a call to INITIALIZE_URNG

38        REAL(C_DOUBLE) :: NUMBER

39

40        TYPE(URNG_STATE), POINTER :: STATE

41          ! A pointer to the actual URNG




      SEP 2002                                WORKING DRAFT                                       475


      J3/02-007R3                              WORKING DRAFT                                     SEP 2002



 1

 2           CALL C_F_POINTER(CPTR=STATE_HANDLE, FPTR=STATE)

 3              ! Convert the opaque handle into a usable pointer

 4           NUMBER=STATE%STREAM%NEXT()

 5              ! Use the type-bound function NEXT to generate NUMBER

 6    END FUNCTION GENERATE_UNIFORM



 7    C.11        Section 16 notes

 8    C.11.1         Examples of host association (16.4.1.3)

 9    The first two examples are examples of valid host association. The third example is an example of invalid
10    host association.

11    Example 1:


12    PROGRAM A

13       INTEGER I, J

14       ...

15    CONTAINS

16       SUBROUTINE B

17            INTEGER I     ! Declaration of I hides

18                          ! program A's declaration of I

19                ...

20            I = J         ! Use of variable J from program A

21                          ! through host association

22       END SUBROUTINE B

23    END PROGRAM A


24    Example 2:


25    PROGRAM A

26       TYPE T

27            ...

28       END TYPE T

29       ...

30    CONTAINS

31       SUBROUTINE B

32            IMPLICIT TYPE (T) (C)      ! Refers to type T declared below

33                                       ! in subroutine B, not type T

34                                       ! declared above in program A

35                ...

36            TYPE T

37                ...

38            END TYPE T

39                ...



      476                                WORKING DRAFT                                           SEP 2002


      SEP 2002                               WORKING DRAFT                                       J3/02-007R3



 1       END SUBROUTINE B

 2    END PROGRAM A


 3    Example 3:



 4    PROGRAM Q

 5       REAL (KIND = 1) :: C

 6           ...

 7    CONTAINS

 8       SUBROUTINE R

 9           REAL (KIND = KIND (C)) :: D            ! Invalid declaration

10                                                  ! See below

11           REAL (KIND = 2) :: C

12                ...

13       END SUBROUTINE R

14    END PROGRAM Q


15    In the declaration of D in subroutine R, the use of C would refer to the declaration of C in subroutine
16    R, not program Q. However, it is invalid because the declaration of C shall occur before it is used in the
17    declaration of D (7.1.7).


18    C.11.2        Rules ensuring unambiguous generics (16.2.3)

19    The rules in 16.2.3 are intended to ensure


20       � that it is possible to reference each specific procedure in the generic collection,

21       � that for any valid reference to the generic procedure, the determination of the specific procedure
22         referenced is unambiguous, and

23       � that the determination of the specific procedure referenced can be made before execution of the
24         program begins (during compilation).


25    Specific procedures are distinguished by fixed properties of their arguments, specifically type, kind type
26    parameters, and rank. A valid reference to one procedure in a generic collection will differ from another
27    because it has an argument that the other cannot accept, because it is missing an argument that the
28    other requires, or because one of these fixed properties is different.

29    Although the declared type of a data entity is a fixed property, extensible types allow for a limited degree
30    of type mismatch between dummy arguments and actual arguments, so the requirement for distinguishing
31    two dummy arguments is type incompatibility, not merely different types. (This is illustrated in the BAD6
32    example later in this note.)

33    That same limited type mismatch means that two dummy arguments that are not type incompatible
34    can be distinguished on the basis of the values of the kind type parameters they have in common; if one
35    of them has a kind type parameter that the other does not, that is irrelevant in distinguishing them.

36    Rank is a fixed property, but some forms of array dummy arguments allow rank mismatches when a
37    procedure is referenced by its specific name. In order to allow rank to always be usable in distinguishing
38    generics, such rank mismatches are disallowed for those arguments when the procedure is referenced as
39    part of a generic. Additionally, the fact that elemental procedures can accept array arguments is not



      SEP 2002                                      WORKING DRAFT                                           477


      J3/02-007R3                                WORKING DRAFT                                       SEP 2002



 1    taken into account when applying these rules, so apparent ambiguity between elemental and nonelemental
 2    procedures is possible; in such cases, the reference is interpreted as being to the nonelemental procedure.

 3    The concept of TKR incompatibility encapsulates the rules for distinguishing dummy arguments on the
 4    basis of any of these properties.

 5    For procedures referenced as operators or defined-assignment, syntactically distinguished arguments are
 6    mapped to specific positions in the argument list, so the rule for distinguishing such procedures is that
 7    it be possible to distinguish the arguments at one of the argument positions.

 8    For user-defined derived-type input/output procedures, only the dtv argument corresponds to something
 9    explicitly written in the program, so it is the dtv that is required to be distinguished. Since dtv arguments
10    are required to be scalar, they cannot differ in rank. Thus, in this rule, TKR incompatibility effectively
11    involves only type and kind type parameters.

12    For generic procedures identified by names, the rules are more complicated because optional arguments
13    may be omitted and because arguments may be specified either positionally or by name.

14    In the special case of type-bound procedures with passed-object dummy arguments, the passed-object
15    argument is syntactically distinguished in the reference, so rule (2) can be applied. The type of passed-
16    object arguments is constrained in ways that prevent passed-object arguments in the same scoping unit
17    from being type incompatible. Thus, in this rule, TKR incompatibility effectively involves only kind
18    type parameters and rank.

19    The primary means of distinguishing named generics is rule (3). The most common application of that
20    rule is a single argument satisfying both (3a) and (3b):


21               INTERFACE GOOD1

22                 FUNCTION F1A(X)

23                    REAL :: F1A,X

24                 END FUNCTION F1A

25                 FUNCTION F1B(X)

26                    INTEGER :: F1B,X

27                 END FUNCTION F1B

28               END INTERFACE GOOD1


29    Whether one writes GOOD1(1.0) or GOOD1(X=1.0), the reference is to F1A because F1B would require an
30    integer argument whereas these references provide the real constant 1.0.

31    This example and those that follow are expressed using interface bodies, with type as the distinguishing
32    property. This was done to make it easier to write and describe the examples. The principles being
33    illustrated are equally applicable when the procedures get their explicit interfaces in some other way or
34    when kind type parameters or rank are the distinguishing property.

35    Another common variant is the argument that satisfies (3a) and (3b) by being required in one specific
36    and completely missing in the other:


37               INTERFACE GOOD2

38                 FUNCTION F2A(X)

39                    REAL :: F2A,X

40                 END FUNCTION F2A

41                 FUNCTION F2B(X,Y)

42                    COMPLEX :: F2B



      478                                  WORKING DRAFT                                             SEP 2002


      SEP 2002                              WORKING DRAFT                                  J3/02-007R3



 1                    REAL :: X,Y

 2                 END FUNCTION F2B

 3               END INTERFACE GOOD2


 4    Whether one writes GOOD2(0.0,1.0), GOOD2(0.0,Y=1.0), or GOOD2(Y=1.0,X=0.0), the reference is to
 5    F2B, because F2A has no argument in the second position or with the name Y. This approach is used as
 6    an alternative to optional arguments when one wants a function to have different result TKR depending
 7    on whether the argument is present. In many of the intrinsic functions, the DIM argument works this
 8    way.

 9    It is possible to construct cases where different arguments are used to distinguish positionally and by
10    name:



11               INTERFACE GOOD3

12                 SUBROUTINE S3A(W,X,Y,Z)

13                    REAL :: W,Y

14                    INTEGER :: X,Z

15                 END SUBROUTINE S3A

16                 SUBROUTINE S3B(X,W,Z,Y)

17                    REAL :: W,Z

18                    INTEGER :: X,Y

19                 END SUBROUTINE S3B

20               END INTERFACE GOOD3


21    If one writes GOOD3(1.0,2,3.0,4) to reference S3A, then the third and fourth arguments are consistent
22    with a reference to S3B, but the first and second are not. If one switches to writing the first two
23    arguments as keyword arguments in order for them to be consistent with a reference to S3B, the latter
24    two arguments must also be written as keyword arguments, GOOD3(X=2,W= 1.0,Z=4,Y=3.0), and the
25    named arguments Y and Z are distinguished.

26    The ordering requirement in rule (3) is critical:



27               INTERFACE BAD4      ! this interface is invalid !

28                 SUBROUTINE S4A(W,X,Y,Z)

29                    REAL :: W,Y

30                    INTEGER :: X,Z

31                 END SUBROUTINE S4A

32                 SUBROUTINE S4B(X,W,Z,Y)

33                    REAL :: X,Y

34                    INTEGER :: W,Z

35                 END SUBROUTINE S4B

36               END INTERFACE BAD4


37    In this example, the positionally distinguished arguments are Y and Z, and it is W and X that are
38    distinguished by name. In this order it is possible to write BAD4(1.0,2,Y=3.0,Z=4), which is a valid
39    reference for both S4A and S4B.

40    Rule (1) can be used to distinguish some cases that are not covered by rule (3):




      SEP 2002                                    WORKING DRAFT                                        479


      J3/02-007R3                               WORKING DRAFT                                      SEP 2002



 1               INTERFACE GOOD5

 2                 SUBROUTINE S5A(X)

 3                    REAL :: X

 4                 END SUBROUTINE S5A

 5                 SUBROUTINE S5B(Y,X)

 6                    REAL :: Y,X

 7                 END SUBROUTINE S5B

 8               END INTERFACE GOOD5


 9    In attempting to apply rule (3), position 2 and name Y are distinguished, but they are in the wrong
10    order, just like the BAD4 example. However, when we try to construct a similarly ambiguous reference,
11    we get GOOD5(1.0,X=2.0), which can't be a reference to S5A because it would be attempting to associate
12    two different actual arguments with the dummy argument X. Rule (3) catches this case by recognizing
13    that S5B requires two real arguments, and S5A cannot possibly accept more than one.

14    The application of rule (1) becomes more complicated when extensible types are involved. If FRUIT is
15    an extensible type, PEAR and APPLE are extensions of FRUIT, and BOSC is an extension of PEAR, then


16               INTERFACE BAD6      ! this interface is invalid !

17                 SUBROUTINE S6A(X,Y)

18                    TYPE(PEAR) :: X,Y

19                 END SUBROUTINE S6A

20                 SUBROUTINE S6B(X,Y)

21                    TYPE(FRUIT) :: X

22                    TYPE(BOSC) :: Y

23                 END SUBROUTINE S6B

24               END INTERFACE BAD6


25    might, at first glance, seem distinguishable this way, but because of the limited type mismatching allowed,
26    BAD6(A PEAR,A BOSC) is a valid reference to both S6A and S6B.

27    It is important to try rule (1) for each type present:



28               INTERFACE GOOD7

29                 SUBROUTINE S7A(X,Y,Z)

30                    TYPE(PEAR) :: X,Y,Z

31                 END SUBROUTINE S7A

32                 SUBROUTINE S7B(X,Z,W)

33                    TYPE(FRUIT) :: X

34                    TYPE(BOSC) :: Z

35                    TYPE(APPLE),OPTIONAL :: W

36                 END SUBROUTINE S7B

37               END INTERFACE GOOD7


38    Looking at the most general type, S7A has a minimum and maximum of 3 FRUIT arguments, while S7B
39    has a minimum of 2 and a maximum of three. Looking at the most specific, S7A has a minimum of 0
40    and a maximum of 3 BOSC arguments, while S7B has a minimum of 1 and a maximum of 2. However,
41    when we look at the intermediate, S7A has a minimum and maximum of 3 PEAR arguments, while S7B



      480                                 WORKING DRAFT                                            SEP 2002


      SEP 2002                               WORKING DRAFT                                     J3/02-007R3



 1    has a minimum of 1 and a maximum of 2. Because S7A's minimum exceeds S7B's maximum, they can
 2    be distinguished.

 3    In identifying the minimum number of arguments with a particular set of TKR properties, we exclude
 4    optional arguments and test TKR compatibility, so the corresponding actual arguments are required
 5    to have those properties. In identifying the maximum number of arguments with those properties, we
 6    include the optional arguments and test not TKR incompatible (i.e., TKR compatible in either direction),
 7    so we include actual arguments which could have those properties but are not required to have them.

 8    These rules are sufficient to ensure that procedures that meet them are distinguishable, but there remain
 9    examples that fail to meet these rules but which can be shown to be unambiguous:


10               INTERFACE BAD8       ! this interface is invalid !

11               ! despite the fact that it is unambiguous !

12                 SUBROUTINE S8A(X,Y,Z)

13                    REAL,OPTIONAL :: X

14                    INTEGER :: Y

15                    REAL :: Z

16                 END SUBROUTINE S8A

17                 SUBROUTINE S8B(X,Z,Y)

18                    INTEGER,OPTIONAL :: X

19                    INTEGER :: Z

20                    REAL :: Y

21                 END SUBROUTINE S8B

22               END INTERFACE BAD8


23    This interface fails rule (3) because there are no required arguments that can be distinguished from the
24    positionally corresponding argument, but in order for the mismatch of the optional arguments not to
25    be relevant, the later arguments must be specified as keyword arguments, so distinguishing by name
26    does the trick. This interface is nevertheless invalid so a standard- conforming Fortran processor is not
27    required to do such reasoning. The rules to cover all cases are too complicated to be useful.

28    In addition to not recognizing distinguishable patterns like the one in BAD8, the rules do not distinguish
29    on the basis of any properties other than type, kind type parameters, and rank:


30               INTERFACE BAD9       ! this interface is invalid !

31               ! despite the fact that it is unambiguous !

32                 SUBROUTINE S9A(X)

33                    REAL :: X

34                 END SUBROUTINE S9A

35                 SUBROUTINE S9B(X)

36                    INTERFACE

37                         FUNCTION X(A)

38                          REAL :: X,A

39                         END FUNCTION X

40                    END INTERFACE

41                 END SUBROUTINE S9B

42                 SUBROUTINE S9C(X)

43                    INTERFACE



      SEP 2002                                    WORKING DRAFT                                            481


      J3/02-007R3                               WORKING DRAFT                                    SEP 2002



 1                       FUNCTION X(A)

 2                          REAL :: X

 3                          INTEGER :: A

 4                       END FUNCTION X

 5                     END INTERFACE

 6                    END SUBROUTINE S9C

 7                 END INTERFACE BAD9


 8    The real data objects that would be valid arguments for S9A are entirely disjoint from procedures that
 9    are valid arguments to S9B and S9C, and the procedures that valid arguments for S9B are disjoint from
10    the procedures that are valid arguments to S9C because the former are required to accept real arguments
11    and the latter integer arguments. Again, this interface is invalid, so a standard-conforming Fortran
12    processor need not examine such properties when deciding whether a generic collection is valid. Again,
13    the rules to cover all cases are too complicated to be useful.



14    C.12         Array feature notes

15    C.12.1       Summary of features

16    This section is a summary of the principal array features.


17    C.12.1.1     Whole array expressions and assignments (7.4.1.2, 7.4.1.3)

18    An important feature is that whole array expressions and assignments are permitted. For example, the
19    statement

20    A = B + C * SIN (D)

21    where A, B, C, and D are arrays of the same shape, is permitted. It is interpreted element-by-element;
22    that is, the sine function is taken on each element of D, each result is multiplied by the corresponding
23    element of C, added to the corresponding element of B, and assigned to the corresponding element of
24    A. Functions, including user-written functions, may be arrays and may be generic with scalar versions.
25    All arrays in an expression or across an assignment shall conform; that is, have exactly the same shape
26    (number of dimensions and extents in each dimension), but scalars may be included freely and these are
27    interpreted as being broadcast to a conforming array. Expressions are evaluated before any assignment
28    takes place.


29    C.12.1.2     Array sections (2.4.5, 6.2.2.3)

30    Whenever whole arrays may be used, it is also possible to use subarrays called "sections". For example:

31    A (:, 1:N, 2, 3:1:-1)

32    consists of a subarray containing the whole of the first dimension, positions 1 to N of the second dimen-
33    sion, position 2 of the third dimension and positions 1 to 3 in reverse order of the fourth dimension.
34    This is an artificial example chosen to illustrate the different forms. Of course, a common use may be
35    to select a row or column of an array, for example:

36    A (:, J)





      482                                   WORKING DRAFT                                        SEP 2002


      SEP 2002                                 WORKING DRAFT                                   J3/02-007R3



 1    C.12.1.3     WHERE statement (7.4.3)

 2    The WHERE statement applies a conforming logical array as a mask on the individual operations in the
 3    expression and in the assignment. For example:

 4    WHERE (A > 0) B = LOG (A)

 5    takes the logarithm only for positive components of A and makes assignments only in these positions.

 6    The WHERE statement also has a block form (WHERE construct).


 7    C.12.1.4     Automatic arrays and allocatable variables (5.1, 5.1.2.5.3)

 8    Two features useful for writing modular software are automatic arrays, created on entry to a subprogram
 9    and destroyed on return, and allocatable variables, including arrays whose rank is fixed but whose actual
10    size and lifetime is fully under the programmer's control through explicit ALLOCATE and DEALLO-
11    CATE statements. The declarations

12    SUBROUTINE X (N, A, B)
13    REAL WORK (N, N); REAL, ALLOCATABLE :: HEAP (:, :)

14    specify an automatic array WORK and an allocatable array HEAP. Note that a stack is an adequate
15    storage mechanism for the implementation of automatic arrays, but a heap will be needed for some
16    allocatable variables.


17    C.12.1.5     Array constructors (4.8)

18    Arrays, and in particular array constants, may be constructed with array constructors exemplified by:

19    (/ 1.0, 3.0, 7.2 /)

20    which is a rank-one array of size 3,

21    (/ (1.3, 2.7, L = 1, 10), 7.1 /)

22    which is a rank-one array of size 21 and contains the pair of real constants 1.3 and 2.7 repeated 10 times
23    followed by 7.1, and

24    (/ (I, I = 1, N) /)

25    which contains the integers 1, 2, ..., N. Only rank-one arrays may be constructed in this way, but higher
26    dimensional arrays may be made from them by means of the intrinsic function RESHAPE.


27    C.12.2       Examples

28    The array features have the potential to simplify the way that almost any array-using program is con-
29    ceived and written. Many algorithms involving arrays can now be written conveniently as a series of
30    computations with whole arrays.


31    C.12.2.1     Unconditional array computations

32    At the simplest level, statements such as

33    A = B + C

34    or





      SEP 2002                                     WORKING DRAFT                                           483


      J3/02-007R3                                              WORKING DRAFT                                     SEP 2002



 1    S = SUM (A)

 2    can take the place of entire DO loops. The loops were required to perform array addition or to sum all
 3    the elements of an array.

 4    Further examples of unconditional operations on arrays that are simple to write are:


                           matrix multiply                       P = MATMUL (Q, R)
                           largest array element                 L = MAXVAL (P)
                           factorial N                           F = PRODUCT ((/ (K, K = 2, N) /))



 5    The Fourier sum F =          N         a
                                   i=1       i � cos xi may also be computed without writing a DO loop if one makes
 6    use of the element-by-element definition of array expressions as described in Section 7. Thus, we can
 7    write

 8    F = SUM (A * COS (X))

 9    The successive stages of calculation of F would then involve the arrays:


                                        A         =    (/ A (1), ..., A (N) /)
                                        X         =    (/ X (1), ..., X (N) /)
                          COS (X)                 =    (/ COS (X (1)), ..., COS (X (N)) /)
                     A * COS (X)                  =    (/ A (1) * COS (X (1)), ..., A (N) * COS (X (N)) /)



10    The final scalar result is obtained simply by summing the elements of the last of these arrays. Thus, the
11    processor is dealing with arrays at every step of the calculation.


12    C.12.2.2    Conditional array computations

13    Suppose we wish to compute the Fourier sum in the above example, but to include only those terms
14    a(i) cos x(i) that satisfy the condition that the coefficient a(i) is less than 0.01 in absolute value. More
15    precisely, we are now interested in evaluating the conditional Fourier sum



                                                            CF =                 ai � cos xi
                                                                    |ai|<0.01


16    where the index runs from 1 to N as before.

17    This can be done by using the MASK parameter of the SUM function, which restricts the summation
18    of the elements of the array A * COS (X) to those elements that correspond to true elements of MASK.
19    Clearly, the mask required is the logical array expression ABS (A) < 0.01. Note that the stages of
20    evaluation of this expression are:


                                             A         =    (/ A (1), ..., A (N) /)
                             ABS (A)                   =    (/ ABS (A (1)), ..., ABS (A (N)) /)
                      ABS (A) < 0.01                   =    (/ ABS (A (1)) < 0.01, ..., ABS (A (N)) < 0.01 /)



21    The conditional Fourier sum we arrive at is:

22    CF = SUM (A * COS (X), MASK = ABS (A) < 0.01)

23    If the mask is all false, the value of CF is zero.




      484                                              WORKING DRAFT                                             SEP 2002


      SEP 2002                                  WORKING DRAFT                                   J3/02-007R3



 1    The use of a mask to define a subset of an array is crucial to the action of the WHERE statement. Thus
 2    for example, to zero an entire array, we may write simply A = 0; but to set only the negative elements
 3    to zero, we need to write the conditional assignment

 4    WHERE (A .LT. 0)         A = 0

 5    The WHERE statement complements ordinary array assignment by providing array assignment to any
 6    subset of an array that can be restricted by a logical expression.

 7    In the Ising model described below, the WHERE statement predominates in use over the ordinary array
 8    assignment statement.


 9    C.12.2.3        A simple program: the Ising model

10    The Ising model is a well-known Monte Carlo simulation in 3-dimensional Euclidean space which is
11    useful in certain physical studies. We will consider in some detail how this might be programmed. The
12    model may be described in terms of a logical array of shape N by N by N. Each gridpoint is a single
13    logical variable which is to be interpreted as either an up-spin (true) or a down-spin (false).

14    The Ising model operates by passing through many successive states. The transition to the next state is
15    governed by a local probabilistic process. At each transition, all gridpoints change state simultaneously.
16    Every spin either flips to its opposite state or not according to a rule that depends only on the states
17    of its 6 nearest neighbors in the surrounding grid. The neighbors of gridpoints on the boundary faces of
18    the model cube are defined by assuming cubic periodicity. In effect, this extends the grid periodically
19    by replicating it in all directions throughout space.

20    The rule states that a spin is flipped to its opposite parity for certain gridpoints where a mere 3 or
21    fewer of the 6 nearest neighbors have the same parity as it does. Also, the flip is executed only with
22    probability P (4), P (5), or P (6) if as many as 4, 5, or 6 of them have the same parity as it does. (The
23    rule seems to promote neighborhood alignments that may presumably lead to equilibrium in the long
24    run.)


25    C.12.2.3.1       Problems to be solved

26    Some of the programming problems that we will need to solve in order to translate the Ising model into
27    Fortran statements using entire arrays are

28             (1)     Counting nearest neighbors that have the same spin;

29             (2)     Providing an array function to return an array of random numbers; and

30             (3)     Determining which gridpoints are to be flipped.


31    C.12.2.3.2       Solutions in Fortran

32    The arrays needed are:



33    LOGICAL ISING (N, N, N), FLIPS (N, N, N)

34    INTEGER ONES (N, N, N), COUNT (N, N, N)

35    REAL THRESHOLD (N, N, N)

36    The array function needed is:

37    FUNCTION RAND (N)

38    REAL RAND (N, N, N)



39    The transition probabilities are specified in the array



      SEP 2002                                      WORKING DRAFT                                          485


      J3/02-007R3                               WORKING DRAFT                                      SEP 2002



 1    REAL P (6)

 2    The first task is to count the number of nearest neighbors of each gridpoint g that have the same spin
 3    as g.

 4    Assuming that ISING is given to us, the statements

 5    ONES = 0
 6    WHERE (ISING) ONES = 1

 7    make the array ONES into an exact analog of ISING in which 1 stands for an up-spin and 0 for a
 8    down-spin.

 9    The next array we construct, COUNT, will record for every gridpoint of ISING the number of spins to
10    be found among the 6 nearest neighbors of that gridpoint. COUNT will be computed by adding together
11    6 arrays, one for each of the 6 relative positions in which a nearest neighbor is found. Each of the 6
12    arrays is obtained from the ONES array by shifting the ONES array one place circularly along one of
13    its dimensions. This use of circular shifting imparts the cubic periodicity.



14    COUNT = CSHIFT (ONES, SHIFT = -1, DIM = 1)            &

15             + CSHIFT (ONES, SHIFT =      1, DIM = 1)     &

16             + CSHIFT (ONES, SHIFT = -1, DIM = 2)         &

17             + CSHIFT (ONES, SHIFT =      1, DIM = 2)     &

18             + CSHIFT (ONES, SHIFT = -1, DIM = 3)         &

19             + CSHIFT (ONES, SHIFT =      1, DIM = 3)


20    At this point, COUNT contains the count of nearest neighbor up-spins even at the gridpoints where
21    the Ising model has a down-spin. But we want a count of down-spins at those gridpoints, so we correct
22    COUNT at the down (false) points of ISING by writing:

23    WHERE (.NOT. ISING)       COUNT = 6 - COUNT

24    Our object now is to use these counts of what may be called the "like-minded nearest neighbors" to
25    decide which gridpoints are to be flipped. This decision will be recorded as the true elements of an array
26    FLIPS. The decision to flip will be based on the use of uniformly distributed random numbers from the
27    interval 0  p < 1. These will be provided at each gridpoint by the array function RAND. The flip will
28    occur at a given point if and only if the random number at that point is less than a certain threshold
29    value. In particular, by making the threshold value equal to 1 at the points where there are 3 or fewer
30    like-minded nearest neighbors, we guarantee that a flip occurs at those points (because p is always less
31    than 1). Similarly, the threshold values corresponding to counts of 4, 5, and 6 are assigned P (4), P (5),
32    and P (6) in order to achieve the desired probabilities of a flip at those points (P (4), P (5), and P (6)
33    are input parameters in the range 0 to 1).

34    The thresholds are established by the statements:



35    THRESHOLD = 1.0

36    WHERE (COUNT == 4) THRESHOLD = P (4)

37    WHERE (COUNT == 5) THRESHOLD = P (5)

38    WHERE (COUNT == 6) THRESHOLD = P (6)


39    and the spins that are to be flipped are located by the statement:

40    FLIPS = RAND (N) <= THRESHOLD



      486                                 WORKING DRAFT                                            SEP 2002


      SEP 2002                              WORKING DRAFT                                    J3/02-007R3



 1    All that remains to complete one transition to the next state of the ISING model is to reverse the spins
 2    in ISING wherever FLIPS is true:

 3    WHERE (FLIPS)      ISING = .NOT. ISING


 4    C.12.2.3.3    The complete Fortran subroutine

 5    The complete code, enclosed in a subroutine that performs a sequence of transitions, is as follows:



 6    SUBROUTINE TRANSITION (N, ISING, ITERATIONS, P)

 7

 8       LOGICAL ISING (N, N, N), FLIPS (N, N, N)

 9       INTEGER ONES (N, N, N), COUNT (N, N, N)

10       REAL THRESHOLD (N, N, N), P (6)

11

12       DO I = 1, ITERATIONS

13           ONES = 0

14           WHERE (ISING)      ONES = 1

15           COUNT = CSHIFT (ONES, -1, 1) + CSHIFT (ONES, 1, 1) &

16                   + CSHIFT (ONES, -1, 2) + CSHIFT (ONES, 1, 2) &

17                   + CSHIFT (ONES, -1, 3) + CSHIFT (ONES, 1, 3)

18           WHERE (.NOT. ISING)      COUNT = 6 - COUNT

19           THRESHOLD = 1.0

20           WHERE (COUNT == 4)      THRESHOLD = P (4)

21           WHERE (COUNT == 5)      THRESHOLD = P (5)

22           WHERE (COUNT == 6)      THRESHOLD = P (6)

23           FLIPS = RAND (N) <= THRESHOLD

24           WHERE (FLIPS)      ISING = .NOT. ISING

25       END DO

26

27    CONTAINS

28       FUNCTION RAND (N)

29           REAL RAND (N, N, N)

30           CALL RANDOM_NUMBER (HARVEST = RAND)

31           RETURN

32       END FUNCTION RAND

33    END



34    C.12.2.3.4    Reduction of storage

35    The array ISING could be removed (at some loss of clarity) by representing the model in ONES all the
36    time. The array FLIPS can be avoided by combining the two statements that use it as:

37    WHERE (RAND (N) <= THRESHOLD)         ISING = .NOT. ISING

38    but an extra temporary array would probably be needed. Thus, the scope for saving storage while
39    performing whole array operations is limited. If N is small, this will not matter and the use of whole
40    array operations is likely to lead to good execution speed. If N is large, storage may be very important



      SEP 2002                                   WORKING DRAFT                                               487


      J3/02-007R3                                  WORKING DRAFT                                    SEP 2002



 1    and adequate efficiency will probably be available by performing the operations plane by plane. The
 2    resulting code is not as elegant, but all the arrays except ISING will have size of order N2 instead of N3.


 3    C.12.3         FORmula TRANslation and array processing

 4    Many mathematical formulas can be translated directly into Fortran by use of the array processing
 5    features.

 6    We assume the following array declarations:

 7    REAL X (N), A (M, N)

 8    Some examples of mathematical formulas and corresponding Fortran expressions follow.


 9    C.12.3.1       A sum of products

      The expression
                                                          N    M

                                                                    aij
                                                         j=1 i=1



10    can be formed using the Fortran expression

11    SUM (PRODUCT (A, DIM=1))

12    The argument DIM=1 means that the product is to be computed down each column of A. If A had the
                B    C    D
      value                    the result of this expression is BE + CF + DG.
13              E    F    G


14    C.12.3.2       A product of sums

      The expression
                                                          M    N

                                                                    aij
                                                         i=1 j=1

15    can be formed using the Fortran expression

16    PRODUCT (SUM (A, DIM = 2))

17    The argument DIM = 2 means that the sum is to be computed along each row of A. If A had the
               B     C    D
      value                    the result of this expression is (B+C+D)(E+F+G).
18             E     F    G


19    C.12.3.3       Addition of selected elements

      The expression

                                                                    xi
                                                          xi>0.0

20    can be formed using the Fortran expression

21    SUM (X, MASK = X > 0.0)

22    The mask locates the positive elements of the array of rank one. If X has the vector value (0.0, �0.1,
23    0.2, 0.3, 0.2, �0.1, 0.0), the result of this expression is 0.7.





      488                                   WORKING DRAFT                                           SEP 2002


      SEP 2002                                WORKING DRAFT                                 J3/02-007R3


 1    C.12.4     Sum of squared residuals

      The expression
                                                     N

                                                            (xi - xmean)2
                                                     i=1

 2    can be formed using the Fortran statements

 3    XMEAN = SUM (X) / SIZE (X)
 4    SS = SUM ((X - XMEAN) ** 2)

 5    Thus, SS is the sum of the squared residuals.


 6    C.12.5     Vector norms: infinity-norm and one-norm

 7    The infinity-norm of vector X = (X (1), ..., X(N)) is defined as the largest of the numbers ABS (X(1)),
 8    ..., ABS(X(N)) and therefore has the value MAXVAL (ABS(X)).

 9    The one-norm of vector X is defined as the sum of the numbers ABS (X (1)), ..., ABS (X (N)) and
10    therefore has the value SUM ( ABS (X)).


11    C.12.6     Matrix norms: infinity-norm and one-norm

12    The infinity-norm of the matrix A = (A (I, J)) is the largest row-sum of the matrix ABS (A (I, J)) and
13    therefore has the value MAXVAL (SUM (ABS (A), DIM = 2)).

14    The one-norm of the matrix A = (A (I, J)) is the largest column-sum of the matrix ABS (A (I, J)) and
15    therefore has the value MAXVAL (SUM (ABS (A), DIM = 1)).


16    C.12.7     Logical queries

17    The intrinsic functions allow quite complicated questions about tabular data to be answered without
18    use of loops or conditional constructs. Consider, for example, the questions asked below about a simple
19    tabulation of students' test scores.

20    Suppose the rectangular table T (M, N) contains the test scores of M students who have taken N different
21    tests. T is an integer matrix with entries in the range 0 to 100.

22    Example: The scores on 4 tests made by 3 students are held as the table

      T =
                                                 85 76 90 60 
                                                     71      45    50    80
                                                                              
                                                     66      45    21    55


23    Question: What is each student's top score?

24    Answer: MAXVAL (T, DIM = 2); in the example: [90, 80, 66].

25    Question: What is the average of all the scores?

26    Answer: SUM (T) / SIZE (T); in the example: 62.

27    Question: How many of the scores in the table are above average?





      SEP 2002                                       WORKING DRAFT                                      489


      J3/02-007R3                                        WORKING DRAFT                                              SEP 2002



 1    Answer: ABOVE = T > SUM (T) / SIZE (T); N = COUNT (ABOVE); in the example: ABOVE is the
                                               t t t               . 
      logical array (t = true, . = false):         t      .    .    t         and COUNT (ABOVE) is 6.
                                                                        
 2                                                 t      .    .    .

 3    Question: What was the lowest score in the above-average group of scores?

 4    Answer: MINVAL (T, MASK = ABOVE), where ABOVE is as defined previously; in the example: 66.

 5    Question: Was there a student whose scores were all above average?

 6    Answer: With ABOVE as previously defined, the answer is yes or no according as the value of the
 7    expression ANY (ALL (ABOVE, DIM = 2)) is true or false; in the example, the answer is no.


 8    C.12.8     Parallel computations

 9    The most straightforward kind of parallel processing is to do the same thing at the same time to many
10    operands. Matrix addition is a good example of this very simple form of parallel processing. Thus, the
11    array assignment A = B + C specifies that corresponding elements of the identically-shaped arrays B
12    and C be added together in parallel and that the resulting sums be assigned in parallel to the array A.

13    The process being done in parallel in the example of matrix addition is of course the process of addi-
14    tion; the array feature that implements matrix addition as a parallel process is the element-by-element
15    evaluation of array expressions.

16    These observations lead us to look to element-by-element computation as a means of implementing other
17    simple parallel processing algorithms.


18    C.12.9     Example of element-by-element computation

19    Several polynomials of the same degree may be evaluated at the same point by arranging their coefficients
20    as the rows of a matrix and applying Horner's method for polynomial evaluation to the columns of the
21    matrix so formed.

22    The procedure is illustrated by the code to evaluate the three cubic polynomials


                                                        P (t) = 1 + 2t - 3t2 + 4t3

                                                        Q(t) = 2 - 3t + 4t2 - 5t3

                                                        R(t) = 3 + 4t - 5t2 + 6t3


23    in parallel at the point t = X and to place the resulting vector of numbers [P (X), Q (X), R (X)] in the
24    real array RESULT (3).

25    The code to compute RESULT is just the one statement

26    RESULT = M (:, 1) + X * (M (:, 2) + X * (M (:, 3) + X * M (:, 4)))

                                                                               1       2     -3    4     
      where M represents the matrix M (3, 4) with value                            2    -3    4     -5         .
                                                                                                         
27                                                                                 3    4     -5    6


28    C.12.10      Bit manipulation and inquiry procedures

29    The procedures IOR, IAND, NOT, IEOR, ISHFT, ISHFTC, IBITS, MVBITS, BTEST, IBSET, and
30    IBCLR are defined by MIL-STD 1753 for scalar arguments and are extended in this standard to accept



      490                                     WORKING DRAFT                                                         SEP 2002


     SEP 2002                            WORKING DRAFT          J3/02-007R3



1    array arguments and to return array results.





     SEP 2002                                  WORKING DRAFT           491


J3/02-007R3       WORKING DRAFT    SEP 2002





492            WORKING DRAFT       SEP 2002


SEP 2002                              WORKING DRAFT                                    J3/02-007R3





                                              Annex D

                                                   (Informative)


                                    Index of syntax rules
Section 1:
R101    xyz-list                      is    xyz [ , xyz ] ...

R102    xyz-name                      is    name

R103    scalar-xyz                    is    xyz

C101    (R103) scalar-xyz shall be scalar.

Section 2:
R201    program                       is    program-unit

                                                   [ program-unit ] ...

R202    program-unit                  is    main-program

                                      or external-subprogram

                                      or module

                                      or block-data

R203    external-subprogram           is    function-subprogram

                                      or subroutine-subprogram

R204    specification-part             is    [ use-stmt ] ...

                                                   [ import-stmt ] ...

                                                   [ implicit-part ]

                                                   [ declaration-construct ] ...

R205    implicit-part                 is    [ implicit-part-stmt ] ...

                                                   implicit-stmt

R206    implicit-part-stmt            is    implicit-stmt

                                      or parameter-stmt

                                      or format-stmt

                                      or entry-stmt

R207    declaration-construct         is    derived-type-def

                                      or entry-stmt

                                      or enum-alias-def

                                      or format-stmt

                                      or interface-block

                                      or parameter-stmt

                                      or procedure-declaration-stmt

                                      or specification-stmt

                                      or type-alias-stmt

                                      or type-declaration-stmt

                                      or stmt-function-stmt

R208    execution-part                is    executable-construct

                                                   [ execution-part-construct ] ...

R209    execution-part-construct      is    executable-construct

                                      or format-stmt



SEP 2002                                      WORKING DRAFT                                   493


J3/02-007R3                                WORKING DRAFT                      SEP 2002



                                     or entry-stmt

                                     or data-stmt

R210    internal-subprogram-part     is    contains-stmt

                                               internal-subprogram

                                               [ internal-subprogram ] ...

R211    internal-subprogram          is    function-subprogram

                                     or subroutine-subprogram

                                     or subroutine-subprogram

R212    specification-stmt            is    access-stmt

                                     or allocatable-stmt

                                     or asynchronous-stmt

                                     or bind-stmt

                                     or common-stmt

                                     or data-stmt

                                     or dimension-stmt

                                     or equivalence-stmt

                                     or external-stmt

                                     or intent-stmt

                                     or intrinsic-stmt

                                     or namelist-stmt

                                     or optional-stmt

                                     or pointer-stmt

                                     or protected-stmt

                                     or save-stmt

                                     or target-stmt

                                     or volatile-stmt

                                     or value-stmt

R213    executable-construct         is    action-stmt

                                     or associate-construct

                                     or case-construct

                                     or do-construct

                                     or forall-construct

                                     or if-construct

                                     or select-type-construct

                                     or where-construct

R214    action-stmt                  is    allocate-stmt

                                     or assignment-stmt

                                     or backspace-stmt

                                     or call-stmt

                                     or close-stmt

                                     or continue-stmt

                                     or cycle-stmt

                                     or deallocate-stmt

                                     or endfile-stmt

                                     or end-function-stmt

                                     or end-program-stmt




494                                 WORKING DRAFT                             SEP 2002


SEP 2002                             WORKING DRAFT                                  J3/02-007R3



                                     or end-subroutine-stmt

                                     or exit-stmt

                                     or flush-stmt

                                     or forall-stmt

                                     or goto-stmt

                                     or if-stmt

                                     or inquire-stmt

                                     or nullify-stmt

                                     or open-stmt

                                     or pointer-assignment-stmt

                                     or print-stmt

                                     or read-stmt

                                     or return-stmt

                                     or rewind-stmt

                                     or stop-stmt

                                     or wait-stmt

                                     or where-stmt

                                     or write-stmt

                                     or arithmetic-if-stmt

                                     or computed-goto-stmt

C201    (R208) An execution-part shall not contain an end-function-stmt , end-program-stmt , or end-
        subroutine-stmt .

R215    keyword                      is    name

Section 3:
R301    character                    is    alphanumeric-character

                                     or special-character

R302    alphanumeric-character       is    letter

                                     or digit

                                     or underscore

R303    underscore                   is

R304    name                         is    letter [ alphanumeric-character ] ...

C301    (R304) The maximum length of a name is 63 characters.

R305    constant                     is    literal-constant

                                     or named-constant

R306    literal-constant             is    int-literal-constant

                                     or real-literal-constant

                                     or complex-literal-constant

                                     or logical-literal-constant

                                     or char-literal-constant

                                     or boz-literal-constant

R307    named-constant               is    name

R308    int-constant                 is    constant

C302    (R308)int-constant shall be of type integer.

R309    char-constant                is    constant

C303    (R309) char-constant shall be of type character.

R310    intrinsic-operator           is    power-op




SEP 2002                                     WORKING DRAFT                                     495


J3/02-007R3                                   WORKING DRAFT                                    SEP 2002



                                        or mult-op

                                        or add-op

                                        or concat-op

                                        or rel-op

                                        or not-op

                                        or and-op

                                        or or-op

                                        or equiv-op

                                        or /

                                        or �

                                        or .NE.

                                        or .LT.

                                        or .LE.

                                        or .GT.

                                        or .GE.

                                        or ==

                                        or /=

                                        or <

                                        or <=

                                        or >

                                        or >=

                                        or .NEQV.

R311    defined-operator                 is    defined-unary-op

                                        or defined-binary-op

                                        or extended-intrinsic-op

R312    extended-intrinsic-op           is    intrinsic-operator

R313    label                           is    digit [ digit [ digit [ digit [ digit ] ] ] ]

C304    (R313) At least one digit in a label shall be nonzero.

Section 4:
R401    type-param-value                is    scalar-int-expr

                                        or *

                                        or :

C401    (R401) The type-param-value for a kind type parameter shall be an initialization expression.

C402    (R401) A colon may be used as a type-param-value only in the declaration of an entity or
        component that has the POINTER or ALLOCATABLE attribute.

R402    signed-int-literal-constant     is    [ sign ] int-literal-constant

R403    int-literal-constant            is    digit-string [     kind-param ]

R404    kind-param                      is    digit-string

                                        or scalar-int-constant-name

R405    signed-digit-string             is    [ sign ] digit-string

R406    digit-string                    is    digit [ digit ] ...

R407    sign                            is    +

                                        or �

C403    (R404) A scalar-int-constant-name shall be a named constant of type integer.

C404    (R404) The value of kind-param shall be nonnegative.

C405    (R403) The value of kind-param shall specify a representation method that exists on the pro-




496                                    WORKING DRAFT                                           SEP 2002


SEP 2002                                WORKING DRAFT                                        J3/02-007R3



        cessor.

R408    boz-literal-constant            is    binary-constant

                                        or octal-constant

                                        or hex-constant

R409    binary-constant                 is    B ' digit [ digit ] ... '

                                        or B " digit [ digit ] ... "

C406    (R409) digit shall have one of the values 0 or 1.

R410    octal-constant                  is    O ' digit [ digit ] ... '

                                        or O " digit [ digit ] ... "

C407    (R410) digit shall have one of the values 0 through 7.

R411    hex-constant                    is    Z ' hex-digit [ hex-digit ] ... '

                                        or Z " hex-digit [ hex-digit ] ... "

R412    hex-digit                       is    digit

                                        or A

                                        or B

                                        or C

                                        or D

                                        or E

                                        or F

C408    (R408) A boz-literal-constant shall appear only as a data-stmt-constant in a DATA statement, as
        the actual argument associated with the dummy argument A of the numeric intrinsic functions
        DBLE, REAL or INT, or as the actual argument associated with the X or Y dummy argument
        of the intrinsic CMPLX function.

R413    signed-real-literal-constant    is    [ sign ] real-literal-constant

R414    real-literal-constant           is    significand [ exponent-letter exponent ] [    kind-param ]

                                        or digit-string exponent-letter exponent [       kind-param ]

R415    significand                      is    digit-string . [ digit-string ]

                                        or . digit-string

R416    exponent-letter                 is    E

                                        or D

R417    exponent                        is    signed-digit-string

C409    (R414) If both kind-param and exponent-letter are present, exponent-letter shall be E.

C410    (R414) The value of kind-param shall specify an approximation method that exists on the
        processor.

R418    complex-literal-constant        is    ( real-part , imag-part )

R419    real-part                       is    signed-int-literal-constant

                                        or signed-real-literal-constant

                                        or named-constant

R420    imag-part                       is    signed-int-literal-constant

                                        or signed-real-literal-constant

                                        or named-constant

C411    (R418) Each named constant in a complex literal constant shall be of type integer or real.

R421    char-literal-constant           is    [ kind-param     ] ' [ rep-char ] ... '

                                        or [ kind-param        ] " [ rep-char ] ... "

C412    (R421) The value of kind-param shall specify a representation method that exists on the pro-
        cessor.

R422    logical-literal-constant        is    .TRUE. [     kind-param ]




SEP 2002                                           WORKING DRAFT                                           497


J3/02-007R3                                WORKING DRAFT                                        SEP 2002



                                     or .FALSE. [         kind-param ]

C413    (R422) The value of kind-param shall specify a representation method that exists on the pro-
        cessor.

R423    derived-type-def             is    derived-type-stmt

                                               [ type-param-def-stmt ] ...

                                               [ data-component-part ]

                                               [ type-bound-procedure-part ]

                                               end-type-stmt

R424    derived-type-stmt            is    TYPE [ [ , type-attr-spec-list ] :: ] type-name

                                             [ ( type-param-name-list ) ]

R425    type-attr-spec               is    access-spec

                                     or EXTENSIBLE

                                     or EXTENDS ( [ access-spec :: ] parent-type-name

                                             [ = initialization-expr ] )

                                     or BIND (C)

C414    (R424) A derived type type-name shall not be the same as the name of any intrinsic type defined
        in this standard.

C415    (R424) The same type-attr-spec shall not appear more than once in a given derived-type-stmt .

C416    (R424) EXTENSIBLE and EXTENDS shall not both appear.

C417    (R425) A parent-type-name shall be the name of an accessible extensible type (4.5.3).

C418    (R423) If EXTENDS or EXTENSIBLE appears, neither BIND(C) nor SEQUENCE shall appear.

R426    type-param-def-stmt          is    INTEGER [ kind-selector ] , type-param-attr-spec ::

                                             type-param-name-list

C419    (R426) A type-param-name in a type-param-def-stmt in a derived-type-def shall be one of the
        type-param-names in the derived-type-stmt of that derived-type-def .

C420    (R426) Each type-param-name in the derived-type-stmt in a derived-type-def shall appear as a
        type-param-name in a type-param-def-stmt in that derived-type-def .

R427    type-param-attr-spec         is    KIND

                                     or NONKIND

R428    data-component-part          is    [ private-sequence-stmt ] ...

                                               [ component-def-stmt ] ...

R429    private-sequence-stmt        is    PRIVATE

                                     or SEQUENCE

C421    (R429) A PRIVATE statement is permitted only if the type definition is within the specification
        part of a module.

C422    (R428) The same private-sequence-stmt shall not appear more than once in a given derived-type-
        def .

C423    (R428) If SEQUENCE appears, all derived types specified in component definitions shall be
        sequence types.

C424    (R423) If SEQUENCE appears, a type-bound-procedure-part shall not appear.

R430    component-def-stmt           is    data-component-def-stmt

                                     or proc-component-def-stmt

R431    data-component-def-stmt      is    declaration-type-spec [ [ , component-attr-spec-list ] :: ]

                                             component-decl -list

R432    component-attr-spec          is    POINTER

                                     or DIMENSION ( component-array-spec )

                                     or ALLOCATABLE




498                                WORKING DRAFT                                                SEP 2002


SEP 2002                              WORKING DRAFT                                           J3/02-007R3



                                      or access-spec

R433    component-decl                is    component-name [ ( component-array-spec ) ]

                                                [ * char-length ] [ component-initialization ]

R434    component-array-spec          is    explicit-shape-spec-list

                                      or deferred-shape-spec-list

R435    component-initialization      is    = initialization-expr

                                      or => null-init

C425    (R431) No component-attr-spec shall appear more than once in a given component-def-stmt .

C426    (R431) A component declared with the CLASS keyword (5.1.1.8) shall have the ALLOCATABLE
        or POINTER attribute.

C427    (R431) If the POINTER attribute is not specified for a component, the declaration-type-spec in
        the component-def-stmt shall specify an intrinsic type or a previously defined derived type.

C428    (R431) If the POINTER attribute is specified for a component, the declaration-type-spec in the
        component-def-stmt shall specify an intrinsic type or any accessible derived type including the
        type being defined.

C429    (R431) If the POINTER or ALLOCATABLE attribute is specified, each component-array-spec
        shall be a deferred-shape-spec-list.

C430    (R431) If neither the POINTER attribute nor the ALLOCATABLE attribute is specified, each
        component-array-spec shall be an explicit-shape-spec-list.

C431    (R434) Each bound in the explicit-shape-spec shall either be an initialization expression or be a
        specification expression that does not contain references to specification functions or any object
        designators other than named constants or subobjects thereof.

C432    (R431) A component shall not have both the ALLOCATABLE and the POINTER attribute.

C433    (R433) The * char-length option is permitted only if the type specified is character.

C434    (R430) Each type-param-value within a component-def-stmt shall either be a colon, be an ini-
        tialization expression, or be a specification expression that contains neither references to speci-
        fication functions nor any object designators other than named constants or subobjects thereof.

C435    (R431) If component-initialization appears, a double-colon separator shall appear before the
        component-decl -list.

C436    (R431) If => appears in component-initialization, POINTER shall appear in the component-
        attr-spec-list. If = appears in component-initialization, POINTER or ALLOCATABLE shall
        not appear in the component-attr-spec-list.

R436    proc-component-def-stmt       is    PROCEDURE ( [ proc-interface ] ) ,

                                                proc-component-attr-spec-list :: proc-decl -list

R437    proc-component-attr-spec      is    POINTER

                                      or PASS [ (arg-name) ]

                                      or NOPASS

                                      or access-spec

C437    (R436) The same proc-component-attr-spec shall not appear more than once in a given proc-
        component-def-stmt .

C438    (R436) POINTER shall appear in each proc-component-attr-spec-list.

C439    (R436) If the procedure pointer component has an implicit interface or has no arguments,
        NOPASS shall be specified.

C440    (R436) If PASS (arg-name) appears, the interface shall have a dummy argument named arg-
        name.

C441    (R436) PASS and NOPASS shall not both appear in the same proc-component-attr-spec-list.

R438    type-bound-procedure-part     is    contains-stmt

                                                  [ binding-private-stmt ]

                                                  proc-binding-stmt



SEP 2002                                        WORKING DRAFT                                        499


J3/02-007R3                                    WORKING DRAFT                                        SEP 2002



                                                   [ proc-binding-stmt ] ...

R439    binding-private-stmt             is    PRIVATE

C442    (R438) A binding-private-stmt is permitted only if the type definition is within the specification
        part of a module.

R440    proc-binding-stmt                is    specific-binding

                                         or generic-binding

                                         or final-binding

C443    (R440) No proc-binding-stmt shall specify a binding that overrides (4.5.3.2) one that is inherited
        (4.5.3.1) from the parent type and has the NON OVERRIDABLE binding attribute.

R441    specific-binding                  is    PROCEDURE

                                                 [ [ , binding-attr -list ] :: ] binding-name [ => binding ]

C444    (R441) If => binding appears, the double-colon separator shall appear.

R442    generic-binding                  is    GENERIC

                                                 [, binding-attr -list ] :: generic-spec => binding-list

C445    (R442) If generic-spec is generic-name, generic-name shall not be the name of a nongeneric
        binding of the type.

C446    (R442) If generic-spec is OPERATOR ( defined-operator ), the interface of each binding shall
        be as specified in 12.3.2.1.1.

C447    (R442) If generic-spec is ASSIGNMENT ( = ), the interface of each binding shall be as specified
        in 12.3.2.1.2.

C448    (R442) If generic-spec is dtio-generic-spec, the interface of each binding shall be as specified in
        9.5.3.7. The type of the dtv argument shall be type-name.

R443    final-binding                     is    FINAL [ :: ] final-subroutine-name-list

C449    (R443) A final-subroutine-name shall be the name of a module procedure with exactly one
        dummy argument. That argument shall be nonoptional and shall be a nonpointer, nonallocat-
        able, nonpolymorphic variable of the derived type being defined. All nonkind type parameters
        of the dummy argument shall be assumed. The dummy argument shall not be INTENT(OUT).

C450    (R443) A final-subroutine-name shall not be one previously specified as a final subroutine for
        that type.

C451    (R443) A final subroutine shall not have a dummy argument with the same kind type parameters
        and rank as the dummy argument of another final subroutine of that type.

R444    binding-attr                     is    PASS [ (arg-name) ]

                                         or NOPASS

                                         or NON OVERRIDABLE

                                         or access-spec

C452    (R444) The same binding-attr shall not appear more than once in a given binding-attr -list.

C453    (R441, R442) If the interface of the binding has no dummy argument of the type being defined,
        NOPASS shall appear.

C454    (R441, R442) If PASS (arg-name) appears, the interface of the binding shall have a dummy
        argument named arg-name.

C455    (R440) PASS and NOPASS shall not both appear in the same binding-attr -list.

C456    (R442) A generic-binding for which generic-spec is not generic-name shall have a passed-object
        dummy argument (4.5.1.6).

C457    (R442) An overriding binding shall have a passed-object dummy argument if and only if the
        binding that it overrides has a passed-object dummy argument.

C458    (R442) Within the specification-part of a module, each generic-binding shall specify, either
        implicitly or explicitly, the same accessibility as every other generic-binding in the same derived-
        type-def that has the same generic-spec.

R445    binding                          is    procedure-name



500                                 WORKING DRAFT                                                   SEP 2002


SEP 2002                                 WORKING DRAFT                                          J3/02-007R3



C459    (R445) The procedure-name shall be the name of an accessible module procedure or an external
        procedure that has an explicit interface.

R446    end-type-stmt                    is    END TYPE [ type-name ]

C460    (R446) If END TYPE is followed by a type-name, the type-name shall be the same as that in
        the corresponding derived-type-stmt .

C461    The passed-object dummy argument shall be a scalar, nonpointer, nonallocatable dummy data
        object with the same declared type as the type being defined; all of its nonkind type parameters
        shall be assumed; it shall be polymorphic if and only if the type being defined is extensible.

R447    derived-type-spec                is    type-name [ ( type-param-spec-list ) ]

                                         or type-alias-name

R448    type-param-spec                  is    [ keyword = ] type-param-value

C462    (R447) type-name shall be the name of an accessible derived type.

C463    (R447) type-alias-name shall be the name of an accessible type alias that is an alias for a derived
        type.

C464    (R447) type-param-spec-list shall appear if and only if the type is parameterized.

C465    (R447) There shall be exactly one type-param-spec corresponding to each parameter of the type.

C466    (R448) The keyword = may be omitted from a type-param-spec only if the keyword = has been
        omitted from each preceding type-param-spec in the type-param-spec-list.

C467    (R448) Each keyword shall be the name of a parameter of the type.

C468    (R448) An asterisk may be used as a type-param-value in a type-param-spec only in the decla-
        ration or allocation of a dummy argument.

R449    structure-constructor            is    derived-type-spec ( [ component-spec-list ] )

R450    component-spec                   is    [ keyword = ] component-data-source

R451    component-data-source            is    expr

                                         or data-target

                                         or proc-target

C469    (R449) At most one component-spec shall be provided for a component.

C470    (R449) If a component-spec is be provided for a component, no component-spec shall be provided
        for any component with which it is inheritance associated.

C471    (R449) A component-spec shall be provided for a component unless it has default initialization
        or is inheritance associated with another component for which a component-spec is provided or
        that has default initialization.

C472    (R450) The keyword = may be omitted from a component-spec only if the keyword = has been
        omitted from each preceding component-spec in the constructor.

C473    (R450) Each keyword shall be the name of a component of the type.

C474    (R449) The type name and all components of the type for which a component-spec appears shall
        be accessible in the scoping unit containing the structure constructor.

C475    (R449) If derived-type-spec is a type name that is the same as a generic name, the component-
        spec-list shall not be a valid actual-arg-spec-list for a function reference that is resolvable as a
        generic reference (12.4.4.1).

C476    (R451) A data-target shall correspond to a nonprocedure pointer component; a proc-target shall
        correspond to a procedure pointer component.

C477    (R451) A data-target shall have the same rank as its corresponding component.

R452    type-alias-stmt                  is    TYPEALIAS :: type-alias-list

R453    type-alias                       is    type-alias-name => declaration-type-spec

C478    (R453) A type-alias-name shall not be the same as the name of any intrinsic type defined in this
        standard.

C479    (R453) A declaration-type-spec in a type-alias shall not use the CLASS keyword.

C480    (R453) A declaration-type-spec shall specify an intrinsic type or a previously defined derived



SEP 2002                                        WORKING DRAFT                                          501


J3/02-007R3                                WORKING DRAFT                                            SEP 2002



        type. Each type-param-value shall be an initialization expression.

R454    enum-alias-def               is    enum-def-stmt

                                                  enumerator-def-stmt

                                                  [ enumerator-def-stmt ] ...

                                                  end-enum-stmt

R455    enum-def-stmt                is    ENUM, BIND(C) :: type-alias-name

                                     or ENUM [ kind-selector ] [ :: ] type-alias-name

R456    enumerator-def-stmt          is    ENUMERATOR [ :: ] enumerator -list

R457    enumerator                   is    named-constant [ = scalar-int-initialization-expr ]

R458    end-enum-stmt                is    END ENUM [ type-alias-name ]

C481    (R456) If = appears in an enumerator , a double-colon separator shall appear before the enu-
        merator -list.

C482    (R458) If END ENUM is followed by a type-alias-name, the type-alias-name shall be the same
        as that in the corresponding enum-def-stmt .

R459    array-constructor            is    (/ ac-spec /)

                                     or left-square-bracket ac-spec right-square-bracket

R460    ac-spec                      is    type-spec ::

                                     or [type-spec ::] ac-value-list

R461    left-square-bracket          is    [

R462    right-square-bracket         is    ]

R463    ac-value                     is    expr

                                     or ac-implied-do

R464    ac-implied-do                is    ( ac-value-list , ac-implied-do-control )

R465    ac-implied-do-control        is    ac-do-variable = scalar-int-expr , scalar-int-expr

                                                [ , scalar-int-expr ]

R466    ac-do-variable               is    scalar-int-variable

C483    (R466) ac-do-variable shall be a named variable.

C484    (R460) If type-spec is omitted, each ac-value expression in the array-constructor shall have the
        same type and kind type parameters.

C485    (R460) If type-spec specifies an intrinsic type, each ac-value expression in the array-constructor
        shall be of an intrinsic type that is in type conformance with a variable of type type-spec as
        specified in Table 7.8.

C486    (R460) If type-spec specifies a derived type, all ac-value expressions in the array-constructor
        shall be of that derived type and shall have the same kind type parameter values as specified by
        type-spec.

C487    (R464) The ac-do-variable of an ac-implied-do that is in another ac-implied-do shall not appear
        as the ac-do-variable of the containing ac-implied-do.

Section 5:
R501    type-declaration-stmt        is    declaration-type-spec [ [ , attr-spec ] ... :: ] entity-decl -list

R502    declaration-type-spec        is    type-spec

                                     or CLASS ( derived-type-spec )

                                     or CLASS ( * )

C501    (R502) In a declaration-type-spec, every type-param-value that is not a colon or an asterisk shall
        be a specification-expr .

C502    (R502) In a declaration-type-spec that uses the CLASS keyword, derived-type-spec shall specify
        an extensible type.

R503    type-spec                    is    INTEGER [ kind-selector ]




502                                 WORKING DRAFT                                                   SEP 2002


SEP 2002                                  WORKING DRAFT                                          J3/02-007R3



                                          or REAL [ kind-selector ]

                                          or DOUBLE PRECISION

                                          or COMPLEX [ kind-selector ]

                                          or CHARACTER [ char-selector ]

                                          or LOGICAL [ kind-selector ]

                                          or TYPE ( derived-type-spec )

                                          or TYPE ( type-alias-name )

C503    (R503) A type-alias-name shall be the name of a type alias.

R504    attr-spec                         is    access-spec

                                          or ALLOCATABLE

                                          or ASYNCHRONOUS

                                          or DIMENSION ( array-spec )

                                          or EXTERNAL

                                          or INTENT ( intent-spec )

                                          or INTRINSIC

                                          or language-binding-spec

                                          or OPTIONAL

                                          or PARAMETER

                                          or POINTER

                                          or PROTECTED

                                          or SAVE

                                          or TARGET

                                          or VALUE

                                          or VOLATILE

R505    entity-decl                       is    object-name [( array-spec )] [ * char-length ] [ initialization ]

                                          or function-name [ * char-length ]

C504    (R505) If a type-param-value in a char-length in an entity-decl is not a colon or an asterisk, it
        shall be a specification-expr .

R506    object-name                       is    name

C505    (R506) The object-name shall be the name of a data object.

R507    kind-selector                     is    ( [ KIND = ] scalar-int-initialization-expr )

R508    initialization                    is    = initialization-expr

                                          or => null-init

R509    null-init                         is    function-reference

C506    (R509) The function-reference shall be a reference to the NULL intrinsic function with no
        arguments.

C507    (R501) The same attr-spec shall not appear more than once in a given type-declaration-stmt .

C508    An entity shall not be explicitly given any attribute more than once in a scoping unit.

C509    (R501) An entity declared with the CLASS keyword shall be a dummy argument or have the
        ALLOCATABLE or POINTER attribute.

C510    (R501) An array that has the POINTER or ALLOCATABLE attribute shall be specified with
        an array-spec that is a deferred-shape-spec-list (5.1.2.5.3).

C511    (R501) An array-spec for an object-name that is a function result that does not have the AL-
        LOCATABLE or POINTER attribute shall be an explicit-shape-spec-list.

C512    (R501) If the POINTER attribute is specified, the ALLOCATABLE, TARGET, EXTERNAL,
        or INTRINSIC attribute shall not be specified.

C513    (R501) If the TARGET attribute is specified, the POINTER, EXTERNAL, INTRINSIC, or




SEP 2002                                         WORKING DRAFT                                               503


J3/02-007R3                                  WORKING DRAFT                                     SEP 2002



        PARAMETER attribute shall not be specified.

C514    (R501) The PARAMETER attribute shall not be specified for a dummy argument, a pointer,
        an allocatable entity, a function, or an object in a common block.

C515    (R501) The INTENT, VALUE, and OPTIONAL attributes may be specified only for dummy
        arguments.

C516    (R501) The INTENT attribute shall not be specified for a dummy argument that is a dummy
        procedure.

C517    (R501) The SAVE attribute shall not be specified for an object that is in a common block, a
        dummy argument, a procedure, a function result, an automatic data object, or an object with
        the PARAMETER attribute.

C518    An entity shall not have both the EXTERNAL attribute and the INTRINSIC attribute.

C519    (R501) An entity in an entity-decl -list shall not have the EXTERNAL or INTRINSIC attribute
        specified unless it is a function.

C520    (R505) The * char-length option is permitted only if the type specified is character.

C521    (R505) The function-name shall be the name of an external function, an intrinsic function, a
        function dummy procedure, or a statement function.

C522    (R501) The initialization shall appear if the statement contains a PARAMETER attribute
        (5.1.2.10).

C523    (R501) If initialization appears, a double-colon separator shall appear before the entity-decl -list.

C524    (R505)initialization shall not appear if object-name is a dummy argument, a function result, an
        object in a named common block unless the type declaration is in a block data program unit,
        an object in blank common, an allocatable variable, an external name, an intrinsic name, or an
        automatic object.

C525    (R505) If => appears in initialization, the object shall have the POINTER attribute. If =
        appears in initialization, the object shall not have the POINTER attribute.

C526    (R503) The value of scalar-int-initialization-expr in kind-selector shall be nonnegative and shall
        specify a representation method that exists on the processor.

C527    (R501) If the VOLATILE attribute is specified, the PARAMETER, INTRINSIC, EXTERNAL,
        or INTENT(IN) attribute shall not be specified.

C528    (R501) If the VALUE attribute is specified, the PARAMETER, EXTERNAL, POINTER,
        ALLOCATABLE, DIMENSION, VOLATILE, INTENT(INOUT), or INTENT(OUT) attribute
        shall not be specified.

C529    (R501) If the VALUE attribute is specified for a dummy argument of type character, the length
        parameter shall be omitted or shall be specified by an initialization expression with the value
        one.

C530    (R501) The ALLOCATABLE, POINTER, or OPTIONAL attribute shall not be specified for a
        dummy argument of a procedure that has a proc-language-binding-spec.

C531    (R504) A language-binding-spec shall appear only in the specification part of a module.

C532    (R501) If a language-binding-spec is specified, the entity declared shall be an interoperable
        variable (15.2).

C533    (R501) If a language-binding-spec with a NAME= specifier appears, the entity-decl -list shall
        consist of a single entity-decl .

C534    (R504) The PROTECTED attribute is permitted only in the specification part of a module.

C535    (R501) The PROTECTED attribute is permitted only for a procedure pointer or named variable
        that is not in a common block.

C536    (R501) If the PROTECTED attribute is specified, the EXTERNAL, INTRINSIC, or PARAM-
        ETER attribute shall not be specified.

C537    A nonpointer object that has the PROTECTED attribute and is accessed by use association
        shall not appear in a variable definition context (16.5.7) or as the data-target or proc-target in
        a pointer-assignment-stmt .



504                                    WORKING DRAFT                                           SEP 2002


SEP 2002                                     WORKING DRAFT                                              J3/02-007R3



C538      A pointer object that has the PROTECTED attribute and is accessed by use association shall
          not appear as

        (1)    A pointer-object in a pointer-assignment-stmt or nullify-stmt ,

        (2)    An allocate-object in an allocate-stmt or deallocate-stmt , or

        (3)    An actual argument in a reference to a procedure if the associated dummy argument is a
               pointer with the INTENT(OUT) or INTENT(INOUT) attribute.

R510      char-selector                      is    length-selector

                                             or ( LEN = type-param-value ,

                                                        KIND = scalar-int-initialization-expr )

                                             or ( type-param-value ,

                                                        [ KIND = ] scalar-int-initialization-expr )

                                             or ( KIND = scalar-int-initialization-expr

                                                        [ , LEN =type-param-value ] )

R511      length-selector                    is    ( [ LEN = ] type-param-value )

                                             or * char-length [ , ]

R512      char-length                        is    ( type-param-value )

                                             or scalar-int-literal-constant

C539      (R510) The value of scalar-int-initialization-expr shall be nonnegative and shall specify a rep-
          resentation method that exists on the processor.

C540      (R512) The scalar-int-literal-constant shall not include a kind-param.

C541      (R510 R511 R512) A type-param-value of * may be used only in the following ways:

C542      A function name shall not be declared with an asterisk type-param-value unless it is of type CHAR-

          ACTER and is the name of the result of an external function or the name of a dummy function.

C543      A function name declared with an asterisk type-param-value shall not be an array, a pointer, recursive, or pure.

C544      (R511) The optional comma in a length-selector is permitted only in a declaration-type-spec in a type-declaration-

          stmt .

C545      (R511) The optional comma in a length-selector is permitted only if no double-colon separator appears in the

          type-declaration-stmt .

C546      (R510) The length specified for a character statement function or for a statement function dummy argument of

          type character shall be an initialization expression.

R513      access-spec                        is    PUBLIC

                                             or PRIVATE

C547      (R513) An access-spec shall appear only in the specification-part of a module.

R514      language-binding-spec              is    BIND (C [, NAME = scalar-char-initialization-expr ])

C548      (R514) The scalar-char-initialization-expr shall be of default character kind.

R515      array-spec                         is    explicit-shape-spec-list

                                             or assumed-shape-spec-list

                                             or deferred-shape-spec-list

                                             or assumed-size-spec

C549      (R515)The maximum rank is seven.

R516      explicit-shape-spec                is    [ lower-bound : ] upper-bound

R517      lower-bound                        is    specification-expr

R518      upper-bound                        is    specification-expr

C550      (R516) An explicit-shape array whose bounds are not initialization expressions shall be a dummy
          argument, a function result, or an automatic array of a procedure.

R519      assumed-shape-spec                 is    [ lower-bound ] :

R520      deferred-shape-spec                is    :




SEP 2002                                                WORKING DRAFT                                                 505


J3/02-007R3                                   WORKING DRAFT                                         SEP 2002



R521    assumed-size-spec               is    [ explicit-shape-spec-list , ] [ lower-bound : ] *

C551    An assumed-size-spec shall not appear except as the declaration of the array bounds of a dummy
        data argument.

C552    An assumed-size array with INTENT (OUT) shall not be of a type for which default initialization
        is specified.

R522    intent-spec                     is    IN

                                        or OUT

                                        or INOUT

C553    (R522) A nonpointer object with the INTENT (IN) attribute shall not appear in a variable
        definition context (16.5.7).

C554    (R522) A pointer object with the INTENT (IN) attribute shall not appear as

C555    (R504) (R1216) If the name of a generic intrinsic procedure is explicitly declared to have the
        INTRINSIC attribute, and it is also the generic name in one or more generic interfaces (12.3.2.1)
        accessible in the same scoping unit, the procedures in the interfaces and the specific intrinsic
        procedures shall all be functions or all be subroutines, and the characteristics of the specific
        intrinsic procedures and the procedures in the interfaces shall differ as specified in 16.2.3.

R523    access-stmt                     is    access-spec [ [ :: ] access-id -list ]

R524    access-id                       is    use-name

                                        or generic-spec

C556    (R523) An access-stmt shall appear only in the specification-part of a module. Only one ac-
        cessibility statement with an omitted access-id -list is permitted in the specification-part of a
        module.

C557    (R524) Each use-name shall be the name of a named variable, procedure, derived type, named
        constant, or namelist group.

R525    allocatable-stmt                is    ALLOCATABLE [ :: ]

                                                object-name [ ( deferred-shape-spec-list ) ]

                                                [ , object-name [ ( deferred-shape-spec-list ) ] ] ...

R526    asynchronous-stmt               is    ASYNCHRONOUS [ :: ] object-name-list

R527    bind-stmt                       is    language-binding-spec [ :: ] bind-entity-list

R528    bind-entity                     is    entity-name

                                        or / common-block-name /

C558    (R527) If any bind-entity in a bind-stmt is an entity-name, the bind-stmt shall appear in the
        specification part of a module and the entity shall be an interoperable variable (15.2.4, 15.2.5).

C559    (R527) If the language-binding-spec has a NAME= specifier, the bind-entity-list shall consist of
        a single bind-entity.

C560    (R527) If a bind-entity is a common block, each variable of the common block shall be interop-
        erable (15.2.4, 15.2.5).

R529    data-stmt                       is    DATA data-stmt-set [ [ , ] data-stmt-set ] ...

R530    data-stmt-set                   is    data-stmt-object -list / data-stmt-value-list /

R531    data-stmt-object                is    variable

                                        or data-implied-do

R532    data-implied-do                 is    ( data-i-do-object -list , data-i-do-variable =

                                                scalar-int-expr , scalar-int-expr [ , scalar-int-expr ] )

R533    data-i-do-object                is    array-element

                                        or scalar-structure-component

                                        or data-implied-do

R534    data-i-do-variable              is    scalar-int-variable

C561    (R531) In a variable that is a data-stmt-object , any subscript, section subscript, substring start-




506                                    WORKING DRAFT                                                SEP 2002


SEP 2002                              WORKING DRAFT                                        J3/02-007R3



        ing point, and substring ending point shall be an initialization expression.

C562    (R531) A variable whose designator is included in a data-stmt-object -list or a data-i-do-object -
        list shall not be: a dummy argument, made accessible by use association or host association, in
        a named common block unless the DATA statement is in a block data program unit, in a blank
        common block, a function name, a function result name, an automatic object, or an allocatable
        variable.

C563    (R531) A data-i-do-object or a variable that appears as a data-stmt-object shall not be an object
        designator in which a pointer appears other than as the entire rightmost part-ref .

C564    (R534)data-i-do-variable shall be a named variable.

C565    (R532) A scalar-int-expr of a data-implied-do shall involve as primaries only constants, subob-
        jects of constants, or DO variables of the containing data-implied-dos, and each operation shall
        be intrinsic.

C566    (R533) The array-element shall be a variable.

C567    (R533) The scalar-structure-component shall be a variable.

C568    (R533) The scalar-structure-component shall contain at least one part-ref that contains a sub-
        script -list.

C569    (R533) In an array-element or a scalar-structure-component that is a data-i-do-object , any sub-
        script shall be an expression whose primaries are either constants, subobjects of constants, or
        DO variables of this data-implied-do or the containing data-implied-dos, and each operation shall
        be intrinsic.

R535    data-stmt-value               is    [ data-stmt-repeat * ] data-stmt-constant

R536    data-stmt-repeat              is    scalar-int-constant

                                      or scalar-int-constant-subobject

C570    (R536) The data-stmt-repeat shall be positive or zero. If the data-stmt-repeat is a named con-
        stant, it shall have been declared previously in the scoping unit or made accessible by use
        association or host association.

R537    data-stmt-constant            is    scalar-constant

                                      or scalar-constant-subobject

                                      or signed-int-literal-constant

                                      or signed-real-literal-constant

                                      or null-init

                                      or structure-constructor

C571    (R537) If a DATA statement constant value is a named constant or a structure constructor, the
        named constant or derived type shall have been declared previously in the scoping unit or made
        accessible by use or host association.

C572    (R537) If a data-stmt-constant is a structure-constructor , it shall be an initialization expression.

R538    int-constant-subobject        is    constant-subobject

C573    (R538) int-constant-subobject shall be of type integer.

R539    constant-subobject            is    designator

C574    (R539) constant-subobject shall be a subobject of a constant.

C575    (R539) Any subscript, substring starting point, or substring ending point shall be an initializa-
        tion expression.

R540    dimension-stmt                is    DIMENSION [ :: ] array-name ( array-spec )

                                              [ , array-name ( array-spec ) ] ...

R541    intent-stmt                   is    INTENT ( intent-spec ) [ :: ] dummy-arg-name-list

R542    optional-stmt                 is    OPTIONAL [ :: ] dummy-arg-name-list

R543    parameter-stmt                is    PARAMETER ( named-constant-def -list )

R544    named-constant-def            is    named-constant = initialization-expr

R545    pointer-stmt                  is    POINTER [ :: ] pointer-decl -list



SEP 2002                                     WORKING DRAFT                                              507


J3/02-007R3                                WORKING DRAFT                                        SEP 2002



R546    pointer-decl                 is    object-name [ ( deferred-shape-spec-list ) ]

                                     or proc-entity-name

C576    (R546) A proc-entity-name shall also be declared in a procedure-declaration-stmt .

R547    protected-stmt               is    PROTECTED [ :: ] entity-name-list

R548    save-stmt                    is    SAVE [ [ :: ] saved-entity-list ]

R549    saved-entity                 is    object-name

                                     or proc-pointer-name

                                     or / common-block-name /

R550    proc-pointer-name            is    name

C577    (R550) A proc-pointer-name shall be the name of a procedure pointer.

C578    (R548) If a SAVE statement with an omitted saved entity list occurs in a scoping unit, no other
        explicit occurrence of the SAVE attribute or SAVE statement is permitted in the same scoping
        unit.

R551    target-stmt                  is    TARGET [ :: ] object-name [ ( array-spec ) ]

                                             [ , object-name [ ( array-spec ) ] ] ...

R552    value-stmt                   is    VALUE [ :: ] dummy-arg-name-list

R553    volatile-stmt                is    VOLATILE [ :: ] object-name-list

R554    implicit-stmt                is    IMPLICIT implicit-spec-list

                                     or IMPLICIT NONE

R555    implicit-spec                is    declaration-type-spec ( letter-spec-list )

R556    letter-spec                  is    letter [ � letter ]

C579    (R554) If IMPLICIT NONE is specified in a scoping unit, it shall precede any PARAMETER
        statements that appear in the scoping unit and there shall be no other IMPLICIT statements
        in the scoping unit.

C580    (R556) If the minus and second letter appear, the second letter shall follow the first letter
        alphabetically.

R557    namelist-stmt                is    NAMELIST

                                             / namelist-group-name / namelist-group-object -list

                                             [ [ , ] / namelist-group-name /

                                             namelist-group-object -list ] . . .

C581    (R557) The namelist-group-name shall not be a name made accessible by use association.

R558    namelist-group-object        is    variable-name

C582    (R558) A namelist-group-object shall not be an assumed-size array.

C583    (R557) A namelist-group-object shall not have the PRIVATE attribute if the namelist-group-
        name has the PUBLIC attribute.

R559    equivalence-stmt             is    EQUIVALENCE equivalence-set -list

R560    equivalence-set              is    ( equivalence-object , equivalence-object -list )

R561    equivalence-object           is    variable-name

                                     or array-element

                                     or substring

C584    (R561) An equivalence-object shall not be a designator with a base object that is a dummy
        argument, a pointer, an allocatable variable, a derived-type object that has an allocatable ulti-
        mate component, an object of a nonsequence derived type, an object of a derived type that has
        a pointer at any level of component selection, an automatic object, a function name, an entry
        name, a result name, a variable with the BIND attribute, a variable in a common block that
        has the BIND attribute, or a named constant.

C585    (R561) An equivalence-object shall not be a designator that has more than one part-ref .

C586    (R561) An equivalence-object shall not have the TARGET attribute.



508                                WORKING DRAFT                                                SEP 2002


SEP 2002                                WORKING DRAFT                                           J3/02-007R3



C587    (R561) Each subscript or substring range expression in an equivalence-object shall be an integer
        initialization expression (7.1.7).

C588    (R560) If an equivalence-object is of type default integer, default real, double precision real,
        default complex, default logical, or numeric sequence type, all of the objects in the equivalence
        set shall be of these types.

C589    (R560) If an equivalence-object is of type default character or character sequence type, all of the
        objects in the equivalence set shall be of these types.

C590    (R560) If an equivalence-object is of a sequence derived type that is not a numeric sequence or
        character sequence type, all of the objects in the equivalence set shall be of the same type with
        the same type parameter values.

C591    (R560) If an equivalence-object is of an intrinsic type other than default integer, default real,
        double precision real, default complex, default logical, or default character, all of the objects in
        the equivalence set shall be of the same type with the same kind type parameter value.

C592    (R561) If an equivalence-object has the PROTECTED attribute, all of the objects in the equiv-
        alence set shall have the PROTECTED attribute.

C593    (R561) The name of an equivalence-object shall not be a name made accessible by use association.

C594    (R561) A substring shall not have length zero.

R562    common-stmt                     is    COMMON

                                                [ / [ common-block-name ] / ] common-block-object -list

                                                [ [ , ] / [ common-block-name ] /

                                                common-block-object -list ] ...

R563    common-block-object             is    variable-name [ ( explicit-shape-spec-list ) ]

                                        or proc-pointer-name

C595    (R563) Only one appearance of a given variable-name or proc-pointer-name is permitted in all
        common-block-object -list s within a scoping unit.

C596    (R563) A common-block-object shall not be a dummy argument, an allocatable variable, a
        derived-type object with an ultimate component that is allocatable, an automatic object, a
        function name, an entry name, a variable with the BIND attribute, or a result name.

C597    (R563) If a common-block-object is of a derived type, it shall be a sequence type (4.5.1) with no
        default initialization.

C598    (R563) A variable-name or proc-pointer-name shall not be a name made accessible by use
        association.

Section 6:
R601    variable                        is    designator

C601    (R601) designator shall not be a constant or a subobject of a constant.

R602    variable-name                   is    name

C602    (R602) A variable-name shall be the name of a variable.

R603    designator                      is    object-name

                                        or array-element

                                        or array-section

                                        or structure-component

                                        or substring

R604    logical-variable                is    variable

C603    (R604) logical-variable shall be of type logical.

R605    default-logical-variable        is    variable

C604    (R605) default-logical-variable shall be of type default logical.

R606    char-variable                   is    variable

C605    (R606) char-variable shall be of type character.




SEP 2002                                       WORKING DRAFT                                               509


J3/02-007R3                                   WORKING DRAFT                                  SEP 2002



R607    default-char-variable           is    variable

C606    (R607) default-char-variable shall be of type default character.

R608    int-variable                    is    variable

C607    (R608) int-variable shall be of type integer.

R609    substring                       is    parent-string ( substring-range )

R610    parent-string                   is    scalar-variable-name

                                        or array-element

                                        or scalar-structure-component

                                        or scalar-constant

R611    substring-range                 is    [ scalar-int-expr ] : [ scalar-int-expr ]

C608    (R610) parent-string shall be of type character.

R612    data-ref                        is    part-ref [ % part-ref ] ...

R613    part-ref                        is    part-name [ ( section-subscript -list ) ]

C609    (R612) In a data-ref , each part-name except the rightmost shall be of derived type.

C610    (R612) In a data-ref , each part-name except the leftmost shall be the name of a component of
        the derived-type definition of the declared type of the preceding part-name.

C611    (R612) The leftmost part-name shall be the name of a data object.

C612    (R613) In a part-ref containing a section-subscript -list, the number of section-subscript s shall
        equal the rank of part-name.

C613    (R612) In a data-ref , there shall not be more than one part-ref with nonzero rank. A part-name
        to the right of a part-ref with nonzero rank shall not have the ALLOCATABLE or POINTER
        attribute.

R614    structure-component             is    data-ref

C614    (R614) In a structure-component , there shall be more than one part-ref and the rightmost
        part-ref shall be of the form part-name.

R615    type-param-inquiry              is    designator % type-param-name

C615    (R615) The type-param-name shall be the name of a type parameter of the declared type of the
        object designated by the designator .

R616    array-element                   is    data-ref

C616    (R616) In an array-element , every part-ref shall have rank zero and the last part-ref shall
        contain a subscript -list.

R617    array-section                   is    data-ref [ ( substring-range ) ]

C617    (R617) In an array-section, exactly one part-ref shall have nonzero rank, and either the final
        part-ref shall have a section-subscript -list with nonzero rank or another part-ref shall have
        nonzero rank.

C618    (R617) In an array-section with a substring-range, the rightmost part-name shall be of type
        character.

R618    subscript                       is    scalar-int-expr

R619    section-subscript               is    subscript

                                        or subscript-triplet

                                        or vector-subscript

R620    subscript-triplet               is    [ subscript ] : [ subscript ] [ : stride ]

R621    stride                          is    scalar-int-expr

R622    vector-subscript                is    int-expr

C619    (R622) A vector-subscript shall be an integer array expression of rank one.

C620    (R620) The second subscript shall not be omitted from a subscript-triplet in the last dimension
        of an assumed-size array.

R623    allocate-stmt                   is    ALLOCATE ( [ type-spec :: ] allocation-list



510                                   WORKING DRAFT                                          SEP 2002


SEP 2002                               WORKING DRAFT                                             J3/02-007R3



                                               [, alloc-opt -list ] )

R624    alloc-opt                      is    STAT = stat-variable

                                       or ERRMSG = errmsg-variable

                                       or SOURCE = source-variable

R625    stat-variable                  is    scalar-int-variable

R626    errmsg-variable                is    scalar-default-char-variable

R627    allocation                     is    allocate-object [ ( allocate-shape-spec-list ) ]

R628    allocate-object                is    variable-name

                                       or structure-component

R629    allocate-shape-spec            is    [ allocate-lower-bound : ] allocate-upper-bound

R630    allocate-lower-bound           is    scalar-int-expr

R631    allocate-upper-bound           is    scalar-int-expr

R632    source-variable                is    variable

C621    (R628) Each allocate-object shall be a nonprocedure pointer or an allocatable variable.

C622    (R623) If any allocate-object in the statement has a deferred type parameter, either type-spec or
        SOURCE= shall appear.

C623    (R623) If a type-spec appears, it shall specify a type with which each allocate-object is type
        compatible.

C624    (R623) If any allocate-object is unlimited polymorphic, either type-spec or SOURCE= shall
        appear.

C625    (R623) A type-param-value in a type-spec shall be an asterisk if and only if each allocate-object
        is a dummy argument for which the corresponding type parameter is assumed.

C626    (R623) If a type-spec appears, the kind type parameter values of each allocate-object shall be
        the same as the corresponding type parameter values of the type-spec.

C627    (R627) An allocate-shape-spec-list shall appear if and only if the allocate-object is an array.

C628    (R627) The number of allocate-shape-specs in an allocate-shape-spec-list shall be the same as
        the rank of the allocate-object .

C629    (R624) No alloc-opt shall appear more than once in a given alloc-opt -list.

C630    (R623) If SOURCE= appears, type-spec shall not appear and allocation-list shall contain only
        one allocate-object , which shall be type compatible (5.1.1.8) with source-variable.

C631    (R623) The source-variable shall be a scalar or have the same rank as allocate-object .

C632    (R623) Corresponding kind type parameters of allocate-object and source-variable shall have the
        same values.

R633    nullify-stmt                   is    NULLIFY ( pointer-object -list )

R634    pointer-object                 is    variable-name

                                       or structure-component

                                       or proc-pointer-name

C633    (R634) Each pointer-object shall have the POINTER attribute.

R635    deallocate-stmt                is    DEALLOCATE ( allocate-object -list [ , dealloc-opt -list ] )

C634    (R635) Each allocate-object shall be a nonprocedure pointer or an allocatable variable.

R636    dealloc-opt                    is    STAT = stat-variable

                                       or ERRMSG = errmsg-variable

C635    (R636) No dealloc-opt shall appear more than once in a given dealloc-opt -list.

Section 7:
R701    primary                        is    constant

                                       or designator

                                       or array-constructor




SEP 2002                                      WORKING DRAFT                                             511


J3/02-007R3                                  WORKING DRAFT                              SEP 2002



                                       or structure-constructor

                                       or function-reference

                                       or type-param-inquiry

                                       or type-param-name

                                       or ( expr )

C701    (R701) The type-param-name shall be the name of a type parameter.

C702    (R701) The designator shall not be a whole assumed-size array.

R702    level-1-expr                   is    [ defined-unary-op ] primary

R703    defined-unary-op                is    . letter [ letter ] ... .

C703    (R703) A defined-unary-op shall not contain more than 63 letters and shall not be the same as
        any intrinsic-operator or logical-literal-constant .

R704    mult-operand                   is    level-1-expr [ power-op mult-operand ]

R705    add-operand                    is    [ add-operand mult-op ] mult-operand

R706    level-2-expr                   is    [ [ level-2-expr ] add-op ] add-operand

R707    power-op                       is    **

R708    mult-op                        is    *

                                       or /

R709    add-op                         is    +

                                       or �

R710    level-3-expr                   is    [ level-3-expr concat-op ] level-2-expr

R711    concat-op                      is    //

R712    level-4-expr                   is    [ level-3-expr rel-op ] level-3-expr

R713    rel-op                         is    .EQ.

                                       or .NE.

                                       or .LT.

                                       or .LE.

                                       or .GT.

                                       or .GE.

                                       or ==

                                       or /=

                                       or <

                                       or <=

                                       or >

                                       or >=

R714    and-operand                    is    [ not-op ] level-4-expr

R715    or-operand                     is    [ or-operand and-op ] and-operand

R716    equiv-operand                  is    [ equiv-operand or-op ] or-operand

R717    level-5-expr                   is    [ level-5-expr equiv-op ] equiv-operand

R718    not-op                         is    .NOT.

R719    and-op                         is    .AND.

R720    or-op                          is    .OR.

R721    equiv-op                       is    .EQV.

                                       or .NEQV.

R722    expr                           is    [ expr defined-binary-op ] level-5-expr

R723    defined-binary-op               is    . letter [ letter ] ... .

C704    (R723) A defined-binary-op shall not contain more than 63 letters and shall not be the same as
        any intrinsic-operator or logical-literal-constant .



512                                  WORKING DRAFT                                      SEP 2002


SEP 2002                                 WORKING DRAFT                                        J3/02-007R3



R724    logical-expr                     is    expr

C705    (R724) logical-expr shall be of type logical.

R725    char-expr                        is    expr

C706    (R725) char-expr shall be of type character.

R726    default-char-expr                is    expr

C707    (R726) default-char-expr shall be of type default character.

R727    int-expr                         is    expr

C708    (R727) int-expr shall be of type integer.

R728    numeric-expr                     is    expr

C709    (R728) numeric-expr shall be of type integer, real, or complex.

R729    specification-expr                is    scalar-int-expr

C710    (R729) The scalar-int-expr shall be a restricted expression.

R730    initialization-expr              is    expr

C711    (R730) initialization-expr shall be an initialization expression.

R731    char-initialization-expr         is    char-expr

C712    (R731) char-initialization-expr shall be an initialization expression.

R732    int-initialization-expr          is    int-expr

C713    (R732) int-initialization-expr shall be an initialization expression.

R733    logical-initialization-expr      is    logical-expr

C714    (R733) logical-initialization-expr shall be an initialization expression.

R734    assignment-stmt                  is    variable = expr

C715    (R734) The variable in an assignment-stmt shall not be a whole assumed-size array.

R735    pointer-assignment-stmt          is    data-pointer-object [ (bounds-spec-list ) ] => data-target

                                         or data-pointer-object (bounds-remapping-list ) => data-target

                                         or proc-pointer-object => proc-target

R736    data-pointer-object              is    variable-name

                                         or variable % data-pointer-component-name

C716    (R735) If data-target is polymorphic (5.1.1.8), data-pointer-object shall be polymorphic.

C717    (R735) A data-pointer-object shall be type compatible (5.1.1.8) with data-target , and the corre-
        sponding kind type parameters shall be equal.

C718    (R735) If bounds-spec-list is specified, the number of bounds-specs shall equal the rank of data-
        pointer-object .

C719    (R735) If bounds-remapping-list is specified, the number of bounds-remappings shall equal the
        rank of data-pointer-object .

C720    (R735) If bounds-remapping-list is specified, data-target shall have rank one; otherwise, the
        ranks of data-pointer-object and data-target shall be the same.

C721    (R736) A variable-name shall have the POINTER attribute.

C722    (R736) A data-pointer-component-name shall be the name of a component of variable that is a
        data pointer.

R737    bounds-spec                      is    lower-bound :

R738    bounds-remapping                 is    lower-bound : upper-bound

R739    data-target                      is    variable

                                         or expr

C723    (R739) A variable shall have either the TARGET or POINTER attribute, and shall not be an
        array section with a vector subscript.

C724    (R739) An expr shall be a reference to a function whose result is a data pointer.

R740    proc-pointer-object              is    proc-pointer-name




SEP 2002                                        WORKING DRAFT                                                513


J3/02-007R3                                 WORKING DRAFT                                        SEP 2002



                                      or variable % procedure-component-name

C725    (R740) A procedure-component-name shall be the name of a procedure pointer component of
        variable.

R741    proc-target                   is    expr

                                      or procedure-name

C726    (R741) An expr shall be a reference to a function whose result is a procedure pointer.

C727    (R741) A procedure-name shall be the name of an external, module, or dummy procedure, a
        specific intrinsic function listed in 13.6 and not marked with a bullet (�), or a procedure pointer.

C728    (R741) The proc-target shall not be a nonintrinsic elemental procedure.

R742    where-stmt                    is    WHERE ( mask-expr ) where-assignment-stmt

R743    where-construct               is    where-construct-stmt

                                                       [ where-body-construct ] ...

                                                [ masked-elsewhere-stmt

                                                       [ where-body-construct ] ... ] ...

                                                [ elsewhere-stmt

                                                       [ where-body-construct ] ... ]

                                                end-where-stmt

R744    where-construct-stmt          is    [where-construct-name:] WHERE ( mask-expr )

R745    where-body-construct          is    where-assignment-stmt

                                      or where-stmt

                                      or where-construct

R746    where-assignment-stmt         is    assignment-stmt

R747    mask-expr                     is    logical-expr

R748    masked-elsewhere-stmt         is    ELSEWHERE (mask-expr ) [where-construct-name]

R749    elsewhere-stmt                is    ELSEWHERE [where-construct-name]

R750    end-where-stmt                is    END WHERE [where-construct-name]

C729    (R746) A where-assignment-stmt that is a defined assignment shall be elemental.

C730    (R743) If the where-construct-stmt is identified by a where-construct-name, the corresponding
        end-where-stmt shall specify the same where-construct-name. If the where-construct-stmt is
        not identified by a where-construct-name, the corresponding end-where-stmt shall not specify
        a where-construct-name. If an elsewhere-stmt or a masked-elsewhere-stmt is identified by a
        where-construct-name, the corresponding where-construct-stmt shall specify the same where-
        construct-name.

C731    (R745) A statement that is part of a where-body-construct shall not be a branch target statement.

R751    forall-construct              is    forall-construct-stmt

                                                    [forall-body-construct ] ...

                                                    end-forall-stmt

R752    forall-construct-stmt         is    [forall-construct-name :] FORALL forall-header

R753    forall-header                 is    (forall-triplet-spec-list [, scalar-mask-expr ] )

R754    forall-triplet-spec           is    index-name = subscript : subscript [ : stride]

R755    forall-body-construct         is    forall-assignment-stmt

                                      or where-stmt

                                      or where-construct

                                      or forall-construct

                                      or forall-stmt

R756    forall-assignment-stmt        is    assignment-stmt

                                      or pointer-assignment-stmt




514                                 WORKING DRAFT                                                SEP 2002


SEP 2002                              WORKING DRAFT                                      J3/02-007R3



R757    end-forall-stmt               is    END FORALL [forall-construct-name ]

C732    (R757) If the forall-construct-stmt has a forall-construct-name, the end-forall-stmt shall have
        the same forall-construct-name. If the end-forall-stmt has a forall-construct-name, the forall-
        construct-stmt shall have the same forall-construct-name.

C733    (R753) The scalar-mask-expr shall be scalar and of type logical.

C734    (R753) Any procedure referenced in the scalar-mask-expr , including one referenced by a defined
        operation, shall be a pure procedure (12.6).

C735    (R754) The index-name shall be a named scalar variable of type integer.

C736    (R754) A subscript or stride in a forall-triplet-spec shall not contain a reference to any index-
        name in the forall-triplet-spec-list in which it appears.

C737    (R755) A statement in a forall-body-construct shall not define an index-name of the forall-
        construct .

C738    (R755) Any procedure referenced in a forall-body-construct , including one referenced by a defined
        operation, assignment, or finalization, shall be a pure procedure.

C739    (R755) A forall-body-construct shall not be a branch target.

R758    forall-stmt                   is    FORALL forall-header forall-assignment-stmt

Section 8:
R801    block                         is    [ execution-part-construct ] ...

R802    if-construct                  is    if-then-stmt

                                                    block

                                                [ else-if-stmt

                                                    block ] ...

                                                [ else-stmt

                                                    block ]

                                                end-if-stmt

R803    if-then-stmt                  is    [ if-construct-name : ] IF ( scalar-logical-expr ) THEN

R804    else-if-stmt                  is    ELSE IF ( scalar-logical-expr ) THEN [ if-construct-name ]

R805    else-stmt                     is    ELSE [ if-construct-name ]

R806    end-if-stmt                   is    END IF [ if-construct-name ]

C801    (R802) If the if-then-stmt of an if-construct specifies an if-construct-name, the corresponding
        end-if-stmt shall specify the same if-construct-name. If the if-then-stmt of an if-construct does
        not specify an if-construct-name, the corresponding end-if-stmt shall not specify an if-construct-
        name. If an else-if-stmt or else-stmt specifies an if-construct-name, the corresponding if-then-
        stmt shall specify the same if-construct-name.

R807    if-stmt                       is    IF ( scalar-logical-expr ) action-stmt

C802    (R807) The action-stmt in the if-stmt shall not be an if-stmt , end-program-stmt , end-function-
        stmt , or end-subroutine-stmt .

R808    case-construct                is    select-case-stmt

                                                [ case-stmt

                                                    block ] ...

                                                end-select-stmt

R809    select-case-stmt              is    [ case-construct-name : ] SELECT CASE ( case-expr )

R810    case-stmt                     is    CASE case-selector [case-construct-name]

R811    end-select-stmt               is    END SELECT [ case-construct-name ]

C803    (R808) If the select-case-stmt of a case-construct specifies a case-construct-name, the corre-
        sponding end-select-stmt shall specify the same case-construct-name. If the select-case-stmt
        of a case-construct does not specify a case-construct-name, the corresponding end-select-stmt
        shall not specify a case-construct-name. If a case-stmt specifies a case-construct-name, the




SEP 2002                                     WORKING DRAFT                                             515


J3/02-007R3                                WORKING DRAFT                                    SEP 2002



        corresponding select-case-stmt shall specify the same case-construct-name.

R812    case-expr                    is    scalar-int-expr

                                     or scalar-char-expr

                                     or scalar-logical-expr

R813    case-selector                is    ( case-value-range-list )

                                     or DEFAULT

C804    (R808) No more than one of the selectors of one of the CASE statements shall be DEFAULT.

R814    case-value-range             is    case-value

                                     or case-value :

                                     or : case-value

                                     or case-value : case-value

R815    case-value                   is    scalar-int-initialization-expr

                                     or scalar-char-initialization-expr

                                     or scalar-logical-initialization-expr

C805    (R808) For a given case-construct , each case-value shall be of the same type as case-expr . For
        character type, the kind type parameters shall be the same; character length differences are
        allowed.

C806    (R808) A case-value-range using a colon shall not be used if case-expr is of type logical.

C807    (R808) For a given case-construct , the case-value-ranges shall not overlap; that is, there shall
        be no possible value of the case-expr that matches more than one case-value-range.

R816    associate-construct          is    associate-stmt

                                               block

                                               end-associate-stmt

R817    associate-stmt               is    [ associate-construct-name : ] ASSOCIATE

                                             (association-list )

R818    association                  is    associate-name => selector

R819    selector                     is    expr

                                     or variable

C808    (R818) If selector is not a variable or is a variable that has a vector subscript, associate-name
        shall not appear in a variable definition context (16.5.7).

R820    end-associate-stmt           is    END ASSOCIATE [ associate-construct-name ]

C809    (R820) If the associate-stmt of an associate-construct specifies an associate-construct-name,
        the corresponding end-associate-stmt shall specify the same associate-construct-name. If the
        associate-stmt of an associate-construct does not specify an associate-construct-name, the cor-
        responding end-associate-stmt shall not specify an associate-construct-name.

R821    select-type-construct        is    select-type-stmt

                                               [ type-guard-stmt

                                                    block ] ...

                                               end-select-type-stmt

R822    select-type-stmt             is    [ select-construct-name : ] SELECT TYPE

                                             ( [ associate-name => ] selector )

C810    (R822) If selector is not a named variable, associate-name => shall appear.

C811    (R822) If selector is not a variable or is a variable that has a vector subscript, associate-name
        shall not appear in a variable definition context (16.5.7).

C812    (R822) The selector in a select-type-stmt shall be polymorphic.

R823    type-guard-stmt              is    TYPE IS ( extensible-type-name ) [ select-construct-name ]

                                     or CLASS IS ( extensible-type-name ) [ select-construct-name ]




516                                WORKING DRAFT                                            SEP 2002


SEP 2002                                WORKING DRAFT                                          J3/02-007R3



                                        or CLASS DEFAULT [ select-construct-name ]

C813    (R823) If selector is not unlimited polymorphic, the extensible-type-name shall be the name of
        an extension of the declared type of selector .

C814    (R823) For a given select-type-construct , the same extensible-type-name shall not be specified in
        more than one TYPE IS type-guard-stmt and shall not be specified in more than one CLASS IS
        type-guard-stmt .

C815    (R823) For a given select-type-construct , there shall be at most one CLASS DEFAULT type-
        guard-stmt .

R824    end-select-type-stmt            is    END SELECT [ select-construct-name ]

C816    (R821) If the select-type-stmt of a select-type-construct specifies a select-construct-name, the
        corresponding end-select-type-stmt shall specify the same select-construct-name. If the select-
        type-stmt of a select-type-construct does not specify a select-construct-name, the corresponding
        end-select-type-stmt shall not specify a select-construct-name. If a type-guard-stmt specifies a
        select-construct-name, the corresponding select-type-stmt shall specify the same select-construct-
        name.

R825    do-construct                    is    block-do-construct

                                        or nonblock-do-construct

R826    block-do-construct              is    do-stmt

                                                  do-block

                                                  end-do

R827    do-stmt                         is    label-do-stmt

                                        or nonlabel-do-stmt

R828    label-do-stmt                   is    [ do-construct-name : ] DO label [ loop-control ]

R829    nonlabel-do-stmt                is    [ do-construct-name : ] DO [ loop-control ]

R830    loop-control                    is    [ , ] do-variable = scalar-int-expr , scalar-int-expr

                                                [ , scalar-int-expr ]

                                        or [ , ] WHILE ( scalar-logical-expr )

R831    do-variable                     is    scalar-int-variable

C817    (R831) The do-variable shall be a named scalar variable of type integer.

R832    do-block                        is    block

R833    end-do                          is    end-do-stmt

                                        or continue-stmt

R834    end-do-stmt                     is    END DO [ do-construct-name ]

C818    (R826) If the do-stmt of a block-do-construct specifies a do-construct-name, the corresponding
        end-do shall be an end-do-stmt specifying the same do-construct-name. If the do-stmt of a
        block-do-construct does not specify a do-construct-name, the corresponding end-do shall not
        specify a do-construct-name.

C819    (R826) If the do-stmt is a nonlabel-do-stmt , the corresponding end-do shall be an end-do-stmt .

C820    (R826) If the do-stmt is a label-do-stmt , the corresponding end-do shall be identified with the
        same label .

R835    nonblock-do-construct           is    action-term-do-construct

                                        or outer-shared-do-construct

R836    action-term-do-construct        is    label-do-stmt

                                                  do-body

                                                  do-term-action-stmt

R837    do-body                         is    [ execution-part-construct ] ...

R838    do-term-action-stmt             is    action-stmt

C821    (R838) A do-term-action-stmt shall not be a continue-stmt , a goto-stmt , a return-stmt , a stop-




SEP 2002                                        WORKING DRAFT                                          517


J3/02-007R3                                  WORKING DRAFT                                       SEP 2002



        stmt , an exit-stmt , a cycle-stmt , an end-function-stmt , an end-subroutine-stmt , an end-program-
        stmt , or an arithmetic-if-stmt .

C822    (R835) The do-term-action-stmt shall be identified with a label and the corresponding label-do-
        stmt shall refer to the same label.

R839    outer-shared-do-construct      is    label-do-stmt

                                                 do-body

                                                 shared-term-do-construct

R840    shared-term-do-construct       is    outer-shared-do-construct

                                       or inner-shared-do-construct

R841    inner-shared-do-construct      is    label-do-stmt

                                                 do-body

                                                 do-term-shared-stmt

R842    do-term-shared-stmt            is    action-stmt

C823    (R842) A do-term-shared-stmt shall not be a goto-stmt , a return-stmt , a stop-stmt , an exit-
        stmt , a cycle-stmt , an end-function-stmt , an end-subroutine-stmt , an end-program-stmt , or an
        arithmetic-if-stmt .

C824    (R840) The do-term-shared-stmt shall be identified with a label and all of the label-do-stmt s of
        the shared-term-do-construct shall refer to the same label.

R843    cycle-stmt                     is    CYCLE [ do-construct-name ]

C825    (R843) If a cycle-stmt refers to a do-construct-name, it shall be within the range of that do-
        construct ; otherwise, it shall be within the range of at least one do-construct .

R844    exit-stmt                      is    EXIT [ do-construct-name ]

C826    (R844) If an exit-stmt refers to a do-construct-name, it shall be within the range of that do-
        construct ; otherwise, it shall be within the range of at least one do-construct .

R845    goto-stmt                      is    GO TO label

C827    (R845) The label shall be the statement label of a branch target statement that appears in the
        same scoping unit as the goto-stmt .

R846    computed-goto-stmt             is    GO TO ( label -list ) [ , ] scalar-int-expr

C828    (R846 Each label in label -list shall be the statement label of a branch target statement that
        appears in the same scoping unit as the computed-goto-stmt .

R847    arithmetic-if-stmt             is    IF ( scalar-numeric-expr ) label , label , label

C829    (R847) Each label shall be the label of a branch target statement that appears in the same
        scoping unit as the arithmetic-if-stmt .

C830    (R847) The scalar-numeric-expr shall not be of type complex.

R848    continue-stmt                  is    CONTINUE

R849    stop-stmt                      is    STOP [ stop-code ]

R850    stop-code                      is    scalar-char-constant

                                       or digit [ digit [ digit [ digit [ digit ] ] ] ]

C831    (R850) scalar-char-constant shall be of type default character.

Section 9:
R901    io-unit                        is    file-unit-number

                                       or *

                                       or internal-file-variable

R902    file-unit-number                is    scalar-int-expr

R903    internal-file-variable          is    default-char-variable

C901    (R903) The default-char-variable shall not be an array section with a vector subscript.

R904    open-stmt                      is    OPEN ( connect-spec-list )




518                                  WORKING DRAFT                                               SEP 2002


SEP 2002                             WORKING DRAFT                                        J3/02-007R3



R905    connect-spec                 is    [ UNIT = ] file-unit-number

                                     or ACCESS = scalar-default-char-expr

                                     or ACTION = scalar-default-char-expr

                                     or ASYNCHRONOUS = scalar-default-char-expr

                                     or BLANK = scalar-default-char-expr

                                     or DECIMAL = scalar-default-char-expr

                                     or DELIM = scalar-default-char-expr

                                     or ERR = label

                                     or FILE = file-name-expr

                                     or FORM = scalar-default-char-expr

                                     or IOMSG = iomsg-variable

                                     or IOSTAT = scalar-int-variable

                                     or PAD = scalar-default-char-expr

                                     or POSITION = scalar-default-char-expr

                                     or RECL = scalar-int-expr

                                     or ROUND = scalar-default-char-expr

                                     or SIGN = scalar-default-char-expr

                                     or STATUS = scalar-default-char-expr

R906    file-name-expr                is    scalar-default-char-expr

R907    iomsg-variable               is    scalar-default-char-variable

C902    (R905) No specifier shall appear more than once in a given connect-spec-list.

C903    (R905) A file-unit-number shall be specified; if the optional characters UNIT= are omitted, the
        file-unit-number shall be the first item in the connect-spec-list.

C904    (R905) The label used in the ERR= specifier shall be the statement label of a branch target
        statement that appears in the same scoping unit as the OPEN statement.

R908    close-stmt                   is    CLOSE ( close-spec-list )

R909    close-spec                   is    [ UNIT = ] file-unit-number

                                     or IOSTAT = scalar-int-variable

                                     or IOMSG = iomsg-variable

                                     or ERR = label

                                     or STATUS = scalar-default-char-expr

C905    (R909) No specifier shall appear more than once in a given close-spec-list.

C906    (R909) A file-unit-number shall be specified; if the optional characters UNIT= are omitted, the
        file-unit-number shall be the first item in the close-spec-list.

C907    (R909) The label used in the ERR= specifier shall be the statement label of a branch target
        statement that appears in the same scoping unit as the CLOSE statement.

R910    read-stmt                    is    READ ( io-control-spec-list ) [ input-item-list ]

                                     or READ format [ , input-item-list ]

R911    write-stmt                   is    WRITE ( io-control-spec-list ) [ output-item-list ]

R912    print-stmt                   is    PRINT format [ , output-item-list ]

R913    io-control-spec              is    [ UNIT = ] io-unit

                                     or [ FMT = ] format

                                     or [ NML = ] namelist-group-name

                                     or ADVANCE = scalar-default-char-expr

                                     or ASYNCHRONOUS = scalar-char-initialization-expr

                                     or BLANK = scalar-default-char-expr

                                     or DECIMAL = scalar-default-char-expr



SEP 2002                                    WORKING DRAFT                                         519


J3/02-007R3                                WORKING DRAFT                                   SEP 2002



                                      or DELIM = scalar-default-char-expr

                                      or END = label

                                      or EOR = label

                                      or ERR = label

                                      or ID = scalar-int-variable

                                      or IOMSG = iomsg-variable

                                      or IOSTAT = scalar-int-variable

                                      or PAD = scalar-default-char-expr

                                      or POS = scalar-int-expr

                                      or REC = scalar-int-expr

                                      or ROUND = scalar-default-char-expr

                                      or SIGN = scalar-default-char-expr

                                      or SIZE = scalar-int-variable

C908    (R913) No specifier shall appear more than once in a given io-control-spec-list.

C909    (R913) An io-unit shall be specified; if the optional characters UNIT= are omitted, the io-unit
        shall be the first item in the io-control-spec-list.

C910    (R913) A DELIM= or SIGN= specifier shall not appear in a read-stmt .

C911    (R913) A BLANK=, PAD=, END=, EOR=, or SIZE= specifier shall not appear in a write-stmt .

C912    (R913) The label in the ERR=, EOR=, or END= specifier shall be the statement label of a
        branch target statement that appears in the same scoping unit as the data transfer statement.

C913    (R913) A namelist-group-name shall be the name of a namelist group.

C914    (R913) A namelist-group-name shall not appear if an input-item-list or an output-item-list
        appears in the data transfer statement.

C915    (R913) An io-control-spec-list shall not contain both a format and a namelist-group-name.

C916    (R913) If format appears without a preceding FMT=, it shall be the second item in the io-
        control-spec-list and the first item shall be io-unit .

C917    (R913) If namelist-group-name appears without a preceding NML=, it shall be the second item
        in the io-control-spec-list and the first item shall be io-unit .

C918    (R913) If io-unit is not a file-unit-number , the io-control-spec-list shall not contain a REC=
        specifier or a POS= specifier.

C919    (R913) If the REC= specifier appears, an END= specifier shall not appear, a namelist-group-
        name shall not appear, and the format , if any, shall not be an asterisk.

C920    (R913) An ADVANCE= specifier may appear only in a formatted sequential or stream in-
        put/output statement with explicit format specification (10.1) whose control information list
        does not contain an internal-file-variable as the io-unit .

C921    (R913) If an EOR= specifier appears, an ADVANCE= specifier also shall appear.

C922    (R913) If a SIZE= specifier appears, an ADVANCE= specifier also shall appear.

C923    (R913) The scalar-char-initialization-expr in an ASYNCHRONOUS= specifier shall be of type
        default character and shall have the value YES or NO.

C924    (R913) An ASYNCHRONOUS= specifier with a value YES shall not appear unless io-unit is a
        file-unit-number .

C925    (R913) If an ID= specifier appears, an ASYNCHRONOUS= specifier with the value YES shall
        also appear.

C926    (R913) If a POS= specifier appears, the io-control-spec-list shall not contain a REC= specifier.

C927    (R913) If a DECIMAL=, BLANK=, PAD=, SIGN=, or ROUND= specifier appears, a format
        or namelist-group-name shall also appear.

C928    (R913) If a DELIM= specifier appears, either format shall be an asterisk or namelist-group-name
        shall appear.




520                                 WORKING DRAFT                                          SEP 2002


SEP 2002                              WORKING DRAFT                                          J3/02-007R3



R914    format                        is    default-char-expr

                                      or label

                                      or *

C929    (R914) The label shall be the label of a FORMAT statement that appears in the same scoping
        unit as the statement containing the FMT= specifier.

R915    input-item                    is    variable

                                      or io-implied-do

R916    output-item                   is    expr

                                      or io-implied-do

R917    io-implied-do                 is    ( io-implied-do-object -list , io-implied-do-control )

R918    io-implied-do-object          is    input-item

                                      or output-item

R919    io-implied-do-control         is    do-variable = scalar-int-expr ,

                                              scalar-int-expr [ , scalar-int-expr ]

C930    (R915) A variable that is an input-item shall not be a whole assumed-size array.

C931    (R915) A variable that is an input-item shall not be a procedure pointer.

C932    (R919) The do-variable shall be a named scalar variable of type integer.

C933    (R918) In an input-item-list, an io-implied-do-object shall be an input-item. In an output-item-
        list, an io-implied-do-object shall be an output-item.

C934    (R916) An expression that is an output-item shall not have a value that is a procedure pointer.

R920    dtv-type-spec                 is    TYPE( derived-type-spec )

                                      or CLASS( derived-type-spec )

C935    (R920) If derived-type-spec specifies an extensible type, the CLASS keyword shall be used;
        otherwise, the TYPE keyword shall be used.

C936    (R920) All nonkind type parameters of derived-type-spec shall be assumed.

R921    wait-stmt                     is    WAIT (wait-spec-list )

R922    wait-spec                     is    [ UNIT = ] file-unit-number

                                      or END = label

                                      or EOR = label

                                      or ERR = label

                                      or ID = scalar-int-variable

                                      or IOMSG = iomsg-variable

                                      or IOSTAT = scalar-int-variable

C937    (R922) No specifier shall appear more than once in a given wait-spec-list.

C938    (R922) A file-unit-number shall be specified; if the optional characters UNIT= are omitted, the
        file-unit-number shall be the first item in the wait-spec-list.

C939    (R922) The label in the ERR=, EOR=, or END= specifier shall be the statement label of a
        branch target statement that appears in the same scoping unit as the WAIT statement.

R923    backspace-stmt                is    BACKSPACE file-unit-number

                                      or BACKSPACE ( position-spec-list )

R924    endfile-stmt                   is    ENDFILE file-unit-number

                                      or ENDFILE ( position-spec-list )

R925    rewind-stmt                   is    REWIND file-unit-number

                                      or REWIND ( position-spec-list )

R926    position-spec                 is    [ UNIT = ] file-unit-number

                                      or IOMSG = iomsg-variable

                                      or IOSTAT = scalar-int-variable




SEP 2002                                      WORKING DRAFT                                           521


J3/02-007R3                                WORKING DRAFT                                        SEP 2002



                                     or ERR = label

C940    (R926) No specifier shall appear more than once in a given position-spec-list.

C941    (R926) A file-unit-number shall be specified; if the optional characters UNIT= are omitted, the
        file-unit-number shall be the first item in the position-spec-list.

C942    (R926) The label in the ERR= specifier shall be the statement label of a branch target statement
        that appears in the same scoping unit as the file positioning statement.

R927    flush-stmt                    is    FLUSH file-unit-number

                                     or FLUSH ( flush-spec-list )

R928    flush-spec                    is    [UNIT =] file-unit-number

                                     or IOSTAT = scalar-int-variable

                                     or IOMSG = iomsg-variable

                                     or ERR = label

C943    (R928) No specifier shall appear more than once in a given flush-spec-list.

C944    (R928) A file-unit-number shall be specified; if the optional characters UNIT= are omitted from
        the unit specifier, the file-unit-number shall be the first item in the flush-spec-list.

C945    (R928) The label in the ERR= specifier shall be the statement label of a branch target statement
        that appears in the same scoping unit as the flush statement.

R929    inquire-stmt                 is    INQUIRE ( inquire-spec-list )

                                     or INQUIRE ( IOLENGTH = scalar-int-variable )

                                             output-item-list

R930    inquire-spec                 is    [ UNIT = ] file-unit-number

                                     or FILE = file-name-expr

                                     or ACCESS = scalar-default-char-variable

                                     or ACTION = scalar-default-char-variable

                                     or ASYNCHRONOUS = scalar-default-char-variable

                                     or BLANK = scalar-default-char-variable

                                     or DECIMAL = scalar-default-char-variable

                                     or DELIM = scalar-default-char-variable

                                     or DIRECT = scalar-default-char-variable

                                     or ERR = label

                                     or EXIST = scalar-default-logical-variable

                                     or FORM = scalar-default-char-variable

                                     or FORMATTED = scalar-default-char-variable

                                     or ID = scalar-int-variable

                                     or IOMSG = iomsg-variable

                                     or IOSTAT = scalar-int-variable

                                     or NAME = scalar-default-char-variable

                                     or NAMED = scalar-default-logical-variable

                                     or NEXTREC = scalar-int-variable

                                     or NUMBER = scalar-int-variable

                                     or OPENED = scalar-default-logical-variable

                                     or PAD = scalar-default-char-variable

                                     or PENDING = scalar-default-logical-variable

                                     or POS = scalar-int-variable

                                     or POSITION = scalar-default-char-variable

                                     or READ = scalar-default-char-variable

                                     or READWRITE = scalar-default-char-variable



522                                WORKING DRAFT                                                SEP 2002


SEP 2002                                 WORKING DRAFT                                      J3/02-007R3



                                         or RECL = scalar-int-variable

                                         or ROUND = scalar-default-char-variable

                                         or SEQUENTIAL = scalar-default-char-variable

                                         or SIGN = scalar-default-char-variable

                                         or SIZE = scalar-int-variable

                                         or STREAM = scalar-default-char-variable

                                         or UNFORMATTED = scalar-default-char-variable

                                         or WRITE = scalar-default-char-variable

C946     (R930) No specifier shall appear more than once in a given inquire-spec-list.

C947     (R930) An inquire-spec-list shall contain one FILE= specifier or one UNIT= specifier, but not
         both.

C948     (R930) In the inquire by unit form of the INQUIRE statement, if the optional characters UNIT=
         are omitted, the file-unit-number shall be the first item in the inquire-spec-list.

C949     (R930) If an ID= specifier appears, a PENDING= specifier shall also appear.

Section 10:
R1001 format-stmt                        is    FORMAT format-specification

R1002 format-specification                is    ( [ format-item-list ] )

C1001    (R1001) The format-stmt shall be labeled.

C1002    (R1002) The comma used to separate format-items in a format-item-list may be omitted

R1003 format-item                        is    [ r ] data-edit-desc

                                         or control-edit-desc

                                         or char-string-edit-desc

                                         or [ r ] ( format-item-list )

R1004 r                                  is    int-literal-constant

C1003    (R1004) r shall be positive.

C1004    (R1004) r shall not have a kind parameter specified for it.

R1005 data-edit-desc                     is    I w [ . m ]

                                         or B w [ . m ]

                                         or O w [ . m ]

                                         or Z w [ . m ]

                                         or F w . d

                                         or E w . d [ E e ]

                                         or EN w . d [ E e ]

                                         or ES w . d [ E e ]

                                         or G w . d [ E e ]

                                         or L w

                                         or A [ w ]

                                         or D w . d

                                         or DT [ char-literal-constant ] [ ( v -list ) ]

R1006 w                                  is    int-literal-constant

R1007 m                                  is    int-literal-constant

R1008 d                                  is    int-literal-constant

R1009 e                                  is    int-literal-constant

R1010 v                                  is    signed-int-literal-constant

C1005    (R1009) e shall be positive.

C1006    (R1006) w shall be zero or positive for the I, B, O, Z, and F edit descriptors. w shall be positive




SEP 2002                                        WORKING DRAFT                                          523


J3/02-007R3                                       WORKING DRAFT                                SEP 2002



         for all other edit descriptors.

C1007    (R1005) w , m, d , e, and v shall not have kind parameters specified for them.

C1008    (R1005) The char-literal-constant in the DT edit descriptor shall not have a kind parameter
         specified for it.

R1011 control-edit-desc                     is    position-edit-desc

                                            or [ r ] /

                                            or :

                                            or sign-edit-desc

                                            or k P

                                            or blank-interp-edit-desc

                                            or round-edit-desc

                                            or decimal-edit-desc

R1012 k                                     is    signed-int-literal-constant

C1009    (R1012) k shall not have a kind parameter specified for it.

R1013 position-edit-desc                    is    T n

                                            or TL n

                                            or TR n

                                            or n X

R1014 n                                     is    int-literal-constant

C1010    (R1014) n shall be positive.

C1011    (R1014) n shall not have a kind parameter specified for it.

R1015 sign-edit-desc                        is    SS

                                            or SP

                                            or S

R1016 blank-interp-edit-desc                is    BN

                                            or BZ

R1017 round-edit-desc                       is    RU

                                            or RD

                                            or RZ

                                            or RN

                                            or RC

                                            or RP

R1018 decimal-edit-desc                     is    DC

                                            or DP

R1019 char-string-edit-desc                 is    char-literal-constant

C1012    (R1019) The char-literal-constant shall not have a kind parameter specified for it.

Section 11:
R1101 main-program                          is    [ program-stmt ]

                                                         [ specification-part ]

                                                         [ execution-part ]

                                                         [ internal-subprogram-part ]

                                                         end-program-stmt

R1102 program-stmt                          is    PROGRAM program-name

R1103 end-program-stmt                      is    END [ PROGRAM [ program-name ] ]

C1101    (R1101) In a main-program, the execution-part shall not contain a RETURN statement or an
         ENTRY statement.




524                                   WORKING DRAFT                                            SEP 2002


SEP 2002                              WORKING DRAFT                                      J3/02-007R3



C1102    (R1101) The program-name may be included in the end-program-stmt only if the optional
         program-stmt is used and, if included, shall be identical to the program-name specified in the
         program-stmt .

C1103    (R1101) An automatic object shall not appear in the specification-part (R204) of a main program.

R1104 module                          is    module-stmt

                                                [ specification-part ]

                                                [ module-subprogram-part ]

                                                end-module-stmt

R1105 module-stmt                     is    MODULE module-name

R1106 end-module-stmt                 is    END [ MODULE [ module-name ] ]

R1107 module-subprogram-part          is    contains-stmt

                                                module-subprogram

                                                [ module-subprogram ] ...

R1108 module-subprogram               is    function-subprogram

                                      or subroutine-subprogram

C1104    (R1104) If the module-name is specified in the end-module-stmt , it shall be identical to the
         module-name specified in the module-stmt .

C1105    (R1104) A module specification-part shall not contain a stmt-function-stmt , an entry-stmt , or a
         format-stmt .

C1106    (R1104) An automatic object shall not appear in the specification-part of a module.

C1107    (R1104) If an object of a type for which component-initialization is specified (R435) appears
         in the specification-part of a module and does not have the ALLOCATABLE or POINTER
         attribute, the object shall have the SAVE attribute.

R1109 use-stmt                        is    USE [ [ , module-nature ] :: ] module-name [ , rename-list ]

                                      or USE [ [ , module-nature ] :: ] module-name ,

                                              ONLY : [ only-list ]

R1110 module-nature                   is    INTRINSIC

                                      or NON INTRINSIC

R1111 rename                          is    local-name => use-name

                                      or OPERATOR (local-defined-operator ) =>

                                              OPERATOR (use-defined-operator )

R1112 only                            is    generic-spec

                                      or only-use-name

                                      or rename

R1113 only-use-name                   is    use-name

C1108    (R1109) If module-nature is INTRINSIC, module-name shall be the name of an intrinsic module.

C1109    (R1109) If module-nature is NON INTRINSIC, module-name shall be the name of a nonintrinsic
         module.

C1110    (R1111) OPERATOR(use-defined-operator ) shall not identify a generic-binding.

C1111    (R1112) The generic-spec shall not identify a generic-binding.

C1112    (R1112) Each generic-spec shall be a public entity in the module.

C1113    (R1113) Each use-name shall be the name of a public entity in the module.

R1114 local-defined-operator           is    defined-unary-op

                                      or defined-binary-op

R1115 use-defined-operator             is    defined-unary-op

                                      or defined-binary-op

C1114    (R1115) Each use-defined-operator shall be a public entity in the module.




SEP 2002                                     WORKING DRAFT                                           525


J3/02-007R3                                  WORKING DRAFT                                    SEP 2002



R1116 block-data                       is    block-data-stmt

                                                 [ specification-part ]

                                                 end-block-data-stmt

R1117 block-data-stmt                  is    BLOCK DATA [ block-data-name ]

R1118 end-block-data-stmt              is    END [ BLOCK DATA [ block-data-name ] ]

C1115    (R1116) The block-data-name may be included in the end-block-data-stmt only if it was provided
         in the block-data-stmt and, if included, shall be identical to the block-data-name in the block-
         data-stmt .

C1116    (R1116) A block-data specification-part may contain only USE statements, type declaration
         statements, IMPLICIT statements, PARAMETER statements, derived-type definitions, and
         the following specification statements: COMMON, DATA, DIMENSION, EQUIVALENCE, IN-
         TRINSIC, POINTER, SAVE, and TARGET.

C1117    (R1116) A type declaration statement in a block-data specification-part shall not contain AL-
         LOCATABLE, EXTERNAL, or BIND attribute specifiers.

Section 12:
R1201 interface-block                  is    interface-stmt

                                                 [ interface-specification ] ...

                                                 end-interface-stmt

R1202 interface-specification           is    interface-body

                                       or procedure-stmt

R1203 interface-stmt                   is    INTERFACE [ generic-spec ]

                                       or ABSTRACT INTERFACE

R1204 end-interface-stmt               is    END INTERFACE [ generic-spec ]

R1205 interface-body                   is    function-stmt

                                                 [ specification-part ]

                                                 end-function-stmt

                                       or subroutine-stmt

                                                 [ specification-part ]

                                                 end-subroutine-stmt

C1201    (R1201) An interface-block in a subprogram shall not contain an interface-body for a procedure
         defined by that subprogram.

C1202    (R1201) The generic-spec may be included in the end-interface-stmt only if it was provided in the
         interface-stmt . If the end-interface-stmt includes generic-name, the interface-stmt shall specify
         the same generic-name. If the end-interface-stmt includes ASSIGNMENT(=), the interface-
         stmt shall specify ASSIGNMENT(=).            If the end-interface-stmt includes dtio-generic-spec,
         the interface-stmt shall specify the same dtio-generic-spec. If the end-interface-stmt includes
         OPERATOR(defined-operator ), the interface-stmt shall specify the same defined-operator . If
         one defined-operator is .LT., .LE., .GT., .GE., .EQ., or .NE., the other is permitted to be the
         corresponding operator <, <=, >, >=, ==, or /=.

C1203    (R1203) If the interface-stmt is ABSTRACT INTERFACE, then the function-name in the
         function-stmt or the subroutine-name in the subroutine-stmt shall not be the same as a keyword
         that specifies an intrinsic type.

C1204    (R1202) A procedure-stmt is allowed only in an interface block that has a generic-spec.

C1205    (R1205) An interface-body of a pure procedure shall specify the intents of all dummy arguments
         except pointer, alternate return, and procedure arguments.

C1206    (R1205) An interface-body shall not contain an entry-stmt , data-stmt , format-stmt , or stmt-

         function-stmt .

R1206 procedure-stmt                   is    [ MODULE ] PROCEDURE procedure-name-list




526                                  WORKING DRAFT                                            SEP 2002


SEP 2002                              WORKING DRAFT                                              J3/02-007R3



R1207 generic-spec                    is    generic-name

                                      or OPERATOR ( defined-operator )

                                      or ASSIGNMENT ( = )

                                      or dtio-generic-spec

R1208 dtio-generic-spec               is    READ (FORMATTED)

                                      or READ (UNFORMATTED)

                                      or WRITE (FORMATTED)

                                      or WRITE (UNFORMATTED)

C1207    (R1206) A procedure-name shall have an explicit interface and shall refer to an accessible pro-
         cedure pointer, external procedure, dummy procedure, or module procedure.

C1208    (R1206) If MODULE appears in a procedure-stmt , each procedure-name in that statement shall
         be accessible in the current scope as a module procedure.

C1209    (R1206) A procedure-name shall not specify a procedure that is specified previously in any
         procedure-stmt in any accessible interface with the same generic identifier.

R1209 import-stmt                     is    IMPORT [[ :: ] import-name-list

C1210    (R1209) The IMPORT statement is allowed only in an interface-body.

C1211    (R1209) Each import-name shall be the name of an entity in the host scoping unit.

R1210 external-stmt                   is    EXTERNAL [ :: ] external-name-list

R1211 procedure-declaration-stmt      is    PROCEDURE ( [ proc-interface ] )

                                              [ [ , proc-attr-spec ] ... :: ] proc-decl -list

R1212 proc-interface                  is    interface-name

                                      or declaration-type-spec

R1213 proc-attr-spec                  is    access-spec

                                      or proc-language-binding-spec

                                      or INTENT ( intent-spec )

                                      or OPTIONAL

                                      or POINTER

                                      or SAVE

R1214 proc-decl                       is    procedure-entity-name[ => null-init ]

R1215 interface-name                  is    name

C1212    (R1215) The name shall be the name of an abstract interface or of a procedure that has an
         explicit interface. If name is declared by a procedure-declaration-stmt it shall be previously
         declared. If name denotes an intrinsic procedure it shall be one that is listed in 13.6 and not
         marked with a bullet (�).

C1213    (R1215) The name shall not be the same as a keyword that specifies an intrinsic type.

C1214    If a procedure entity has the INTENT attribute or SAVE attribute, it shall also have the
         POINTER attribute.

C1215    (R1211) If a proc-interface describes an elemental procedure, each procedure-entity-name shall
         specify an external procedure.

C1216    (R1214) If => appears in proc-decl , the procedure entity shall have the POINTER attribute.

C1217    (R1211) If proc-language-binding-spec with a NAME= is specified, then proc-decl -list shall con-
         tain exactly one proc-decl , which shall neither have the POINTER attribute nor be a dummy
         procedure.

C1218    (R1211) If proc-language-binding-spec is specified, the proc-interface shall appear, it shall be an
         interface-name, and interface-name shall be declared with a proc-language-binding-spec.

R1216 intrinsic-stmt                  is    INTRINSIC [ :: ] intrinsic-procedure-name-list

C1219    (R1216) Each intrinsic-procedure-name shall be the name of an intrinsic procedure.

R1217 function-reference              is    procedure-designator ( [ actual-arg-spec-list ] )



SEP 2002                                     WORKING DRAFT                                              527


J3/02-007R3                                      WORKING DRAFT                                        SEP 2002



C1220    (R1217) The procedure-designator shall designate a function.

C1221    (R1217) The actual-arg-spec-list shall not contain an alt-return-spec.

R1218 call-stmt                            is    CALL procedure-designator [ ( [ actual-arg-spec-list ] ) ]

C1222    (R1218) The procedure-designator shall designate a subroutine.

R1219 procedure-designator                 is    procedure-name

                                           or data-ref % procedure-component-name

                                           or data-ref % binding-name

C1223    (R1219) A procedure-name shall be the name of a procedure or procedure pointer.

C1224    (R1219) A procedure-component-name shall be the name of a procedure pointer component of
         the declared type of data-ref .

C1225    (R1219) A binding-name shall be the name of a procedure binding (4.5.1.5) of the declared type
         of data-ref .

R1220 actual-arg-spec                      is    [ keyword = ] actual-arg

R1221 actual-arg                           is    expr

                                           or variable

                                           or procedure-name

                                           or alt-return-spec

R1222 alt-return-spec                      is    * label

C1226    (R1220) The keyword = shall not appear if the interface of the procedure is implicit in the
         scoping unit.

C1227    (R1220) The keyword = may be omitted from an actual-arg-spec only if the keyword = has been
         omitted from each preceding actual-arg-spec in the argument list.

C1228    (R1220) Each keyword shall be the name of a dummy argument in the explicit interface of the
         procedure.

C1229    (R1221) A nonintrinsic elemental procedure shall not be used as an actual argument.

C1230    (R1221) A procedure-name shall be the name of an external procedure, a dummy procedure, a
         module procedure, a procedure pointer, or a specific intrinsic function that is listed in 13.6 and
         not marked with a bullet(�).

C1231    (R1221) In a reference to a pure procedure, a procedure-name actual-arg shall be the name of a
         pure procedure (12.6).

C1232    (R1222) The label used in the alt-return-spec shall be the statement label of a branch target statement that

         appears in the same scoping unit as the call-stmt .

C1233    (R1221) If an actual argument is an array section or an assumed-shape array, and the corre-
         sponding dummy argument has either the VOLATILE or ASYNCHRONOUS attribute, that
         dummy argument shall be an assumed-shape array.

C1234    (R1221) If an actual argument is a pointer array, and the corresponding dummy argument
         has either the VOLATILE or ASYNCHRONOUS attribute, that dummy argument shall be an
         assumed-shape array or a pointer array.

R1223 function-subprogram                  is    function-stmt

                                                      [ specification-part ]

                                                      [ execution-part ]

                                                      [ internal-subprogram-part ]

                                                      end-function-stmt

R1224 function-stmt                        is    [ prefix ] FUNCTION function-name

                                                   ( [ dummy-arg-name-list ] )

                                                   [, proc-language-binding-spec] [ RESULT ( result-name ) ]

C1235    (R1224) If RESULT is specified, result-name shall not be the same as function-name and shall
         not be the same as the entry-name in any ENTRY statement in the subprogram.




528                                      WORKING DRAFT                                                SEP 2002


SEP 2002                               WORKING DRAFT                                          J3/02-007R3



C1236    (R1224) If RESULT is specified, the function-name shall not appear in any specification state-
         ment in the scoping unit of the function subprogram.

R1225 proc-language-binding-spec       is    language-binding-spec

C1237    (R1225) A proc-language-binding-spec with a NAME= specifier shall not be specified in the
         function-stmt or subroutine-stmt of an interface body for an abstract interface or a dummy
         procedure.

C1238    (R1225) A proc-language-binding-spec shall not be specified for an internal procedure.

C1239    (R1225) If proc-language-binding-spec is specified for a procedure, each of the procedure's dummy
         arguments shall be a nonoptional interoperable variable (15.2.4, 15.2.5) or an interoperable
         procedure (15.2.6). If proc-language-binding-spec is specified for a function, the function result
         shall be an interoperable variable.

R1226 dummy-arg-name                   is    name

C1240    (R1226) A dummy-arg-name shall be the name of a dummy argument.

R1227 prefix                            is    prefix-spec [ prefix-spec ] ...

R1228 prefix-spec                       is    declaration-type-spec

                                       or RECURSIVE

                                       or PURE

                                       or ELEMENTAL

C1241    (R1227) A prefix shall contain at most one of each prefix-spec.

C1242    (R1227) A prefix shall not specify both ELEMENTAL and RECURSIVE.

C1243    (R1227) A prefix shall not specify ELEMENTAL if proc-language-binding-spec appears in the
         function-stmt or subroutine-stmt .

R1229 end-function-stmt                is    END [ FUNCTION [ function-name ] ]

C1244    (R1229) FUNCTION shall appear in the end-function-stmt of an internal or module function.

C1245    (R1223) An internal function subprogram shall not contain an ENTRY statement.

C1246    (R1223) An internal function subprogram shall not contain an internal-subprogram-part .

C1247    (R1229) If a function-name appears in the end-function-stmt , it shall be identical to the function-
         name specified in the function-stmt .

R1230 subroutine-subprogram            is    subroutine-stmt

                                                  [ specification-part ]

                                                  [ execution-part ]

                                                  [ internal-subprogram-part ]

                                                  end-subroutine-stmt

R1231 subroutine-stmt                  is    [ prefix ] SUBROUTINE subroutine-name

                                                [ ( [ dummy-arg -list ] ) ] [, proc-language-binding-spec ]

C1248    (R1231) The prefix of a subroutine-stmt shall not contain a declaration-type-spec.

R1232 dummy-arg                        is    dummy-arg-name

                                       or *

R1233 end-subroutine-stmt              is    END [ SUBROUTINE [ subroutine-name ] ]

C1249    (R1233) SUBROUTINE shall appear in the end-subroutine-stmt of an internal or module sub-
         routine.

C1250    (R1230) An internal subroutine subprogram shall not contain an ENTRY statement.

C1251    (R1230) An internal subroutine subprogram shall not contain an internal-subprogram-part .

C1252    (R1233) If a subroutine-name appears in the end-subroutine-stmt , it shall be identical to the
         subroutine-name specified in the subroutine-stmt .

R1234 entry-stmt                       is    ENTRY entry-name [ ( [ dummy-arg -list ] )

                                                [, proc-language-binding-spec ]

                                                [ RESULT ( result-name ) ] ]



SEP 2002                                        WORKING DRAFT                                                  529


J3/02-007R3                                       WORKING DRAFT                                              SEP 2002



                                            or ENTRY entry-name

                                                    , proc-language-binding-spec [ RESULT ( result-name ) ]

C1253    (R1234) If RESULT is specified, the entry-name shall not appear in any specification or type-
         declaration statement in the scoping unit of the function program.

C1254    (R1234) An entry-stmt may appear only in an external-subprogram or module-subprogram. An
         entry-stmt shall not appear within an executable-construct .

C1255    (R1234) RESULT may appear only if the entry-stmt is in a function subprogram.

C1256    (R1234) Within the subprogram containing the entry-stmt , the entry-name shall not appear
         as a dummy argument in the FUNCTION or SUBROUTINE statement or in another ENTRY
         statement nor shall it appear in an EXTERNAL, INTRINSIC, or PROCEDURE statement.

C1257    (R1234) A dummy-arg may be an alternate return indicator only if the ENTRY statement is in a subroutine

         subprogram.

C1258    (R1234) If RESULT is specified, result-name shall not be the same as the function-name in the
         FUNCTION statement and shall not be the same as the entry-name in any ENTRY statement
         in the subprogram.

R1235 return-stmt                           is    RETURN [ scalar-int-expr ]

C1259    (R1235) The return-stmt shall be in the scoping unit of a function or subroutine subprogram.

C1260    (R1235) The scalar-int-expr is allowed only in the scoping unit of a subroutine subprogram.

R1236 contains-stmt                         is    CONTAINS

R1237 stmt-function-stmt                    is    function-name ( [ dummy-arg-name-list ] ) = scalar-expr

C1261    (R1237) The primaries of the scalar-expr shall be constants (literal and named), references to variables, references

         to functions and function dummy procedures, and intrinsic operations. If scalar-expr contains a reference to a

         function or a function dummy procedure, the reference shall not require an explicit interface, the function shall

         not require an explicit interface unless it is an intrinsic, the function shall not be a transformational intrinsic,

         and the result shall be scalar. If an argument to a function or a function dummy procedure is an array, it shall

         be an array name. If a reference to a statement function appears in scalar-expr , its definition shall have been

         provided earlier in the scoping unit and shall not be the name of the statement function being defined.

C1262    (R1237) Named constants in scalar-expr shall have been declared earlier in the scoping unit or made accessible

         by use or host association. If array elements appear in scalar-expr , the array shall have been declared as an array

         earlier in the scoping unit or made accessible by use or host association.

C1263    (R1237) If a dummy-arg-name, variable, function reference, or dummy function reference is typed by the implicit

         typing rules, its appearance in any subsequent type declaration statement shall confirm this implied type and

         the values of any implied type parameters.

C1264    (R1237) The function-name and each dummy-arg-name shall be specified, explicitly or implicitly, to be scalar.

C1265    (R1237) A given dummy-arg-name may appear only once in any dummy-arg-name-list.

C1266    (R1237) Each variable reference in scalar-expr may be either a reference to a dummy argument of the statement

         function or a reference to a variable accessible in the same scoping unit as the statement function statement.

C1267    The specification-part of a pure function subprogram shall specify that all dummy arguments
         have INTENT (IN) except procedure arguments and arguments with the POINTER attribute.

C1268    The specification-part of a pure subroutine subprogram shall specify the intents of all dummy ar-
         guments except procedure arguments, alternate return indicators, and arguments with the POINTER
         attribute.

C1269    A local variable declared in the specification-part or internal-subprogram-part of a pure subpro-
         gram shall not have the SAVE attribute.

C1270    The specification-part of a pure subprogram shall specify that all dummy arguments that are
         procedure arguments are pure.

C1271    If a procedure that is neither an intrinsic procedure nor a statement function is used in a context
         that requires it to be pure, then its interface shall be explicit in the scope of that use. The
         interface shall specify that the procedure is pure.

C1272    All internal subprograms in a pure subprogram shall be pure.



530                                      WORKING DRAFT                                                       SEP 2002


SEP 2002                                WORKING DRAFT                                      J3/02-007R3



C1273    In a pure subprogram any designator with a base object that is in common or accessed by
         host or use association, is a dummy argument of a pure function, is a dummy argument with
         INTENT (IN) of a pure subroutine, or an object that is storage associated with any such variable,
         shall not be used in the following contexts:

C1274    Any procedure referenced in a pure subprogram, including one referenced via a defined operation,
         assignment, or finalization, shall be pure.

C1275    A pure subprogram shall not contain a print-stmt , open-stmt , close-stmt , backspace-stmt , endfile-
         stmt , rewind-stmt , flush-stmt , wait-stmt , or inquire-stmt .

C1276    A pure subprogram shall not contain a read-stmt or write-stmt whose io-unit is a file-unit-number
         or *.

C1277    A pure subprogram shall not contain a stop-stmt .

C1278    All dummy arguments of an elemental procedure shall be scalar dummy data objects and shall
         not have the POINTER or ALLOCATABLE attribute.

C1279    The result variable of an elemental function shall be scalar and shall not have the POINTER or
         ALLOCATABLE attribute.

C1280    In the scoping unit of an elemental subprogram, an object designator with a dummy argument
         as the base object shall not appear in a specification-expr except as the argument to one of the
         intrinsic functions BIT SIZE, KIND, LEN, or the numeric inquiry functions (13.5.6).

Section 13:

Section 14:

Section 15:
C1501    (R423) A derived type with the BIND attribute shall not be a SEQUENCE type.

C1502    (R423) A derived type with the BIND attribute shall not have type parameters.

C1503    (R423) A derived type with the BIND attribute shall not have the EXTENSIBLE or EXTENDS
         attribute.

C1504    (R423) A derived type with the BIND attribute shall not have a type-bound-procedure-part .

C1505    (R423) Each component of a derived type with the BIND attribute shall be a nonpointer,
         nonallocatable data component with interoperable type and type parameters.

Section 16:





SEP 2002                                      WORKING DRAFT                                             531


J3/02-007R3       WORKING DRAFT    SEP 2002





532            WORKING DRAFT       SEP 2002


SEP 2002                                WORKING DRAFT                                    J3/02-007R3





                                           Annex E
                                            (Informative)

                                             Index
In this index, entries in italics denote BNF terms, entries in bold face denote language keywords, and
page numbers in bold face denote primary or defining text.


Symbols                                              accessibility statements, 84
<, 135                                               action statement, 415
<=, 135                                              action-stmt (R214), 10, 11, 157, 169
>, 135                                               action-term-do-construct (R836), 165, 165
>=, 135                                              ACTION= specifier, 182, 209
*, 133                                               actions, 172
* (symbol), 235, 239                                 active, 166
**, 133                                              active combination of, 150
+, 133                                               actual argument, 251, 415
-, 133                                               actual-arg (R1221), 263, 263
.AND., 136                                           actual-arg-spec (R1220), 58, 262, 263, 263
.EQ., 135                                            add-op (R709), 25, 118, 118
.EQV., 136                                           add-operand (R705), 118, 118, 137
.GE., 135                                            ADVANCE= specifier, 188
.GT., 135                                            advancing input/output statement, 175
.LE., 135                                            affector, 189
.LT., 135                                            alloc-opt (R624), 108, 108, 109
.NE., 135                                            allocatable array, 77
.NEQV., 136                                          ALLOCATABLE attribute, 75, 84
.NOT., 136                                           ALLOCATABLE statement, 84
.OR., 136                                            allocatable variable, 415
/, 133                                               allocatable-stmt (R525), 10, 84, 401
//, 39, 134                                          ALLOCATE statement, 108
/=, 135                                              allocate-lower-bound (R630), 109, 109
;, 29                                                allocate-object (R628), 70, 72, 73, 79, 108, 108, 109,
==, 135                                                       110, 112, 413
&, 28                                                allocate-shape-spec (R629), 108, 109, 109
&, 240                                               allocate-stmt (R623), 11, 70, 79, 108, 413
                                                     allocate-upper-bound (R631), 109, 109
A                                                    allocated, 110
abstract interface, 253, 255                         allocation (R627), 108, 108, 109, 110
abstract interface block, 255                        alphanumeric-character (R302), 23, 23, 25
ac-do-variable (R466), 63, 63, 64                    alt-return-spec (R1222), 169, 262, 263, 263
ac-implied-do (R464), 63, 63, 64                     and-op (R719), 25, 120, 120
ac-implied-do-control (R465), 63, 63                 and-operand (R714), 120, 120
ac-spec (R460), 63, 63                               APOSTROPHE (DELIM value), 244
ac-value (R463), 63, 63, 64                          approximation methods, 35
access methods, 172                                  arg-name, 43�45, 50
access-id (R524), 84, 84                             argument, 415
access-spec (R513), 41�43, 45, 50�52, 67, 74, 74,    argument association, 264, 400, 415
           84, 260                                   argument keyword, 19, 264
access-stmt (R523), 10, 50, 84, 84                   argument keywords, 287, 398
ACCESS= specifier, 182, 209                           arithmetic IF statement, 170
accessibility attribute, 74                          arithmetic-if-stmt (R847), 11, 165, 170, 170



SEP 2002                                   WORKING DRAFT                                              533


J3/02-007R3                                 WORKING DRAFT                                   SEP 2002



array, 18, 76�78, 104, 104�107, 415                 assumed-shape-spec (R519), 76, 77, 77
       assumed-shape, 77                            assumed-size array, 77, 415
       assumed-size, 77                             assumed-size-spec (R521), 76, 78, 78
       automatic, 76                                ASYNCHRONOUS attribute, 75, 75, 85
       deferred-shape, 77                           ASYNCHRONOUS statement, 85
       explicit-shape, 76                           asynchronous-stmt (R526), 10, 85
array constructor, 63, 63                           ASYNCHRONOUS= specifier, 182, 188, 209
array element, 18, 106, 415                         attr-spec (R504), 67, 67, 68, 76
array element order, 106                            attribute, 415
array elements, 104                                      accessibility, 74
array intrinsic assignment statement, 139                ALLOCATABLE, 75, 84
array pointer, 77, 415                                   ASYNCHRONOUS, 75, 85
array section, 18, 106, 415                              BIND, 41, 53, 85
array-constructor (R459), 63, 64, 117                    DIMENSION, 76, 88
array-element (R616), 85, 86, 94, 101, 102, 105,         EXTENDS, 54
           105                                           EXTENSIBLE, 54
array-name, 88, 401                                      EXTERNAL, 78
array-section (R617), 101, 105, 105, 106                 INTENT, 78, 88
array-spec (R515), 6, 68, 70, 76, 76, 88, 90             INTRINSIC, 80
ASCII, 343                                               NON OVERRIDABLE, 56
ASCII character set, 38                                  OPTIONAL, 81, 88
ASCII character type, 38                                 PARAMETER, 81, 88
ASCII collating sequence, 40                             POINTER, 81, 89
assignment, 138�154                                      PRIVATE, 74, 84
       defined, 141                                       PROTECTED, 81, 89
       elemental array (FORALL), 147                     PUBLIC, 74, 84
       intrinsic, 139                                    SAVE, 82, 85, 89
       masked array (WHERE), 145                         TARGET, 82, 90
       pointer, 142                                      VALUE, 83, 90
assignment statement, 138, 415                           VOLATILE, 83, 90
assignment-stmt (R734), 11, 138, 138, 139, 145,     attribute specification statements, 84�98
           148, 151, 283, 413                       attributes, 67, 74�83
ASSOCIATE construct, 160                            automatic array, 76
associate name, 415                                 automatic data object, 70, 415
associate names, 160
associate-construct (R816), 10, 160, 161            B
associate-construct-name, 160, 161                  BACKSPACE statement, 205
associate-name, 160�162, 164, 399, 424              backspace-stmt (R923), 11, 205, 282
associate-stmt (R817), 160, 160, 161, 169           base object, 103
associated, 18                                      base type, 54, 415
associating entity, 408                             belong, 416
association, 19, 415                                belongs, 155, 416
       argument, 264, 400                           binary-constant (R409), 34, 34
       host, 400                                    BIND attribute, 41, 53, 85
       name, 400                                    BIND statement, 85
       pointer, 403                                 BIND(C), 252, 254, 387, 389, 392
       sequence, 268                                bind-entity (R528), 85, 85
       storage, 405                                 bind-stmt (R527), 10, 85, 85
       use, 400                                     binding, 49
association (R818), 160, 160                        binding (R445), 44, 45
association status                                  binding label, 392, 416
       pointer, 404                                 binding-attr (R444), 44, 45, 45
assumed type parameter, 33                          binding-name, 44, 262, 263, 398, 425
assumed-shape array, 77, 415                        binding-private-stmt (R439), 44, 44



534                                   WORKING DRAFT                                         SEP 2002


SEP 2002                                WORKING DRAFT                                         J3/02-007R3



bit model, 288                                            character length parameter, 16, 416
blank common, 96                                          character literal constant, 38
blank-interp-edit-desc (R1016), 221, 221                  character relational intrinsic operation, 121
BLANK= specifier, 182, 189, 209                            character sequence type, 52, 94, 407
block, 155, 416                                           character set, 23
block (R801), 155, 156, 158, 160, 162, 165                character storage unit, 405, 416
block data program unit, 249, 416                         character string, 38, 416
block-data (R1116), 9, 249, 250                           character string edit descriptor, 220
block-data-name, 249, 250                                 character type, 38, 38�40
block-data-stmt (R1117), 9, 249, 249                      CHARACTER type specifier, 72
block-do-construct (R826), 164, 165, 165                  characteristics, 416
bounds, 416                                               characteristics of a procedure, 252
bounds-remapping (R738), 142, 143, 143, 144               child data transfer statement, 198, 198�202, 216
bounds-spec (R737), 142, 143, 143, 144                    CLASS, 73
boz-literal-constant (R408), 25, 34, 35, 87, 303, 308,    class, 416
         319, 339, 340                                    CLOSE statement, 184
branch target statement, 169                              close-spec (R909), 185, 185
Branching, 169                                            close-stmt (R908), 11, 185, 282
                                                          collating sequence, 39, 39, 416
C                                                         comment, 28, 29
C address, 382                                            common association, 97
C character kind, 382                                     common block, 96, 397, 416, 459
C (C type), 381�390                                       common block storage sequence, 97
C LOC function, 382                                       COMMON statement, 96, 96�99
CALL statement, 262                                       common-block-name, 85, 89, 96, 249
call-stmt (R1218), 11, 262, 264, 265                      common-block-object (R563), 96, 96, 249, 401
CASE construct, 158                                       common-stmt (R562), 10, 96, 401
case index, 158                                           companion processor, 21, 416
case-construct (R808), 11, 158, 158                       compatibility
case-construct-name, 158                                      Fortran 77, 3
case-expr (R812), 158, 158                                    Fortran 90, 3
case-selector (R813), 158, 158                                Fortran 95, 3
case-stmt (R810), 158, 158                                COMPLEX, 37
case-value (R815), 158, 158                               complex type, 37, 37
case-value-range (R814), 158, 158                         COMPLEX type specifier, 71
CHAR intrinsic, 39                                        complex-literal-constant (R418), 25, 37
char-constant (R309), 25, 25, 170                         component, 417
char-expr (R725), 123, 123, 127, 158                      component keyword, 19
char-initialization-expr (R731), 75, 127, 127, 158,       Component order, 56
         186, 187                                         component order, 417
char-length (R512), 42, 43, 68�70, 72, 72                 component-array-spec (R434), 42, 42, 43, 47
char-literal-constant (R421), 25, 30, 38, 201, 221,       component-attr-spec (R432), 42, 42, 43, 48
         222                                              component-data-source (R451), 57, 57, 58, 59
char-selector (R510), 67, 72, 72                          component-decl (R433), 42, 42, 43, 47, 72
char-string-edit-desc (R1019), 220, 222                   component-def-stmt (R430), 42, 42, 43, 73
char-variable (R606), 101, 101                            component-initialization (R435), 42, 42, 43, 246
CHARACTER, 38                                             component-name, 42
character, 416                                            component-spec (R450), 57, 57, 58, 127
character (R301), 23                                      components, 41, 398
character context, 27                                     computed GO TO statement, 169
CHARACTER declaration, 429                                computed-goto-stmt (R846), 11, 169, 169
character intrinsic assignment statement, 139             concat-op (R711), 25, 119, 119
character intrinsic operation, 121, 134                   concatenation, 39
character intrinsic operator, 121                         conform, 139



SEP 2002                                      WORKING DRAFT                                                535


J3/02-007R3                                WORKING DRAFT                                  SEP 2002



conformable, 18, 417                             data-i-do-object (R533), 85, 85, 86
conformance, 125, 417                            data-i-do-variable (R534), 85, 85, 86
connect-spec (R905), 181, 181                    data-implied-do (R532), 85, 85, 86, 87
connected, 179, 417                              data-pointer-component-name, 142, 143
connected files, 179                              data-pointer-object (R736), 142, 142, 143, 144
constant, 17, 25, 31, 417                        data-ref (R612), 102, 103�105, 189, 262, 263, 265
       character, 38                             data-stmt (R529), 10, 85, 255, 282, 401
       integer, 34                               data-stmt-constant (R537), 35, 86, 86, 87
       named, 88                                 data-stmt-object (R531), 85, 85, 86, 87
constant (R305), 25, 25, 86, 102, 117            data-stmt-repeat (R536), 86, 86, 87
constant subobject, 17                           data-stmt-set (R530), 85, 85
constant-subobject (R539), 86, 86, 117           data-stmt-value (R535), 85, 86, 87
construct, 417                                   data-target (R739), 57�59, 70, 142, 143, 143, 144,
Construct association, 403                                151, 268, 282, 300, 405
construct entity, 395, 417                       datum, 417
constructor                                      dealloc-opt (R636), 112, 112, 114
       array, 63                                 DEALLOCATE statement, 112
       derived-type, 57                          deallocate-stmt (R635), 11, 70, 79, 112, 413
       structure, 57                             decimal symbol, 224, 417
CONTAINS statement, 280                          decimal-edit-desc (R1018), 221, 222
contains-stmt (R1236), 10, 44, 246, 280          DECIMAL= specifier, 182, 189, 209
continuation, 28, 29                             declaration, 19
CONTINUE statement, 170                          declaration-construct (R207), 9, 10
continue-stmt (R848), 11, 165, 170               declaration-type-spec (R502), 42, 43, 61, 67, 67, 70,
Control characters, 23                                    90, 92, 260, 261, 275, 277
control edit descriptor, 220                     declarations, 67�99
control edit descriptors, 232                    declared binding, 262
control information list, 186                    declared type, 73, 417
control mask, 417                                default character, 38
control-edit-desc (R1011), 220, 221              default complex, 37
conversion                                       default initialization, 417
       numeric, 140                              default integer, 34
current record, 175                              default logical, 40
CYCLE statement, 164, 167                        default real, 36
cycle-stmt (R843), 11, 165, 167, 167             default-char-expr (R726), 123, 123, 181�186, 188�
                                                          191
D                                                default-char-variable (R607), 101, 101, 108, 178,
d (R1008), 220, 221, 221, 225�228, 230, 238               181, 208�213
data, 417                                        default-initialized, 46, 418
data edit descriptor, 220                        default-logical-variable (R605), 101, 101, 208, 210,
data edit descriptors, 224�231                            211
data entity, 16, 417                             deferred type parameter, 32, 418
data object, 16, 417                             deferred-shape array, 77
data object reference, 20                        deferred-shape-spec (R520), 42, 43, 68, 76, 77, 77,
data pointer, 18                                          84, 89
DATA statement, 85, 409                          definable, 418
data transfer, 195                               defined, 20, 418
data transfer input statement, 171               defined assignment, 259
data transfer output statements, 171             defined assignment statement, 141, 418
data transfer statements, 185                    defined binary operation, 122
data type, see type, 417                         defined elemental assignment statement, 141
data-component-def-stmt (R431), 42, 42, 47       defined elemental operation, 123
data-component-part (R428), 41, 42, 50, 51       defined operation, 122, 258, 418
data-edit-desc (R1005), 220, 220                 defined unary operation, 122



536                                    WORKING DRAFT                                      SEP 2002


SEP 2002                                  WORKING DRAFT                                   J3/02-007R3



defined-binary-op (R723), 26, 120, 120, 122, 123,     dtio-generic-spec (R1208), 44, 56, 198, 199, 202,
          248                                                 254, 255, 255, 258, 397
defined-operator (R311), 26, 44, 248, 254, 255        dtv-type-spec (R920), 199
defined-unary-op (R703), 26, 118, 118, 122, 123,      dummy argument, 251, 418
          136, 248                                   dummy arguments
definition, 19                                             restrictions, 269
definition of variables, 409                          dummy array, 418
deleted feature, 418                                 dummy data object, 418
deleted features, 6                                  dummy pointer, 418
DELIM= specifier, 182, 189, 210                       dummy procedure, 252, 418
Delimiters, 27                                       dummy-arg (R1232), 277, 277, 278, 279
derived type, 16, 418                                dummy-arg-name (R1226), 88, 90, 275, 275, 277,
derived type determination, 53                                281, 401
derived types, 41�59                                 dynamic binding, 263
derived-type intrinsic assignment statement, 139     dynamic type, 73, 418
derived-type type specifier, 73
derived-type-def (R423), 10, 41, 42, 45, 46, 73      E
derived-type-spec (R447), 57, 57, 58, 61, 67, 73,    e (R1009), 221, 221, 226, 227, 230, 238
          199, 398                                   edit descriptor, 220
derived-type-stmt (R424), 41, 41, 42, 45, 50, 54,    edit descriptors, see format descriptors
          401                                        effective item, 193, 418
designator, 19, 418                                  effective position, 398
designator (R603), 86, 101, 101, 104, 117            element array assignment (FORALL), 147
designator, 117                                      element sequence, 268
digit, 5, 23, 24, 26, 34, 35, 170, 236               elemental, 18, 251, 418
                                                     elemental intrinsic function, 287
digit-string (R406), 34, 34, 36, 225
                                                     elemental operation, 125
digit-string, 34                                     elemental procedure, 283
digits, 23                                           else-if-stmt (R804), 156, 156
DIMENSION attribute, 76, 88                          else-stmt (R805), 156, 156
DIMENSION statement, 88                              elsewhere-stmt (R749), 145, 145
dimension-stmt (R540), 10, 88, 401                   END statement, 14, 14
direct access, 173                                   end-associate-stmt (R820), 160, 161, 161, 169
direct access input/output statement, 190            end-block-data-stmt (R1118), 9, 14, 15, 249, 249
DIRECT= specifier, 210                                end-do (R833), 165, 165, 166�168
disassociated, 18, 418                               end-do-stmt (R834), 165, 165, 169
DO construct, 164                                    end-enum-stmt (R458), 61, 62
DO statement, 164                                    end-forall-stmt (R757), 148, 148
DO termination, 166                                  end-function-stmt (R1229), 9, 11, 14, 15, 157, 165,
DO WHILE statement, 164                                       254, 275, 275, 276, 280
do-block (R832), 165, 165, 166, 167                  end-if-stmt (R806), 156, 156, 169
do-body (R837), 165, 165, 166                        end-interface-stmt (R1204), 254, 254
do-construct (R825), 11, 164, 167, 168               end-module-stmt (R1106), 9, 14, 15, 246, 246
do-construct-name, 165, 167, 168                     end-of-file condition, 214
do-stmt (R827), 165, 165, 169, 413                   end-of-record condition, 214
do-term-action-stmt (R838), 165, 165, 166, 167,      end-program-stmt (R1103), 9, 11, 14, 15, 157, 165,
          169                                                 245, 245
do-term-shared-stmt (R842), 165, 165, 166, 167,      end-select-stmt (R811), 158, 158, 159, 169
          169                                        end-select-type-stmt (R824), 162, 162, 163, 169
do-variable (R831), 165, 165, 166, 191, 192, 217,    end-subroutine-stmt (R1233), 9, 11, 14, 15, 157,
          413                                                 165, 254, 277, 278, 278, 280
DOUBLE PRECISION, 36                                 end-type-stmt (R446), 41, 45
double precision real, 36                            end-where-stmt (R750), 145, 145
DOUBLE PRECISION type specifier, 71                   END= specifier, 215



SEP 2002                                     WORKING DRAFT                                           537


J3/02-007R3                                WORKING DRAFT                                          SEP 2002



endfile record, 172                                      exponent-letter (R416), 36, 36
ENDFILE statement, 172, 206                             expr (R722), 6, 57, 58, 60, 63, 117, 118, 120, 120,
endfile-stmt (R924), 11, 205, 282                                    123, 124, 127, 138�143, 147, 151, 160, 191,
ending point, 102                                                   263, 281, 282
entity, 418                                             expression, 117, 419
entity-decl (R505), 67, 68, 68, 69, 70, 72, 76, 126,    expressions, 17, 117�137
           127, 401                                     extended type, 54, 419
entity-name, 85, 89                                     extended-intrinsic-op (R312), 26, 26
ENTRY statement, 278, 278                               EXTENDS, 54
entry-name, 275, 278, 279, 397                          EXTENSIBLE, 54
entry-stmt (R1234), 10, 246, 255, 278, 279, 397,        extensible type, 54, 419
           401                                          extensible-type-name, 162
enum-alias-def (R454), 10, 61, 62                       extension operation, 123, 136
enum-def-stmt (R455), 61, 61, 62                        extension operator, 123
enumeration, 61                                         extension type, 54, 419
enumerator, 61                                          extent, 18, 419
enumerator (R457), 62, 62                               EXTERNAL attribute, 78
enumerator-def-stmt (R456), 61, 62                      external file, 172, 419
EOR= specifier, 215                                      external linkage, 419
equiv-op (R721), 25, 120, 120                           external procedure, 12, 251, 419
equiv-operand (R716), 120, 120                          EXTERNAL statement, 259
EQUIVALENCE statement, 93, 93�96                        external subprogram, 11, 419
equivalence-object (R561), 94, 94, 249                  external unit, 178, 419
equivalence-set (R560), 94, 94, 95                      external-name, 260
equivalence-stmt (R559), 10, 94, 401                    external-stmt (R1210), 10, 260, 401
ERR= specifier, 214                                      external-subprogram (R203), 9, 9, 279
errmsg-variable (R626), 108, 108, 109, 111, 112,
           411, 413                                     F
ERRMSG= specifier, 111                                   field, 222
ERROR UNIT, 179, 353                                    field width, 222
evaluation                                              file, 419
       optional, 129                                    file access, 173
       operations, 128                                  file connection, 178
       parentheses, 130                                 file connection statements, 171
executable construct, 419                               file inquiry, 207
executable constructs, 155                              file inquiry statement, 171
executable statement, 13, 419                           file position, 175
executable-construct (R213), 10, 10, 13, 279            file positioning statements, 171, 205
execution control, 155�170                              file storage unit, 177, 419
execution cycle, 167                                    file-name-expr (R906), 181, 181, 182, 208�210
execution-part (R208), 9, 10, 11, 245, 275�277          file-unit-number (R902), 178, 178, 181, 185, 187,
execution-part-construct (R209), 10, 10, 155, 165                   200, 204�209, 282
exist, 173                                              FILE= specifier, 182, 209
EXIST= specifier, 210                                    files
EXIT statement, 167                                             connected, 179
exit-stmt (R844), 11, 165, 167, 168                             external, 172
explicit, 253                                                   internal, 177
explicit formatting, 219�235                                    preconnected, 180
explicit initialization, 70, 85, 419                    final subroutine, 419
explicit interface, 253, 419                            final subroutines, 50
explicit-shape array, 76, 419                           final-binding (R443), 44, 44
explicit-shape-spec (R516), 42, 43, 68, 76, 76, 78,     final-subroutine-name, 44
           96, 97                                       finalizable, 50, 419
exponent (R417), 36, 36                                 finalization, 59, 419



538                                     WORKING DRAFT                                             SEP 2002


SEP 2002                              WORKING DRAFT                                          J3/02-007R3



finalized, 59                                                 explicit, 219�235
fixed source form, 29, 29                                     list-directed, 198, 235�239
FLUSH statement, 206                                         namelist, 198, 239�244
flush-spec (R928), 206, 206, 207                         forms, 172
flush-stmt (R927), 11, 206, 282                          Fortran 77 compatibility, 3
FMT= specifier, 188                                      Fortran 90 compatibility, 3
FORALL construct, 148                                   Fortran 95 compatibility, 3
forall-assignment-stmt (R756), 148, 148, 151, 153,      Fortran character set, 23
         283                                            free source form, 27, 27
forall-body-construct (R755), 148, 148, 151, 153        function, 12, 420
forall-construct (R751), 11, 148, 148, 149, 151, 152    function reference, 17, 272
forall-construct-name, 148                              function result, 420
forall-construct-stmt (R752), 148, 148, 169             FUNCTION statement, 275
forall-header (R753), 148, 148, 153, 154                function subprogram, 275, 420
forall-stmt (R758), 11, 148, 152, 153, 153              function-name, 68, 69, 254, 255, 275, 276, 279, 281,
forall-triplet-spec (R754), 148, 148, 149, 150, 152              396, 401
FORM= specifier, 183, 210                                function-reference (R1217), 58, 68, 117, 262, 265,
format (R914), 185�188, 188, 195, 219, 220                       272
format control, 222                                     function-stmt (R1224), 9, 254, 255, 275, 275, 276,
format descriptors                                               396, 401
    /, 233                                              function-subprogram (R1223), 9, 10, 246, 275
    :, 233
    A, 229                                              G
    B, 224                                              generic identifier, 257, 420
    BN, 234                                             generic interface, 49, 257, 420
    BZ, 234                                             generic interface block, 255, 420
    control edit descriptors, 232                       generic name, 257
    D, 226                                              Generic names, 287
    data edit descriptors, 224�231                      generic procedure references, 397
    E, 226                                              generic-binding (R442), 44, 44, 45, 49, 247
    EN, 227                                             generic-name, 44, 45, 254, 255, 398, 401
    ES, 227                                             generic-spec (R1207), 44, 45, 49, 56, 84, 122, 142,
    F, 225                                                       199, 200, 247, 248, 254, 255, 255, 257,
    G, 229, 230                                                  398, 401
    I, 224                                              global entities, 395
    L, 229                                              global entity, 395, 420
    O, 224                                              GO TO statement, 169
    P, 234                                              goto-stmt (R845), 11, 165, 169, 169
    S, 233                                              Graphic characters, 23
    SP, 233
    SS, 233                                             H
    TL, 232                                             hex-constant (R411), 34, 34
    TR, 232                                             hex-digit (R412), 34, 35, 35
    X, 233                                              host, 12, 420
    Z, 224                                              host association, 400, 420
FORMAT statement, 188, 219                              host scoping unit, 12, 420
format-item (R1003), 219, 220, 220
format-specification (R1002), 219, 219                   I
format-stmt (R1001), 10, 219, 219, 246, 255             ICHAR intrinsic, 39
formatted data transfer, 197                            ID= specifier, 190, 210
formatted input/output statement, 187                   IEEE , 296, 355�379
formatted record, 171                                   IF construct, 156, 156
FORMATTED= specifier, 210                                IF statement, 156, 157
formatting                                              if-construct (R802), 11, 156, 156



SEP 2002                                       WORKING DRAFT                                            539


J3/02-007R3                              WORKING DRAFT                                          SEP 2002



if-construct-name, 156                                 int-initialization-expr (R732), 62, 68, 69, 72, 127,
if-stmt (R807), 11, 157, 157                                    127, 158
if-then-stmt (R803), 156, 156, 169                     int-literal-constant (R403), 25, 34, 34, 72, 87, 220,
imag-part (R420), 37, 37                                        221, 319
imaginary part, 37, 37                                 int-variable (R608), 63, 85, 101, 101, 108, 165, 181,
implicit, 253                                                   185, 186, 204, 205, 207, 208, 211�216
implicit interface, 262, 420                           INTEGER, 34
IMPLICIT statement, 90, 90                             integer constant, 34
implicit-part (R205), 9, 10                            integer editing, 224
implicit-part-stmt (R206), 10, 10                      integer model, 289
implicit-spec (R555), 90, 90                           integer type, 33, 33
implicit-stmt (R554), 10, 90                           INTEGER type specifier, 71
import-name, 255                                       INTENT, 288
import-name-list, 256                                  intent, 420
import-stmt (R1209), 9, 255                            INTENT attribute, 78, 88
inactive, 166                                          INTENT statement, 88
INCLUDE, 30                                            intent-spec (R522), 68, 78, 88, 260
                                                       intent-stmt (R541), 10, 88
INCLUDE line, 30
                                                       interface, 253
index-name, 148�154, 399, 411, 412
                                                           (procedure), 253
inherit, 420                                               explicit, 253
inheritance associated, 55                                 generic, 257
inheritance association, 408, 420                          implicit, 262
inherited, 54                                          interface block, 13, 420
initial point, 175                                     interface body, 13, 420
initialization, 46, 69, 70, 409                        interface of a procedure, 420
initialization (R508), 68, 68, 69�71                   interface-block (R1201), 10, 254, 254
initialization expression, 126                         interface-body (R1205), 254, 254, 255, 401
initialization-expr (R730), 42, 46, 68, 70, 81, 88,    interface-name (R1215), 260, 260, 261
         127, 127                                      interface-specification (R1202), 254, 254
inner-shared-do-construct (R841), 165, 165, 166        interface-stmt (R1203), 254, 254, 257, 258, 401
Input statements, 171                                  internal file, 420
input-item (R915), 185, 186, 191, 191, 192, 203,       internal files, 177
         217, 413                                      internal procedure, 12, 251, 420
input/output editing, 219�244                          internal subprogram, 11, 420
input/output list, 191                                 internal unit, 178
input/output statements, 171�216                       internal-file-variable (R903), 178, 178, 187, 413
INPUT UNIT, 178, 353                                   internal-subprogram (R211), 10, 10
inquire by file, 207                                    internal-subprogram-part (R210), 9, 10, 245, 275�
inquire by output list, 207                                     278, 282
inquire by unit, 207                                   interoperable, 385, 385, 386, 388, 389, 390, 421
INQUIRE statement, 207                                 intrinsic, 20, 421
inquire-spec (R930), 207, 208, 208, 209, 214, 217          elemental, 287
inquire-stmt (R929), 11, 207, 282                          inquiry function, 287
inquiry function, 287, 420                                 transformational, 287
inquiry, type parameter, 104                           intrinsic assignment statement, 139
instance, 278                                          INTRINSIC attribute, 80
instance of a subprogram, 420                          intrinsic binary operation, 121
int-constant (R308), 25, 25, 86                        intrinsic module, 246
int-constant-name, 34                                  intrinsic operation, 121
int-constant-subobject (R538), 86, 86                  intrinsic operations, 133�136
int-expr (R727), 15, 32, 63, 85, 86, 102, 105, 109,        logical, 40
         123, 123, 125, 127, 148, 158, 165, 166,       intrinsic procedure, 251
         169, 178, 181, 186, 191, 280                  intrinsic procedures, 296, 353



540                                   WORKING DRAFT                                             SEP 2002


SEP 2002                                 WORKING DRAFT                                       J3/02-007R3



INTRINSIC statement, 262                                lexical token, 421
intrinsic type, 15                                      Lexical tokens, 24
intrinsic types, 33�40                                  line, 27, 421
intrinsic unary operation, 121                          linked, 421
intrinsic-operator (R310), 25, 26, 118, 120�122,        list-directed formatting, 198, 235�239
         258                                            list-directed input/output statement, 188
intrinsic-procedure-name, 262, 401                      literal constant, 17, 101, 421
intrinsic-stmt (R1216), 10, 262, 401                    literal-constant (R306), 25, 25
invoke, 421                                             local entities, 396
io-control-spec (R913), 185, 186, 186, 187, 200, 217    local entity, 395, 421
io-implied-do (R917), 191, 191, 192, 196, 217, 413      local variable, 17, 421
io-implied-do-control (R919), 191, 191                  local-defined-operator (R1114), 247, 248, 248
io-implied-do-object (R918), 191, 191                   local-name, 247�249
io-unit (R901), 178, 178, 186, 187, 282                 LOGICAL, 40
iomsg-variable (R907), 181, 181, 185, 186, 204,         logical intrinsic assignment statement, 139
         205, 207, 208, 215, 216, 410                   logical intrinsic operation, 121
IOMSG= specifier, 216                                    logical intrinsic operations, 40, 135
IOSTAT= specifier, 216                                   logical intrinsic operator, 121
ISO 10646, 343                                          logical type, 40, 40
ISO 10646 character set, 38                             LOGICAL type specifier, 73
ISO 10646 character type, 38                            logical-expr (R724), 123, 123, 127, 145, 156�158,
ISO C BINDING module, 381                                        165, 167, 168
ISO FORTRAN ENV module, 178, 353                        logical-initialization-expr (R733), 127, 127, 158
iteration count, 166                                    logical-literal-constant (R422), 25, 40, 118, 120
                                                        logical-variable (R604), 101, 101
K                                                       loop, 164
k (R1012), 221, 221, 226, 230, 234                      loop-control (R830), 165, 165, 166�168
keyword, 19, 264, 421                                   low-level syntax, 24
keyword (R215), 19, 19, 57, 263                         lower-bound (R517), 76, 76, 77, 78, 143
kind, 33, 35, 37, 38, 40
KIND intrinsic, 33, 35, 37, 38, 40                      M
kind type parameter, 16, 32, 33, 35, 37, 38, 40, 421    m (R1007), 220, 221, 221, 225
kind-param (R404), 34, 34, 36, 38, 40, 72, 87, 319      main program, 12, 245, 421
kind-selector (R507), 6, 42, 62, 67, 68, 69             main-program (R1101), 9, 245, 245
                                                        many-one array section, 107, 421
L                                                       mask-expr (R747), 145, 145, 146�148, 150�152
label, 421                                              masked array assignment, 145
label (R313), 26, 26, 165, 169, 170, 181, 185, 186,     masked array assignment (WHERE), 145
         188, 204, 205, 207, 208, 215, 216, 263         masked-elsewhere-stmt (R748), 145, 145, 146, 151
label-do-stmt (R828), 165, 165                          model
language-binding-spec (R514), 68, 69, 75, 85, 275            bit, 288
left tab limit, 232                                          integer, 289
left-square-bracket (R461), 63, 63                           real, 289
length, 38                                              module, 13, 246, 421
length of a character string, 421                       module (R1104), 9, 246
length-selector (R511), 6, 72, 72                       module procedure, 12, 252, 421
letter, 23, 23, 25, 26, 90, 118, 120                    module reference, 20, 247
letter-spec (R556), 90, 90, 91                          module subprogram, 11, 421
letters, 23                                             module-name, 246�248, 401
level-1-expr (R702), 118, 118, 137                      module-nature (R1110), 247, 247, 248
level-2-expr (R706), 118, 118, 119, 137                 module-stmt (R1105), 9, 246, 246
level-3-expr (R710), 119, 119                           module-subprogram (R1108), 10, 246, 246, 279
level-4-expr (R712), 119, 119, 120                      module-subprogram-part (R1107), 9, 49, 55, 246,
level-5-expr (R717), 120, 120                                    246



SEP 2002                                       WORKING DRAFT                                            541


J3/02-007R3                                  WORKING DRAFT                                    SEP 2002



mult-op (R708), 25, 118, 118                            numeric relational intrinsic operation, 121
mult-operand (R704), 118, 118, 137                      numeric sequence type, 52, 94, 407
                                                        numeric storage unit, 405, 422
N                                                       numeric type, 422
n (R1014), 221, 221                                     numeric types, 33
name, 19, 422                                           numeric-expr (R728), 35, 123, 123, 170
name (R304), 19, 25, 25, 68, 89, 101, 162, 196, 260,
           275                                          O
name, 6                                                 object, see data object, 16, 422
name association, 400, 422                              object designator, 19, 422
name-value subsequences, 239                            object-name (R506), 68, 68, 69�71, 81, 84, 85, 89,
NAME= specifier, 210                                               90, 101, 401
named, 422                                              obsolescent feature, 422
named common block, 96                                  obsolescent features, 7
named constant, 17, 81, 88, 101, 422                    octal-constant (R410), 34, 34
named file, 172                                          only (R1112), 247, 247, 248
named-constant (R307), 25, 25, 30, 37, 62, 88, 401      only-use-name (R1113), 247, 247, 248
named-constant-def (R544), 88, 88, 401                  OPEN statement, 180, 180
NAMED= specifier, 211                                    open-stmt (R904), 11, 181, 282
namelist formatting, 198, 239�244                       OPENED= specifier, 211
namelist input/output statement, 188                    operand, 422
NAMELIST statement, 93, 93                              operands, 20
namelist-group-name, 93, 186�188, 195, 197, 219,        operation, 422
           240, 244, 249, 401, 413                      operations, 31
namelist-group-object (R558), 93, 93, 195, 196,              character intrinsic, 134
           198, 203, 217, 239, 240, 249                      logical intrinsic, 135
namelist-stmt (R557), 10, 93, 401, 413                       numeric intrinsic, 133
Names, 25                                                    relational intrinsic, 134
NaN, 296, 360, 422                                      operator, 20, 422
next record, 175                                        operator precedence, 136
NEXTREC= specifier, 211                                  operators, 25
NML= specifier, 188                                      OPTIONAL attribute, 81, 88
NON OVERRIDABLE, 56                                     optional dummy argument, 268
nonadvancing input/output statement, 175                OPTIONAL statement, 88
nonblock-do-construct (R835), 164, 165                  optional-stmt (R542), 10, 88
NONE (DELIM value), 244                                 or-op (R720), 25, 120, 120
nonexecutable statement, 422                            or-operand (R715), 120, 120
Nonexecutable statements, 13                            outer-shared-do-construct (R839), 165, 165
nonintrinsic module, 246                                Output statements, 171
nonkind type parameter, 32                              output-item (R916), 185, 186, 191, 191, 203, 208
nonlabel-do-stmt (R829), 165, 165                       OUTPUT UNIT, 178, 353
normal, 360                                             override, 55, 422
not-op (R718), 25, 120, 120                             overrides, 46
NULL intrinsic, 48
null-init (R509), 42, 68, 68, 70, 86, 87, 260           P
NULLIFY statement, 111                                  PAD= specifier, 183, 190, 211
nullify-stmt (R633), 11, 70, 79, 111, 413               PARAMETER, 17
NUMBER= specifier, 211                                   PARAMETER attribute, 81, 88
numeric conversion, 140                                 PARAMETER statement, 88, 88
numeric editing, 224                                    parameter-stmt (R543), 10, 88, 401
numeric intrinsic assignment statement, 139             parent component, 54, 422
numeric intrinsic operation, 121                        parent data transfer statement, 198, 198�202, 216
numeric intrinsic operations, 133                       parent type, 54, 422
numeric intrinsic operator, 121                         parent-string (R610), 102, 102



542                                   WORKING DRAFT                                           SEP 2002


SEP 2002                                WORKING DRAFT                                    J3/02-007R3



parent-type-name, 41, 42                              proc-decl (R1214), 43, 260, 260
parentheses, 130                                      proc-entity-name, 89
part-name, 102, 103, 105                              proc-interface (R1212), 43, 260, 260, 261
part-ref (R613), 86, 94, 102, 102, 103, 105, 106      proc-language-binding-spec (R1225), 69, 260, 261,
partially [storage] associated, 406                            275, 275, 277, 278, 280, 389
PASS attribute, 265                                   proc-pointer-name (R550), 89, 89, 96, 111, 143, 401
passed-object dummy argument, 50, 422                 proc-pointer-object (R740), 142, 143, 144
PENDING= specifier, 211                                proc-target (R741), 57�59, 70, 142, 143, 143, 144,
pointer, 18, 422                                               268, 300, 405
pointer assignment, 142, 422                          procedure, 12, 423
pointer assignment statement, 422                          characteristics of, 252
pointer associated, 422                                    dummy, 252
pointer association, 403, 423                              elemental, 283
pointer association status, 404                            external, 251
POINTER attribute, 81, 89                                  internal, 251
POINTER statement, 89                                      intrinsic, 287�353
pointer-assignment-stmt (R735), 11, 70, 79, 142,           non-Fortran, 280
         148, 151, 282, 413                                pure, 281
pointer-decl (R546), 89, 89                           procedure designator, 19, 423
pointer-object (R634), 70, 79, 111, 111, 112, 143,    procedure interface, 253, 423
         144, 151, 300, 413                           procedure pointer, 18, 260
pointer-stmt (R545), 10, 89, 401                      procedure reference, 20, 262
polymorphic, 73, 423                                  procedure references
POS= specifier, 190, 212                                    generic, 397
position, 172                                              resolving, 272
position-edit-desc (R1013), 221, 221                  procedure-component-name, 143, 262
position-spec (R926), 205, 205                        procedure-declaration-stmt (R1211), 10, 78, 89, 260,
POSITION= specifier, 183, 212                                   260, 401
positional arguments, 287                             procedure-designator (R1219), 262, 262
power-op (R707), 25, 118, 118                         procedure-entity-name, 260
pre-existing, 408                                     procedure-name, 45, 49, 143, 144, 255, 262, 263
precedence of operators, 136                          procedure-stmt (R1206), 254, 255, 255
preceding record, 175                                 processor, 1, 423
PRECISION intrinsic, 35                               processor dependent, 3, 423
preconnected, 423                                     program, 12, 423
preconnected files, 180                                program (R201), 9, 9
Preconnection, 180                                    program unit, 11, 423
prefix (R1227), 275, 275, 277                          program-name, 245
prefix-spec (R1228), 275, 275, 276, 278, 281, 283      program-stmt (R1102), 9, 245, 245
present, 268                                          program-unit (R202), 6, 9, 9
present (dummy argument), 268                         PROTECTED attribute, 81, 89
PRESENT intrinsic, 81                                 PROTECTED statement, 89, 89
primaries, 281                                        protected-stmt (R547), 10, 89
primary, 117                                          prototype, 423
primary (R701), 117, 117, 118                         PUBLIC attribute, 74
PRINT statement, 185                                  PUBLIC statement, 84, 247
print-stmt (R912), 11, 185, 282                       pure procedure, 281, 423
PRIVATE attribute, 74
PRIVATE statement, 84, 247                            Q
private-sequence-stmt (R429), 42, 42                  QUOTE (DELIM value), 244
proc-attr-spec (R1213), 260, 260
proc-binding-stmt (R440), 44, 44, 49                  R
proc-component-attr-spec (R437), 43, 43, 44           r (R1004), 220, 220, 221, 222
proc-component-def-stmt (R436), 42, 43, 43            range, 166



SEP 2002                                   WORKING DRAFT                                             543


J3/02-007R3                                 WORKING DRAFT                                SEP 2002



RANGE intrinsic, 33, 35                           scalar, 17, 102, 423
rank, 17, 18, 423                                 scalar-xyz (R103), 6, 6
READ statement, 185                               scale factor, 221
read-stmt (R910), 11, 185, 186, 282, 413          scope, 395, 424
READ= specifier, 212                               scoping unit, 11, 424
reading, 171                                      section subscript, 424
READWRITE= specifier, 212                          section-subscript (R619), 102, 103, 105, 105, 106
REAL, 36                                          SELECT CASE statement, 158
real and complex editing, 225                     SELECT TYPE construct, 162
real model, 289                                   SELECT TYPE construct, 399, 403
real part, 37                                     select-case-stmt (R809), 158, 158, 169
real type, 35, 35�36                              select-construct-name, 162
REAL type specifier, 71                            select-type-construct (R821), 11, 162, 162
real-literal-constant (R414), 25, 36, 36          select-type-stmt (R822), 162, 162, 169
real-part (R419), 37, 37                          SELECTED INT KIND intrinsic, 33
REC= specifier, 190                                SELECTED REAL KIND intrinsic, 35
RECL= specifier, 183, 212                          selector, 424
record, 171, 423                                  selector (R819), 160, 160, 161�163, 269, 403, 413
record file, 171                                   sequence, 20
record lengths, 172                               sequence association, 268
record number, 174                                SEQUENCE property, 53
RECURSIVE, 278                                    SEQUENCE statement, 52
recursive input/output statement, 216             sequence structure, 73
reference, 423                                    sequence type, 52
rel-op (R713), 25, 119, 119, 135                  sequential access, 173
relational intrinsic operation, 121               sequential access input/output statement, 190
relational intrinsic operations, 134              SEQUENTIAL= specifier, 213
relational intrinsic operator, 121                shape, 18, 424
rename (R1111), 247, 247, 248                     shape conformance, 125
rep-char, 38, 38, 222, 236, 241                   shared-term-do-construct (R840), 165, 165, 166
repeat specification., 220                         sign (R407), 34, 34, 36, 225
representable character, 38                       sign-edit-desc (R1015), 221, 221
representation method, 35                         SIGN= specifier, 184, 191, 213
representation methods, 33, 38, 40                signed-digit-string (R405), 34, 36, 225, 226
resolving procedure references, 272               signed-int-literal-constant (R402), 34, 34, 37, 86,
       derived-type input/output, 202                      221
restricted expression, 125                        signed-real-literal-constant (R413), 36, 37, 86
result variable, 12, 423                          significand (R415), 36, 36
result-name, 275, 276, 278, 279, 401              size, 18, 424
RETURN statement, 280                             size of a common block, 97
return-stmt (R1235), 11, 15, 165, 280, 280        size of a storage sequence, 405
REWIND statement, 206                             SIZE= specifier, 191, 213
rewind-stmt (R925), 11, 205, 282                  source forms, 27
right-square-bracket (R462), 63, 63               source-variable (R632), 108, 109, 109, 110
round-edit-desc (R1017), 221, 221                 special characters, 24
ROUND= specifier, 183, 190, 213                    special-character, 23, 24
rounding mode, 423                                specific interface, 255
                                                  specific interface block, 255
S                                                 Specific names, 287
SAVE attribute, 82, 85, 89                        specific-binding (R441), 44, 44
SAVE statement, 89                                specification expression, 125, 424
save-stmt (R548), 10, 89, 401                     specification function, 126, 424
saved, 82                                         specification inquiry, 125
saved-entity (R549), 71, 89, 89                   specification-expr (R729), 67, 68, 70, 76, 125, 283



544                                     WORKING DRAFT                                    SEP 2002


SEP 2002                              WORKING DRAFT                                       J3/02-007R3



specification-part (R204), 9, 9, 45, 74, 84, 88, 126,        INTENT, 88
         127, 245, 246, 249, 250, 254, 275, 277, 282        INTRINSIC, 262
specification-stmt (R212), 10, 10                            list-directed input/output, 188
specifications, 67�99                                        NAMELIST, 93
standard-conforming program, 2, 424                         namelist input/output, 188
starting point, 102                                         NULLIFY, 111
stat-variable (R625), 108, 108, 109, 110, 112, 413          OPEN, 180
statement, 27, 424                                          OPTIONAL, 88
statement entity, 395, 424                                  PARAMETER, 88
statement function, 252, 281, 424                           POINTER, 89
Statement functions, 428                                    PRINT, 185
statement label, 26, 26, 424                                PRIVATE, 84
statement order, 13                                         PROTECTED, 89
statements                                                  PUBLIC, 84
    accessibility, 84                                       READ, 185
    ALLOCATABLE, 84                                         RETURN, 280
    ALLOCATE, 108                                           REWIND, 206
    arithmetic IF, 170                                      SAVE, 89
    assignment, 138                                         SELECT CASE, 158
    ASYNCHRONOUS, 85                                        STOP, 170
    attribute specification, 84�98                           TARGET, 90
    BACKSPACE, 205                                          type declaration, 67�83
    BIND, 85                                                unformatted input/output, 187
    CALL, 262                                               VALUE, 90
    CASE, 158                                               VOLATILE, 90
    CLOSE, 184                                              WHERE, 145
    COMMON, 96�99                                           WRITE, 185
    computed GO TO, 169                                 STATUS= specifier, 184, 185
    CONTAINS, 280                                       stmt-function-stmt (R1237), 10, 246, 255, 281, 401
    CONTINUE, 170                                       STOP statement, 170
    CYCLE, 167                                          stop-code (R850), 170, 170
    DATA, 85                                            stop-stmt (R849), 11, 165, 170, 282
    data transfer, 185                                  storage associated, 406
    DEALLOCATE, 112                                     Storage association, 405
    DIMENSION, 88                                       storage association, 93�99, 405, 424
    DO, 164                                             storage sequence, 97, 405, 424
    DO WHILE, 164                                       storage unit, 405, 424
    END, 14                                             stream access, 174
    ENDFILE, 206                                        stream access input/output statement, 190
    ENTRY, 278                                          stream file, 171
    EQUIVALENCE, 93�96                                  STREAM= specifier, 213
    EXIT, 167                                           stride, 107, 424
    EXTERNAL, 259                                       stride (R621), 105, 105, 148, 150, 152, 194
    file positioning, 205                                string, see character string
    FLUSH, 206                                          struct, 424
    FORALL, 147, 153                                    structure, 16, 73, 425
    FORMAT, 219                                         structure component, 102, 425
    formatted input/output, 187                         structure constructor, 57, 425
    FUNCTION, 275                                       structure-component (R614), 85, 86, 101�103, 103,
    GO TO, 169                                                   108, 111
    IF, 157                                             structure-constructor (R449), 57, 58, 61, 86, 117,
    IMPLICIT, 90                                                 282
    input/output, 171�216                               subcomponent, 104, 425
    INQUIRE, 207                                        subobject, 425



SEP 2002                                    WORKING DRAFT                                              545


J3/02-007R3                                 WORKING DRAFT                                   SEP 2002



subobjects, 16                                      type equality, 53
subprogram, 425                                     type incompatible, 74
subroutine, 12, 425                                 type parameter, 15, 32, 33, 35, 425
subroutine reference, 272                           type parameter inquiry, 104
subroutine subprogram, 277, 425                     type parameter keyword, 19
subroutine-name, 254, 255, 277, 278, 396            Type parameter order, 56
subroutine-stmt (R1231), 9, 254, 255, 275, 277,     type parameter order, 425
            277, 278, 396, 401                      type specifier, 71
subroutine-subprogram (R1230), 9, 10, 246, 277           CHARACTER, 72
subscript, 425                                           COMPLEX, 71
subscript (R618), 6, 86, 105, 105, 148, 152, 194         DOUBLE PRECISION, 71
subscript triplet, 107, 425                              INTEGER, 71
subscript-triplet (R620), 105, 105, 106                  LOGICAL, 73
substring, 102, 425                                      REAL, 71
substring (R609), 94, 101, 102                           derived type, 73
substring-range (R611), 102, 102, 104, 105, 194          TYPE, 73
                                                    TYPE type specifier, 73
T                                                   type-alias (R453), 54, 61, 61
target, 18, 425                                     type-alias-name, 57, 61, 62, 67, 401
TARGET attribute, 82, 90                            type-alias-stmt (R452), 10, 61, 401
TARGET statement, 90                                type-attr-spec (R425), 41, 41, 42, 46, 93
target-stmt (R551), 10, 90, 401                     type-bound procedure, 49, 425
terminal point, 175                                 type-bound-procedure-part (R438), 41, 42, 44, 51,
TKR compatible, 74                                           387
TKR incompatible, 74                                type-declaration-stmt (R501), 10, 67, 68, 72, 282,
totally [storage] associated, 406                            401
transfer of control, 156, 169, 215, 216             type-guard-stmt (R823), 162, 162
transformational function, 425                      type-name, 41, 42, 44, 45, 54, 57, 73, 425
transformational functions, 287                     type-param-attr-spec (R427), 42, 42, 45
TYPE, 41                                            type-param-def-stmt (R426), 41, 42, 42
type, 15, 31�64, 425                                type-param-inquiry (R615), 104, 104, 117, 398
       base, 54                                     type-param-name, 41�43, 45, 104, 117, 398, 401
       character, 38�40                             type-param-spec (R448), 57, 57
       complex, 37                                  type-param-value (R401), 32, 32, 33, 43, 57, 61, 67,
       concept, 31                                           68, 70, 72, 109
       declared, 73                                 type-spec (R503), 63, 64, 67, 67, 72, 73, 108, 109
       derived types, 59
       dynamic, 73                                  U
       expression, 123                              ultimate component, 426
       extended, 54                                 ultimate components, 41
       extensible, 54                               unallocated, 111
       extension, 54                                undefined, 20, 426
       integer, 33                                  undefinition of variables, 409
       intrinsic types, 33�40                       underscore (R303), 23, 24
       logical, 40                                  unformatted data transfer, 196
       operation, 124                               unformatted input/output statement, 187
       parent, 54                                   unformatted record, 172
       primary, 123                                 UNFORMATTED= specifier, 213
       real, 35�36                                  unit, 178
type alias, 61, 61                                  unlimited polymorphic, 73
type compatible, 73, 425                            unsaved, 82
type conformance, 139                               unsigned, 426
type declaration statement, 425                     unspecified storage unit, 405, 426
type declaration statements, 67�83                  upper-bound (R518), 76, 76, 143



546                                   WORKING DRAFT                                         SEP 2002


SEP 2002                                 WORKING DRAFT                                  J3/02-007R3


use associated, 247                                      X
Use association, 400                                     xyz-list (R101), 6
use association, 400, 426                                xyz-name (R102), 6
USE statement, 247
use-defined-operator (R1115), 247, 248, 248               Z
use-name, 84, 247, 248                                   zero-size array, 18, 77, 87
use-stmt (R1109), 9, 247, 248, 401


V
v (R1010), 201, 221, 221, 231
value, 150
VALUE attribute, 83, 90
value separator, 235
VALUE statement, 90
value-stmt (R552), 10, 90
variable, 426
variable (R601), 60, 85, 86, 101, 101, 109, 114, 117,
         138�143, 146, 147, 151, 160�163, 191, 263,
         282, 413
variable-name (R602), 93, 94, 96, 97, 101, 101, 102,
         108, 111, 142, 143, 401, 413
variables, 17
     definition & undefinition, 409
vector subscript, 107, 426
vector-subscript (R622), 105, 105, 106
void, 426
VOLATILE attribute, 83, 90
VOLATILE statement, 90
volatile-stmt (R553), 10, 90


W
w (R1006), 220, 221, 221, 224�227, 229, 230, 236,
         238
wait operation, 184, 193, 203, 204
WAIT statement, 203
wait-spec (R922), 204, 204
wait-stmt (R921), 11, 204, 282
WHERE construct, 145
WHERE statement, 145
where-assignment-stmt (R746), 145, 145, 147, 151,
         417
where-body-construct (R745), 145, 145, 146, 147
where-construct (R743), 11, 145, 145, 148, 151
where-construct-name, 145
where-construct-stmt (R744), 145, 145, 146, 151,
         169
where-stmt (R742), 11, 145, 145, 148, 151
whole array, 104, 426
WRITE statement, 185
write-stmt (R911), 11, 185, 186, 282, 413
WRITE= specifier, 213
writing, 171



SEP 2002                                     WORKING DRAFT                                     547