A union declaration is a multistatement declaration defining a data
  area that can be shared intermittently during program execution by
  one or more fields or groups of fields.  A union declaration must
  be within a structure declaration.  A union declaration is
  initiated by a UNION statement and terminated by an END UNION
  statement.  Enclosed within these statements are two or more map
  declarations, initiated and terminated by MAP and END MAP
  statements.  Each unique field or group of fields is defined by a
  separate map declaration.

  A union declaration takes the following form:

     UNION
          mdcl
         [mdcl]
         ...
         [mdcl]
     END UNION

     Where "mdcl" represents:

     MAP
        fdcl
       [fdcl]
       ...
       [fdcl]
     END MAP

     fdcl  Is any declaration or combination of declarations
           of substructures, unions, or type declarations.

  As with normal Fortran type declarations, data can be initialized
  in field declaration statements in union declarations.  However, if
  fields within multiple map declarations in a single union are
  initialized, the data declarations are initialized in the order in
  which the statements appear.  As a result, only the final
  initialization takes effect and all of the preceding
  initializations are overwritten.

  The size of the shared area established for a union declaration is
  the size of the largest map defined for that union.  The size of a
  map is the sum of the sizes of the fields declared within it.

  As the variables or arrays declared in map fields in a union
  declaration are assigned values during program execution, the
  values are established in a record in the field shared with other
  map fields in the union.  The fields of only one of the map
  declarations are defined within a union at any given point in the
  execution of a program.  However, if you overlay one variable with
  another smaller variable, that portion of the initial variable is
  retained that is not overlaid.  Depending on the application, the
  retained portion of an overlaid variable may or may not contain
  meaningful data and can be utilized at a later point in the
  program.

  Manipulating data using union declarations is similar to the effect
  of using EQUIVALENCE statements.  The difference is that data
  entities specified within EQUIVALENCE statements are concurrently
  associated with a common storage location and the data residing
  there; with union declarations you can use one discrete storage
  location to alternately contain a variety of fields (arrays or
  variables).

  With union declarations, only one map declaration within a union
  declaration can be associated at any point in time with the storage
  location that they share.  Whenever a field within another map
  declaration in the same union declaration is referenced in your
  program, the fields in the prior map declaration become undefined
  and are succeeded by the fields in the map declaration containing
  the newly referenced field.

  In the following example, the structure WORDS_LONG is defined.
  This structure contains a union declaration defining two map
  fields.  The first map field consists of three INTEGER*2 variables
  (WORD_0, WORD_1, and WORD_2), and the second, an INTEGER*4
  variable, LONG:

     STRUCTURE /WORDS_LONG/
         UNION
             MAP
              INTEGER*2    WORD_0, WORD_1, WORD_2
             END MAP
             MAP
              INTEGER*4    LONG
             END MAP
         END UNION
     END STRUCTURE