The syntax of a type declaration within a record structure is
 identical to that of a normal Fortran type declaration statement:
 it includes a data type (for example, INTEGER), one or more names
 of variables or arrays; and optionally, one or more data
 initialization values.

 The following rules and behavior apply to type declarations in
 record structures:

  o  %FILL can be specified in place of a field name to leave space
     in a record for purposes such as alignment.  This creates an
     unnamed field.

     %FILL can have an array declarator; for example:

        INTEGER %FILL (2,2)

     Unnamed fields cannot be initialized.  For example, the
     following statement is invalid and generates an error message:

        INTEGER*4 %FILL /1980/

  o  Initial values can be supplied in field declaration statements.
     These initial values are supplied for all records that are
     declared using this structure.  Fields not initialized will
     have undefined values when variables are declared by means of
     RECORD statements.  Unnamed fields cannot be initialized; they
     are always undefined.

  o  Field names must always be given explicit data types.  The
     IMPLICIT statement has no effect on statements within a
     structure declaration.

  o  All Fortran data types are allowed in field declarations.

  o  Any required array dimensions must be specified in the field
     declaration statements.  DIMENSION statements cannot be used to
     define field names.

  o  Adjustable or assumed sized arrays and passed-length CHARACTER
     declarations are not allowed in field declarations.

  o  Field names within the same declaration level must be unique,
     but an inner structure declaration (substructure declaration)
     can include field names used in an outer structure declaration
     without conflict.

 A field within a structure can itself be a structured item composed
 of other fields, other structures, or both.  You can declare a
 substructure in two ways:

  o  By nesting structure declarations within other structure or
     union declarations (with the limitation that you cannot refer
     to a structure inside itself at any level of nesting).

     One or more field names must be defined in the STRUCTURE
     statement for the substructure because all fields in a
     structure must be named.  In this case, the substructure is
     being used as a field within a structure or union.

     Field names within the same declaration nesting level must be
     unique, but an inner structure declaration can include field
     names used in an outer structure declaration without conflict.

     %FILL can be specified in place of a field name to leave space
     in a record for purposes such as alignment.

  o  By using a RECORD statement that specifies another previously
     defined record structure, thereby including it in the structure
     being declared.

 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

 PARAMETER statements:  PARAMETER statements can appear in a
 structure declaration, but cannot be given a data type within the
 declaration block.  Consider the following:

    STRUCTURE /ABC/
        INTEGER*4 P
        PARAMETER (P=4)
        REAL*4 F
    END STRUCTURE
        REAL*4 A(P)

 In this example, the INTEGER*4 statement does not provide the data
 type for PARAMETER constant P, but instead declares a record field
 P in structure ABC.  The subsequent PARAMETER statement declares a
 new, different symbol which is given the implicit data type for
 identifiers beginning with the letter P.

 Type declarations for PARAMETER symbolic names must precede the
 PARAMETER statement and be outside of a STRUCTURE declaration, as
 follows:

        INTEGER*4 P
    STRUCTURE /ABC/
        PARAMETER (P=4)
        REAL*4 F
    END STRUCTURE
        REAL*4 A(P)

 For more information on PARAMETER statements, see STATEMENTS
 PARAMETER in this Help file.