Specification Statements

by Michael Metcalf / CERN CN-AS

Implicit typing

The imlicit typing rules of FORTRAN 77 still hold. However, it is good practice to explicitly type all variables, and this can be forced by inserting the statement

        IMPLICIT NONE

at the beginning of each prorgam unit.

PARAMETER attribute

A named constant can be specified directly by adding the PARAMETER attribute and the constant values to a type statement:

     REAL, DIMENSION(3), PARAMETER :: field = (/ 0., 1., 2. /)
     TYPE(triplet), PARAMETER :: t =                           &
                                triplet( 0., (/ 0., 0., 0. /) )

DATA statement

The DATA statement can be used also for arrays and variables of derived type. It is also the only way to initialise just parts of such objects, as well as to initialise to binary, octal or hexadecimal values:

       TYPE(triplet) :: t1, t2
       DATA t1/triplet( 0., (/ 0., 1., 2. /) )/, t2%u/0./
       DATA array(1:64) / 64*0/
       DATA i, j, k/ B'01010101', O'77', Z'ff'/

Characters

There are many variations on the way character arrays may be specified. The shortest and longest are

CHARACTER name(4, 5)*20
CHARACTER (KIND = kanji, LEN = 20), DIMENSION (4, 5) :: name

Initialization expressions

The values used in DATA and PARAMETER statements, or with these attributes, are constant expressions that may include references to: array and structure constructors, elemental intrinsic functions with integer or character arguments and results, and the six transformational functions REPEAT, SELECTED_INT_KIND, TRIM, SELECTED_REAL_KIND, RESHAPE and TRANSFER:

     INTEGER, PARAMETER :: long = SELECTED_REAL_KIND(12),   &
                       array(3) = (/ 1, 2, 3 /)

Specification expressions

It is possible to specify details of variables using any non-constant, scalar, integer expression that may also include inquiry function references:

     SUBROUTINE s(b, m, c)
        USE mod                                 ! contains a
        REAL, DIMENSION(:, :)             :: b
        REAL, DIMENSION(UBOUND(b, 1) + 5) :: x
        INTEGER                              m
        CHARACTER(LEN=*)                     c
        CHARACTER(LEN= m + LEN(c))           cc
        REAL (SELECTED_REAL_KIND(2*PRECISION(a))) z

PUBLIC and PRIVATE

These attributes are used in specifications in modules to limit the scope of entities. The attribute form is

     REAL, PUBLIC     :: x, y, z           ! default
     INTEGER, PRIVATE :: u, v, w

and the statement form is

     PUBLIC  :: x, y, z, OPERATOR(.add.)
     PRIVATE :: u, v, w, ASSIGNMENT(=), OPERATOR(*)

The statement form has to be used to limit access to operators, and can also be used to change the overall default:

     PRIVATE                        ! sets default for module
     PUBLIC  :: only_this

For derived types there are three possibilities: the type and its components are all PUBLIC, the type is PUBLIC and its components PRIVATE (the type only is visible and one can change its details easily), or all of it is PRIVATE (for internal use in the module only):

     MODULE mine
        PRIVATE
        TYPE, PUBLIC :: list
           REAL x, y
           TYPE(list), POINTER :: next
        END TYPE list
        TYPE(list) :: tree
        :
     END MODULE mine

USE statement

To gain access to entities in a module, we use the USE statement. It has options to resolve name clashes if an imported name is the same as a local one:

     USE mine, local_list => list

or to restrict the used entities to a specified set:

     USE mine, ONLY : list

These may be combined:

     USE mine, ONLY : local_list => list

M.G. (October 19th 1995)