COMMON

 Defines one or more contiguous blocks of storage shared among
 separate subprograms.  You can define the same common block in
 different program units of your program.  The first COMMON
 statement in a program unit to name a common block defines it;
 subsequent COMMON statements that name the block reference it.  You
 can leave one common block (the "blank" common block) unnamed.

 Statement format:

    COMMON [/[cb]/] nlist[[,] /[cb] /nlist]...

    cb     Is a symbolic name that identifies the common block.

    nlist  Is one or more names of variables that identify items in
           the common block. The variable must not be a dummy 
           argument, allocatable array, automatic object, function, 
           function result, or entry to a procedure.  

           It must not have the PARAMETER attribute.  If an object 
           of derived type is specified, it must be a sequence type.

 A common block is a global entity, and must not have the same name
 as any other global entity in the program, such as a subroutine or
 function.

 Any common block name, blank or otherwise, can appear more than
 once in one or more COMMON statements in a program unit.  The list
 following each successive appearance of the same common block name
 is treated as a continuation of the list for the block associated
 with that name.

 A variable can appear in only one common block within a scoping
 unit.

 If an array is specified, it can be followed by an explicit-shape
 array specification.  The array must not have the POINTER attribute
 and each bound in the specification must be a constant
 specification expression.

 A pointer can only be associated with pointers of the same type,
 kind type parameters, and rank.

 Nonpointer variables can be associated if they are of different
 numeric type.

 A common block can have the same name as a variable, array, record,
 structure, or field.  However, in a program with one or more
 program units, a common block cannot have the same name as a
 function, subroutine, or entry name in the executable program.

 When common blocks from different program units have the same name,
 they share the same storage area when the units are combined into
 an executable program.

 Entities are assigned storage in common blocks on a one-for-one
 basis.  Thus, the entities assigned by a COMMON statement in one
 program unit should agree with the data type of entities placed in
 a common block by another program unit; for example, consider a
 program unit containing the following statement:

    COMMON CENTS

 Consider another program unit containing the following statements:

    INTEGER*2 MONEY
    COMMON MONEY

 When these program units are combined into an executable program,
 incorrect results can occur if the 2-byte integer variable MONEY is
 made to correspond to the lower-addressed two bytes of the real
 variable CENTS.

 Named common blocks must be declared to have the same size in each
 program unit.  Blank common can have different lengths in different
 program units.