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