Next: UNION and MAP, Previous: Read/Write after EOF marker, Up: Extensions implemented in GNU Fortran

#### 5.1.22 `STRUCTURE` and `RECORD`

Record structures are a pre-Fortran-90 vendor extension to create user-defined aggregate data types. Support for record structures in GNU Fortran can be enabled with the `-fdec-structure` compile flag. If you have a choice, you should instead use Fortran 90's “derived types”, which have a different syntax.

In many cases, record structures can easily be converted to derived types. To convert, replace `STRUCTURE /`structure-name`/` by `TYPE` type-name. Additionally, replace `RECORD /`structure-name`/` by `TYPE(`type-name`)`. Finally, in the component access, replace the period (`.`) by the percent sign (`%`).

Here is an example of code using the non portable record structure syntax:

         ! Declaring a structure named ``item'' and containing three fields:
         ! an integer ID, an description string and a floating-point price.
         STRUCTURE /item/
           INTEGER id
           CHARACTER(LEN=200) description
           REAL price
         END STRUCTURE

         ! Define two variables, an single record of type ``item''
         ! named ``pear'', and an array of items named ``store_catalog''
         RECORD /item/ pear, store_catalog(100)

         ! We can directly access the fields of both variables
         pear.id = 92316
         pear.description = "juicy D'Anjou pear"
         pear.price = 0.15
         store_catalog(7).id = 7831
         store_catalog(7).description = "milk bottle"
         store_catalog(7).price = 1.2

         ! We can also manipulate the whole structure
         store_catalog(12) = pear
         print *, store_catalog(12)

This code can easily be rewritten in the Fortran 90 syntax as following:

         ! ``STRUCTURE /name/ ... END STRUCTURE'' becomes
         ! ``TYPE name ... END TYPE''
         TYPE item
           INTEGER id
           CHARACTER(LEN=200) description
           REAL price
         END TYPE

         ! ``RECORD /name/ variable'' becomes ``TYPE(name) variable''
         TYPE(item) pear, store_catalog(100)

         ! Instead of using a dot (.) to access fields of a record, the
         ! standard syntax uses a percent sign (%)
         pear%id = 92316
         pear%description = "juicy D'Anjou pear"
         pear%price = 0.15
         store_catalog(7)%id = 7831
         store_catalog(7)%description = "milk bottle"
         store_catalog(7)%price = 1.2

         ! Assignments of a whole variable do not change
         store_catalog(12) = pear
         print *, store_catalog(12)

GNU Fortran implements STRUCTURES like derived types with the following rules and exceptions:

- Structures act like derived types with the `SEQUENCE` attribute. Otherwise they may contain no specifiers.
- Structures may contain a special field with the name `%FILL`. This will create an anonymous component which cannot be accessed but occupies space just as if a component of the same type was declared in its place, useful for alignment purposes. As an example, the following structure will consist of at least sixteen bytes:

                structure /padded/
                  character(4) start
                  character(8) %FILL
                  character(4) end
                end structure

- Structures may share names with other symbols. For example, the following is invalid for derived types, but valid for structures:

                structure /header/
                  ! ...
                end structure
                record /header/ header

- Structure types may be declared nested within another parent structure. The syntax is:

                structure /type-name/
                    ...
                    structure [/<type-name>/] <field-list>
                ...

  The type name may be ommitted, in which case the structure type itself is anonymous, and other structures of the same type cannot be instantiated. The following shows some examples:

                structure /appointment/
                  ! nested structure definition: app_time is an array of two 'time'
                  structure /time/ app_time (2)
                    integer(1) hour, minute
                  end structure
                  character(10) memo
                end structure

                ! The 'time' structure is still usable
                record /time/ now
                now = time(5, 30)

                ...

                structure /appointment/
                  ! anonymous nested structure definition
                  structure start, end
                    integer(1) hour, minute
                  end structure
                  character(10) memo
                end structure

- Structures may contain `UNION` blocks. For more detail see the section on UNION and MAP.
- Structures support old-style initialization of components, like those described in Old-style variable initialization. For array initializers, an initializer may contain a repeat specification of the form `<literal-integer> * <constant-initializer>`. The value of the integer indicates the number of times to repeat the constant initializer when expanding the initializer list.