USE

 Gives a program unit accessibility to public entities in a module.
 It takes one of the following forms:

    USE name [, rename-ls]
    USE name, ONLY : [only-ls]

    name       Is the name of the module.

    rename-ls  Is one or more items having the following 
               form:

       local-name => mod-name

       local-name  Is the name of the entity in the program 
                   unit using the module.

       mod-name    Is the name of a public entity in the module. 

    only-ls   Is the name of a public entity in the module
              or a generic identifier (a generic name, defined
              operator, or defined assignment).
     
              An entity in the "only-ls" can also take the form:

       [local-name =>] mod-name

 If the USE statement is specified without the ONLY option, the
 program unit has access to all public entities in the named module.

 If the USE statement is specified with the ONLY option, the program
 unit has access to only those entities following the option.

 If more than one USE statement for a given module appears in a
 scoping unit, the following rules apply:

  o  If one USE statement does not have the ONLY option, all public
     entities in the module are accessible, and any "rename-ls"s and
     "only-ls"s are interpreted as a single, concatenated
     "rename-ls".

  o  If all the USE statements have ONLY options, all the "only-ls"s
     are interpreted as a single, concatenated "only-ls".  Only
     those entities named in one or more of the "only-ls"s are
     accessible.


 If two or more generic interfaces that are accessible in a scoping
 unit have the same name, the same operator, or are both
 assignments, they are interpreted as a single generic interface.
 Otherwise, multiple accessible entities can have the same name only
 if no reference to the name is made in the scoping unit.

 The local names of entities made accessible by a USE statement must
 not be respecified with any attribute other than PUBLIC or PRIVATE.
 The local names can appear in namelist group lists, but not in a
 COMMON or EQUIVALENCE statement.

 EXAMPLES:

 The following shows examples of the USE statement:

   MODULE MOD_A
     INTEGER :: B, C
     REAL E(25,5), D(100)
   END MODULE MOD_A
   ...
   SUBROUTINE SUB_Y
     USE MOD_A, DX => D, EX => E   ! Array D has been renamed 
                                   ! DX and array E 
     ...                           ! has been renamed EX. Scalar 
                                   ! variables B 
   END SUBROUTINE SUB_Y            ! and C are also available to 
   ...                             ! this subroutine (using their 
                                   ! module names).
   SUBROUTINE SUB_Z
     USE MOD_A, ONLY: B, C         ! Only scalar variables B and 
                                   ! C are
     ...                           ! available to this subroutine
   END SUBROUTINE SUB_Z
   ...

 The following example shows a module containing common blocks:

   MODULE COLORS
     COMMON /BLOCKA/ C, D(15)
     COMMON /BLOCKB/ E, F
     ...
   END MODULE COLORS
   ...
   FUNCTION HUE(A, B)
     USE COLORS
     ...
   END FUNCTION HUE

 The USE statement makes all of the variables in the common blocks
 in module COLORS available to the function HUE.

 To provide data abstraction, a user-defined data type and
 operations to be performed on values of this type can be packaged
 together in a module.  The following example shows such a module:

   MODULE CALCULATION
     TYPE ITEM
       REAL :: X, Y
     END TYPE ITEM

     INTERFACE OPERATOR (+)
       MODULE PROCEDURE ITEM_CALC
     END INTERFACE

   CONTAINS
     FUNCTION ITEM_CALC (A1, A2)
       TYPE(ITEM) A1, A2, ITEM_CALC
       ...
     END FUNCTION ITEM_CALC
     ...
   END MODULE CALCULATION

   PROGRAM TOTALS
   USE CALCULATION
   TYPE(ITEM) X, Y, Z
     ...
     X = Y + Z
     ...
   END

 The USE statement allows program TOTALS access to both the type
 ITEM and the extended intrinsic operator + to perform calculations.