There are two kinds of records: data and end-of-file. A data record is a sequence of values.

The values in a data record can be represented in one of two ways: formatted or unformatted. Formatted data consists of characters that are viewable on some medium. For example, a record could contain the following four character values:

These are intended to represent the two numbers 6 and 11. In this case, the record might be represented schematically as shown in Figure 1-1.

Figure 1-1. A formatted record with four character values

Unformatted data consists of values represented just as they are stored in computer memory. For example, if integers are stored using a binary representation, an unformatted record, consisting of two integer values, 6 and 11, might look like Figure 1-2.

Figure 1-2. An unformatted record with two integer values

The values in a data record are either all formatted or all unformatted. A formatted record is one that contains only formatted data. It can be created by a person typing at a terminal or by a Fortran program that converts values stored internally into character strings that form readable representations of those values. When a program reads formatted data, the characters must be converted to the computer's internal representation of values. Even character values can be converted from one character representation in the record to another internal representation. The length of a formatted record is the number of characters in it; the length can be zero.

An unformatted record is one that contains only unformatted data. Unformatted records usually are created by running a Fortran program, but they can be created by other means. Unformatted data often requires less space on an external device. Also, it is usually faster to read and write because no conversion is required. However, it is not as suitable for reading by people and usually it is not suitable for transferring data from one computer to another because the internal representation of values is machine-dependent. The length of an unformatted data record depends on the number of values in it, but is measured in bytes; it can be zero. The length of an unformatted record that will be produced by a particular output list can be determined with the INQUIRE statement.

In general, a formatted record is read and written by a formatted data transfer I/O statement, and an unformatted record is read and written by an unformatted data transfer I/O statement.

Another kind of record is the end-of-file record; it has no value and has no length.

On UNICOS and UNICOS/mk systems, certain file structures allow more than one end-of-file record in a file. The COS blocking format is the default file structure for all UNICOS Fortran sequential unformatted files (except tape files). It can have multiple end-of-file records. For general information on records supported on UNICOS and UNICOS/mk systems, see the Application Programmer's I/O Guide.

For UNICOS structures other than COS blocked, and for structures on IRIX systems, an end-of-file record is always the last record of a file. It is used to mark the end of a file. To write it explicitly for files connected for sequential access, use the ENDFILE statement; to write it implicitly, use a file positioning statement (REWIND or BACKSPACE statement), close the file (CLOSE statement), open the file (OPEN statement), or use normal termination of a program.

---

Note: The Fortran standard does not allow for multiple end-of-file records in a file.

---

A file can be named. The length of the file name and path name depend on the platform, as follows:

A distinction is made between files that are located on an external device like a disk, and files in memory accessible to the program. These two kinds of files are as follows:

The use of these files is illustrated schematically in Figure 1-3.

Figure 1-3. Internal and external files

Each file being processed by a program has a position. During the course of program execution, records are read or written, causing the file position to change. Also, there are other Fortran statements that cause the file position to change; an example is the BACKSPACE statement. The action produced by the I/O statements is described in terms of the file position, so it is important that file position be discussed in detail.

The initial point is the point just before the first record. The terminal point is the point just after the last record. If the file is empty, the initial point and the terminal point are the same. A file position can become indeterminate, in particular, when an error condition occurs. When the file position becomes indeterminate, the programmer cannot rely on the file being in any particular position.

A file can be positioned between records. In the example pictured in Figure 1-4, the file is positioned between records 2 and 3. In this case, record 2 is the preceding record and record 3 is the next record. Of course, if a file is positioned at its initial point, there is no preceding record, and there is no next record if it is positioned at its terminal point.

Figure 1-4. A file positioned between records

There may be a current record during execution of an I/O statement or after completion of a nonadvancing I/O statement as shown in Figure 1-5 where record 2 is the current record. If the file is positioned within a current record, the preceding record is the record immediately previous to the current record, unless the current record is also the initial record, in which case there is no preceding record. Similarly, the next record is the record immediately following the current record, unless the current record is also the final record, in which case there is no next record.

Figure 1-5. A file positioned with a current record

When there is a current record, the file is positioned at the initial point of the record, between values in the record, or at the terminal point of the record.

An internal file is always positioned at the beginning of a record just prior to data transfer.

Advancing I/O is record oriented; completion of such an operation always positions a file at the end of a record or between records, unless an error condition occurs. In contrast, nonadvancing I/O is character oriented; after reading and writing, the file can be positioned between characters within the current record.

While reading a file, the position of a nonadvancing file depends on whether success, data transfer, error, end-of-file, or end-of-record conditions occur while reading the file. The file position is indeterminate following an error condition when reading a file.

While writing a file, the position of a nonadvancing file depends on whether success, data transfer, or error conditions occur while writing the file. The file position is indeterminate following an error condition when writing a file.

When a nonadvancing input operation is performed, the file can be positioned after the last character of the file and before the logical or physical end-of-record. A subsequent nonadvancing input operation causes an end-of-record condition to occur, regardless of whether this record is the last record of the file. If another read operation is executed after the end-of-record condition occurs and the record is the last record of the file, an end-of-file condition occurs.

There are two access file methods:

Some files can be accessed by both methods; other files can be restricted to one access method or the other. For example, a magnetic tape can be accessed only sequentially. While each file is connected, it has a set of permissible access methods, which usually means that it can be accessed either sequentially or directly. However, a file cannot be connected for both direct and sequential access simultaneously; that is, if a file is connected for direct access, it must be disconnected with a CLOSE statement and reconnected with an OPEN statement specifying sequential access before it can be referenced in a sequential access data transfer statement, and vice versa.

The actual file access method used to read or write the file is not strictly a property of the file itself, but is indicated when the file is connected to a unit or when the file is created, if the file is preconnected. The same file can be accessed sequentially by a program, then disconnected, and then later accessed directly by the same program, if both types of access are permitted for the file.

I/O statements refer to a particular file by providing an I/O unit. An I/O unit is either an external unit or an internal unit. An external unit is either a nonnegative integer or an asterisk (*). When an external file is a nonnegative integer, it is called an external file unit. Table 1-1, lists the unit numbers supported by the CF90 and MIPSpro 7 Fortran 90 compilers.

A unit number identifies one and only one external unit in all program units in a Fortran program at a time.

File positioning, file connection, and inquiry statements must use an external unit.

If you are running the CF90 compiler on a UNICOS or UNICOS/mk system, an external_unit_name can be used to designate an external file unit in a data transfer or file positioning statement; if you use an external name, it must be from 1 to 7 characters in length and be enclosed in apostrophes or quotation marks.

---

Note: The Fortran standard does not describe the use of external names to designate a unit.

---

An internal unit must be a default character variable. The name of an internal file also is called a unit.

The I/O control specifiers are defined as follows:

[UNIT = ]io_unit

[ FMT = ]format

[ NML = ]namelist_group_name

REC = scalar_int_expr

IOSTAT = scalar_default_int_variable

ERR = label

END = label

ADVANCE = scalar_char_expr

SIZE = scalar_default_int_variable

EOR = label

The UNIT= specifier, with or without the keyword UNIT, is called a unit specifier.

The FMT= specifier, with or without the keyword FMT, is called a format specifier.

The NML= specifier, with or without the keyword NML, is called a namelist specifier.

The data transfer statement is called a formatted I/O statement if a format or namelist group name specifier is present; it is called an unformatted I/O statement if neither is present. If a namelist group name specifier is present, it is called a namelist I/O statement. It is called a direct access I/O statement if a REC= specifier is present; otherwise, it is called a sequential access I/O statement.

The I/O control specification list must contain a unit specifier and can contain any of the other I/O control specifiers (but none can appear more than once). An FMT= and an NML= specifier cannot both appear in the same list.

This section describes the form and effect of the control information specifiers that are used in the data transfer statements. The NML=, ADVANCE=, END=, EOR=, REC=, and SIZE= specifiers are each unique to one of the forms of the data transfer statements, whereas the other specifiers are used in more than one form. In particular, NML= is used in the namelist data transfer statement; the ADVANCE=, EOR=, and SIZE= specifiers are used in input data transfer statements to specify nonadvancing formatted sequential data transfer; and the REC= specifier is used for direct access data transfer.

UNIT= Control Specifier

The format of the UNIT= control specifier is as follows:

[ UNIT = ]io_unit

An io_unit is defined as follows:

	io_unit	is	external_file_unit
		or	*
		or	internal_file_unit
EXT		or	unit_name
	external_file_unit	is	scalar_int_expr
	internal_file_unit	is	char_variable

---

Note: The Fortran standard does not specify the use of a unit_name.

---

If you specify a scalar_int_expr for io_unit, it must be nonnegative and in the range of 0 through HUGE(3i). Units 100 through 103 are reserved. For more information on units, see Table 1-1.

Specifying an asterisk (*) for io_unit indicates a default external unit. It is the same unit number that would be defined if a READ or PRINT statement appeared without the unit number. The io_unit specified by an asterisk can be used only for formatted sequential access. The external unit used for a READ statement without a unit specifier or a READ statement with an asterisk unit specifier need not be the same as that used for a PRINT statement or WRITE statement with an asterisk unit specifier.

If you are using the CF90 compiler on a UNICOS or UNICOS/mk system, specifying an external_unit_name indicates a file name. The name can consist of 1 to 7 left-justified, blank-filled, or zero-filled ASCII characters. The use of uppercase and lowercase is significant for file names.

A unit specifier is required. A unit number identifies one and only one external unit in all program units in a Fortran program.

If the UNIT keyword is omitted, the I/O unit must be first. In this case, the keyword FMT or NML can be omitted from the format or namelist specifier. If the format or namelist specifier appears in the list, it must be the second specifier in the list.

[ FMT = ]format

char_expr

label

*

[ NML = ]namelist_group_name

ADVANCE = scalar_char_expr

END = label

EOR = label

ERR = label

IOSTAT = scalar_default_int_variable

explain lib-5000

REC = scalar_int_expr

SIZE = scalar_default_int_variable

The I/O item list consists basically of a list of variables in a READ statement and a list of expressions in a WRITE or PRINT statement. In addition, in any of these statements, the I/O item list can contain an I/O implied-DO list, containing a list of variables or expressions indexed by DO variables.

The components of the I/O lists are defined as follows:

variable

io_implied_do

expr

io_implied_do

(io_implied_do_object_list, io_implied_do_control)

input_item

output_item

do_variable = scalar_numeric_expr,
scalar_numeric_expr[, scalar_numeric_expr]

The DO variable must be a scalar integer or real variable. If it is real, it must be default real or double-precision real.

---

Note: The Fortran standard does not specify real or double-precision DO variables. The CF90 and MIPSpro 7 Fortran 90 compilers support these types as an extension to the Fortran standard.

---

Each scalar numeric expression must be of type integer or real. If it is of type real, each must be of type default real or default double precision; the use of such real expressions is considered obsolescent. They need not be all of the same type nor of the type of the DO variable.

The DO variable must not be one of the input items in the implied-DO; it must not be associated with an input item either.

Two nested implied-DOs must not have the same (or associated) DO variables.

An implied-DO object, when it is part of an input item, must itself be an input item; that is, it must be a variable or an implied-DO object whose objects are ultimately variables. Similarly, an implied-DO object, when it is part of an output item, must itself be an output item; that is, it must be an expression or an implied-DO object whose objects are ultimately expressions.

For an I/O implied-DO, the loop is initialized, executed, and terminated in the same manner as for the DO construct. Its iteration count is established at the beginning of processing of the items that constitute the I/O implied-DO.

An array appearing without subscripts in an I/O list is treated the same as if all elements of the array appeared in array-element order. In the following example, assume UP is an array of shape (2,3):

READ *, UP

The preceding statement is the same as the following code:

READ *, UP(1,1), UP(2,1), UP(1,2),  &
        UP(2,2), UP(1,3), UP(2,3)

When a subscripted array is an input item, it is possible that when a value is transferred from the file to the variable, it might affect another part of the input item. This is not allowed. Consider the following READ statements, for example:

INTEGER  A(100), V(10)

READ *, A(A)
READ *, A(A(1):A(9))
! Suppose V's elements are defined with
! values in the range 1 to 100.
READ *, A(V)

The first two READ statements are not valid because the data values read affect other parts of array A. The third READ statement is allowed as long as no two elements of V have the same value.

Assumed-size arrays cannot appear in I/O lists unless a subscript, a section subscript specifying an upper bound, or a vector subscript appears in the last dimension.

In formatted I/O, a structure is treated as if, in place of the structure, all components were listed in the order of the components in the derived-type definition. In the following statement, assume that FIRECHIEF is a structure of type PERSON:

READ *, FIRECHIEF

The preceding statement is the same as the following:

READ *, FIRECHIEF%AGE, FIRECHIEF%NAME

A pointer can be an I/O list item but it must be associated with a target at the time the data transfer statement is executed. For an input item, the data in the file is transferred to the associated target. For an output item, the target associated with the pointer must be defined, and the value of the target is transferred to the file.

On UNICOS and UNICOS/mk systems, the following types of items cannot be used in an I/O list: a structure with an ultimate component that is a pointer, auxiliary variables, or auxiliary arrays.

---

Note: The Fortran standard does not specify auxiliary variables or auxiliary arrays.

---

A constant or an expression with operators, parentheses, or function references cannot appear as an input list item, but can appear as an output list item. A function reference in an output list must not cause execution of another I/O statement on this same unit.

---

Note: The Fortran standard does not allow the execution of another I/O statement on any unit through a function reference in an I/O list. For more information on restrictions, see “Restrictions on I/O Specifiers, List Items, and Statements”.

---

An input list item, or an entity associated with it, must not contain any portion of an established format specification.

On output, every entity whose value is to be written must be defined.

For formatted input and output, the file consists of characters. These characters are converted into representations suitable for storing in the computer memory during input and converted from an internal representation to characters on output. When a file is accessed sequentially, records are processed in the order in which they appear in the file.

The explicitly formatted, advancing, sequential access data transfer statements have the following formats:

READ ([ UNIT = ]io_unit, &
[ FMT = ]format &
[, IOSTAT = scalar_default_int_variable] &
[, ERR = label] &
[, END = label] &
[, ADVANCE = 'YES' ]) &
[, input-item-list]
READ format[, input_item_list]
WRITE ([ UNIT = ]io_unit, &
[ FMT = ]format &
[, IOSTAT = scalar_default_int_variable] &
[, ERR = label] &
[, ADVANCE = 'YES' ]) &
[output_item_list]
PRINT format[, output_item_list]
WRITE format[, output_item_list]

The I/O unit is a scalar integer expression with a nonnegative value, an asterisk (*), or a character literal constant (external name). All three I/O unit forms indicate that the unit is a formatted sequential access external unit.

---

Note: The Fortran standard does not specify the use of a character literal constant (external name) as an I/O unit.

---

If an ADVANCE= specifier is present, the format must not be an asterisk (*).

When an advancing I/O statement is executed, reading or writing of data begins with the next character in the file. If a previous I/O statement was a nonadvancing statement, the next character transferred may be in the middle of a record, even if the statement being executed is an advancing statement. The essential difference between advancing and nonadvancing sequential data transfer is that an advancing I/O statement always leaves the file positioned at the end of the record.

During the data transfer, data is transferred with editing between the file and the entities specified by the I/O list. Format control is initiated and editing is performed as described in Chapter 2, “Input and Output (I/O) Editing”. The current record and possibly additional records are read or written.

For the data transfer, values can be transmitted to or from objects of intrinsic or derived types. In the latter case, the transmission is in the form of values of intrinsic types to or from the components of intrinsic types, which ultimately comprise these structured objects.

For input data transfer, the file must be positioned so that the record read is a formatted record or an end-of-file record.

For input data transfer, the input record is logically padded with blanks to satisfy an input list and format specification that requires more characters than the record contains, unless the PAD= specifier is specified as NO in the OPEN statement. If the PAD= specifier is NO, the input list and format specification must not require more characters from the record than the record contains.

For output data transfer, the output list and format specification must not specify more characters for a record than the record size; recall that the record size for an external file is specified by a RECL= specifier in the OPEN statement.

If the file is connected for formatted I/O, unformatted data transfer is prohibited.

Execution of an advancing sequential access data transfer statement terminates when one of the following occurs:

Example of formatted READ statements are as follows:

! Assume that FMT_5 is a character string
! whose value is a valid format specification.
READ (5, 100, ERR=99, END=200)  &
               A, B, (C(I), I = 1, 40)
READ (9, IOSTAT=IEND, FMT=FMT_5) X, Y
READ (FMT="(5E20.0)", UNIT=5,  &
      ADVANCE="YES") (Y(I), I = 1, KK)
READ 100, X, Y

Examples of WRITE statements are as follows:

! Assume FMT_103 is a character string with a
! valid format specification.
WRITE (9, FMT_103, IOSTAT=IS, ERR=99) A, B, C, S
WRITE (FMT=105, ERR=9, UNIT=7)  X
WRITE (*, "(F10.5)")  X
PRINT "(A, E14.6)", " Y = ", Y

For unformatted sequential input and output, the file consists of values stored using an internal binary representation. This means that little or no conversion is required during input and output.

Unformatted sequential access data transfer statements are the READ and WRITE statements with no format specifier or namelist group name specifier. The formats are as follows:

READ ([ UNIT = ]scalar_int_expr &
[, IOSTAT = scalar_default_int_variable] &
[, ERR = label] &
[, END = label]) &
[input_item_list]
WRITE ([ UNIT = ]scalar_int_expr &
[, IOSTAT = scalar_default_int_variable] &
[, ERR = label]) &
[output_item_list]

Data is transferred without editing between the current record and the entities specified by the I/O list. Exactly one record is read or written.

Objects of intrinsic or derived types can be transferred through an unformatted data transfer statement.

For input data transfer, the file must be positioned so that the record read is an unformatted record or an end-of-file record.

For input data transfer, the number of values required by the input list must be less than or equal to the number of values in the record. Each value in the record must be of the same type as the corresponding entity in the input list, except that one complex value may correspond to two real list entities or two real values may correspond to one complex list entity. The type parameters of the corresponding entities must be the same; if two real values correspond to one complex entity or one complex value corresponds to two real entities, all three must have the same kind type parameter values. If an entity in the input list is of type character, the character entity must have the same length as the character value.

On output, if the file is connected for unformatted sequential access data transfer, the record is created with a length sufficient to hold the values from the output list. This length must be one of the set of allowed record lengths for the file and must not exceed the value specified in the RECL= specifier, if any, of the OPEN statement that established the connection.

Execution of an unformatted sequential access data transfer statement terminates when one of the following occurs:

If the file is connected for unformatted I/O, formatted data transfer is prohibited.

The following are examples of unformatted sequential access READ statements :

READ (5, ERR=99, END=100)  A, B, (C(I), I = 1, 40)
READ (IOSTAT=IEND, UNIT=9) X, Y
READ (5) Y

The following are examples of unformatted sequential access WRITE statements:

WRITE (9, IOSTAT=IS, ERR=99) A, B, C, S
WRITE (ERR=99, UNIT=7) X
WRITE (9) X

If the access is sequential, the file is positioned at the beginning of the next record prior to data transfer and positioned at the end of the record when the I/O is finished, because nonadvancing unformatted I/O is not permitted.

Nonadvancing formatted sequential I/O provides the capability of reading or writing part of a record. It leaves the file positioned after the last character read or written, rather than skipping to the end of the record. Processing of nonadvancing input continues within a current record, until an end-of-record condition occurs. Nonadvancing input statements can read varying-length records and determine their lengths. Nonadvancing I/O is sometimes called partial record or stream I/O. It may be used only with explicitly formatted, external files connected for sequential access.

The formats for the nonadvancing I/O statements are as follows:

READ ([ UNIT = ]io_unit, &
[ FMT = ]format, &
ADVANCE = 'NO' &
[, SIZE = scalar_default_int_variable] &
[, EOR = label] &
[, IOSTAT = scalar_default_int_variable] &
[, ERR = label] &
[, END = label]) &
[input_item_list]
WRITE ([ UNIT = ]io_unit, &
[ FMT = ]format, &
 ADVANCE = 'NO' &
[, IOSTAT = scalar_default_int_variable] &
[, ERR = label]) &
[output_item_list]

The I/O unit is a scalar integer expression with a nonnegative value, an asterisk (*), or a character literal constant (external name). The I/O unit forms indicate that the unit is a formatted sequential access external unit.

The format must not be an asterisk (*).

During the data transfer, data is transferred with editing between the file and the entities specified by the I/O list. Format control is initiated and editing is performed as described in Chapter 2, “Input and Output (I/O) Editing”. The current record and possibly additional records are read or written.

For the data transfer, values can be transmitted to or from objects of intrinsic or derived types. In the latter case, the transmission is in the form of values of intrinsic types to or from the components of intrinsic types, which ultimately comprise these structured objects.

For input data transfer, the file must be positioned at the beginning of, end of, or within a formatted record or at the beginning of an end-of-file record.

For input data transfer, the input record is logically padded with blanks to satisfy an input list and format specification that requires more characters than the record contains, unless the PAD= specifier is specified as NO in the OPEN statement. If the PAD= specifier is NO, the input list and format specification must not require more characters from the record than the record contains, unless either the EOR= or IOSTAT= specifier is present. In the exceptional cases during nonadvancing input, the actions and execution sequence are described in “Error and Other Conditions in I/O Statements”.

For output data transfer, the output list and format specification must not specify more characters for a record than the record size; recall that the record size for an external file may be specified by a RECL= specifier in the OPEN statement.

The variable in the SIZE= specifier is assigned the number of characters read on input. Blanks inserted as padding characters when the PAD= specifier is YES are not counted.

The program branches to the label given by the EOR= specifier, if an end-of-record condition is encountered during input. The label must be the label of a branch target statement in the same scoping unit as the data transfer statement.

Execution of a nonadvancing, formatted, sequential access data transfer statement terminates when one of the following occurs:

Unformatted data transfer is prohibited.

In the following statements, assume that N has the value 7:

WRITE (*, '(A)', ADVANCE="NO") "The answer is "
PRINT '(I1)', N

The preceding statements produce the following single output record:

The answer is 7

In the following statements, assume that SSN is a rank-one array of size 9 with values (1, 2, 3, 0, 0, 9, 8, 8, 6):

DO I = 1, 3
  WRITE (*, '(I1)', ADVANCE="NO") SSN(I)
ENDDO
WRITE (*, '("-")', ADVANCE="NO")
DO I = 4, 5
  WRITE (*, '(I1)', ADVANCE="NO") SSN(I)
ENDDO
WRITE (*, '(A1)', ADVANCE="NO")  '-'
DO I = 6, 9
  WRITE (*, '(I1)', ADVANCE="NO") SSN(I)
ENDDO

The preceding statements produce the following record:

123-00-9886

In direct access data transfer, the records are selected by record number. The record number is a scalar integer expression whose value represents the record number to be read or written. The records can be written in any order, but all records must be of the length specified by the RECL= specifier in an OPEN statement.

If a file is connected using the direct access method, then nonadvancing, list-directed, and namelist I/O are prohibited. Also, an internal file must not be accessed using the direct access method.

It is not possible to delete a record using direct access. However, records may be rewritten so that a record can be erased by writing blanks into it.

READ ([ UNIT = ]scalar_int_expr, &
[ FMT = ]format, &
REC = scalar_int_expr &
[, IOSTAT = scalar_default_int_variable] &
[, ERR = label]) &
[input_item_list]
WRITE ([ UNIT = ]scalar_int_expr, &
[ FMT = ]format, &
REC = scalar_int_expr &
[, IOSTAT = scalar_default_int_variable] &
[, ERR = label]) &
[output_item_list]

READ (7, FMT_X, REC=32, ERR=99) A
READ (IOSTAT=IO_ERR, REC=34,  &
      FMT=185, UNIT=10, ERR=99)  A, B, D
WRITE (8, "(2F15.5)", REC = N + 2) X, Y

READ ([ UNIT = ]scalar_int_expr, &
REC = scalar_int_expr &
[, IOSTAT = scalar_default_int_variable] &
[, ERR = label]) &
[input_item_list]
WRITE ([ UNIT = ]scalar_int_expr, &
REC = scalar_int_expr &
[, IOSTAT = scalar_default_int_variable] &
[, ERR = label]) &
[output_item_list]

READ (7, REC=32, ERR=99) A
READ (IOSTAT=MIS, REC=34, UNIT=10, ERR=99) A, B, D
WRITE (8, REC = N + 2) X, Y

List-directed formatting can occur only with files connected for sequential access; however, the file can be an internal file. The I/O data transfer must be advancing. The records read and written are formatted.

List-directed data transfer statements are any data transfer statement for which the format specifier is an asterisk (*). The formats for the list-directed data transfer statements are as follows:

READ ([ UNIT = ]io_unit, &
[ FMT = ] * &
[, IOSTAT = scalar_default_int_variable] &
[, END = label] &
[, ERR = label]) &
[input_item_list]
READ * [, input-item-list]
WRITE ([ UNIT = ]io_unit, &
[ FMT = ] * &
[, IOSTAT = scalar_default_int_variable] &
[, ERR = label]) &
[output_item_list]
PRINT * [, output_item_list]
WRITE format[, output_item_list]

Note that the preceding forms are intentionally structured so that the ADVANCE= and namelist specifiers cannot appear.

During the data transfer, data is transferred with editing between the file and the entities specified by the I/O list. The rules for formatting the data transferred are discussed in “List-directed Formatting” in Chapter 2. The current record and, possibly, additional records are read or written.

For the data transfer, values can be transmitted to or from objects of intrinsic or derived types. In the latter case, the transmission is in the form of values of intrinsic types to or from the components of intrinsic types, which ultimately comprise these structured objects.

For input data transfer, the file must be positioned so that the record read is a formatted record or an end-of-file record.

For output data transfer, one or more records will be written. Additional records are written if the output list specifies more characters for a record than the record size.

If the file is connected for list-directed data transfer, unformatted data transfer is prohibited.

Execution of a list-directed data transfer statement terminates when one of the following conditions occurs:

The following are examples of list-directed input and output statements:

READ (5, *, ERR=99, END=100) A, B, (C(I), I = 1, 40)
READ (FMT=*, UNIT=5) (Y(I), I = 1, KK)
READ *, X, Y
WRITE (*, *) X
PRINT *, " Y = ", Y

Namelist I/O uses a group name for a list of variables that are transferred. Before the group name can be used in the transfer, the list of variables must be declared in a NAMELIST statement, which is a specification statement. Using the namelist group name eliminates the need to specify the list of variables in the sequence for a namelist data transfer. The formatting of the input or output record is not specified in the program; it is determined by the contents of the record itself or the items in the namelist group. Conversion to and from characters is implicit for each variable in the list.

NAMELIST / namelist_group_name / variable_name[, variable_name] ...
[[ , ] / namelist_group_name / variable_name[, variable_name] ... ]
...

NAMELIST /GOAL/ G, K, R
NAMELIST /XLIST/ A, B /YLIST/ Y, YY, YU

READ ([ UNIT = ]io_unit, &
[ NML = ]namelist_group_name &
[, IOSTAT = scalar_default_int_variable] &
[, END = label] &
[, ERR = label])
WRITE ([ UNIT = ]io_unit, &
[ NML = ]namelist_group_name &
[, IOSTAT = scalar_default_int_variable] &
[, ERR = label])

READ (NML=NAME_LIST_23, IOSTAT=KN,  UNIT=5)
WRITE (6, NAME_LIST_23, ERR=99)

Transferring data from an internal representation to characters or from characters back to internal representation can be done between two variables in an executing program. A formatted sequential access input or output statement, including list-directed formatting, is used for the transfer. The format is used to interpret the characters. The internal file and the internal unit are the same character variable.

With this feature, it is possible to read in a string of characters without knowing its exact format, examine the string, and then interpret it according to its contents.

Formatted sequential access data transfer statements on an internal file have the following formats:

READ ([ UNIT = ]char_variable, &
[ FMT = ]format &
[, IOSTAT = scalar_default_int_variable] &
[, ERR = label] &
[, END = label]) &
[input_item_list]
WRITE ([ UNIT = ]char_variable, &
[ FMT = ]format &
[, IOSTAT = scalar_default_int_variable] &
[, ERR = label]) &
[output_item_list]

Examples of data transfer on internal files are:

READ (CHAR_124, 100, IOSTAT=ERR) MARY, X, J, NAME
WRITE (FMT=*, UNIT=CHAR_VAR) X

The unit must be a character variable that is not an array section with a vector subscript.

Each record of an internal file is a scalar character variable.

If the character variable is an array or an array section, each element of the array or section is a scalar character variable and thus a record. The order of the records is array element order. The length, which must be the same for each record, is the length of one array element.

If the character variable is an array or part (component, element, section, or substring) of an array that has the ALLOCATABLE attribute, the variable must be allocated before it is used as an internal file. It must be defined if it is used as an internal file in a READ statement.

If the character variable is a pointer, it must be associated with a target. The target must be defined if it is used as an internal file in a READ statement.

During data transfer, data is transferred with editing between the internal file and the entities specified by the I/O list. Format control is initiated and editing is performed as described in Chapter 2, “Input and Output (I/O) Editing”. The current record and possibly additional records are read or written.

For the data transfer, values can be transmitted to or from objects of intrinsic or derived types. In the latter case, the transmission is in the form of values of intrinsic types to or from the components of intrinsic types, which ultimately comprise these structured objects.

For output data transfer, the output list and format specification must not specify more characters for a record than the record size. Recall that the record size for an internal file is the length of the scalar character variable or an element in a character array that represents the internal file. The format specification must not be part of the internal file or associated with the internal file or part of it.

If the number of characters written is less than the length of the record, the remaining characters are set to blank.

The records in an internal file are defined when the record is written. An I/O list item must not be in the internal file or associated with the internal file. An internal file also can be defined by a character assignment statement, or some other means, or can be used in expressions in other statements. For example, an array element may be given a value with a WRITE statement and then used in an expression on the right-hand side of an assignment statement.

To read a record in an internal file, the character variable comprising the record must be defined.

Before a data transfer occurs, an internal file is positioned at the beginning of the first record (that is, before the first character, if a scalar, and before the first character of the first element, if an array). This record becomes the current record.

Only formatted sequential access, including list-directed formatting, is permitted on internal files. Namelist formatting is prohibited.

On input, an end-of-file condition occurs when there is an attempt to read beyond the last record of the internal file.

During input processing, all nonleading blanks in numeric fields are treated as if they were removed, right justifying all characters in the field (as if a BN edit descriptor were in effect). In addition, records are blank padded when an end of record is encountered before all of the input items are read (as if PAD=YES were in effect).

For list-directed output, character values are not delimited.

File connection, positioning, and inquiry must not be used with internal files.

Execution of a data transfer statement on an internal file terminates when one of the following events occurs:

Sometimes output records are sent to a device that interprets the first character of the record as a control character. This is usually the case with line printers. If a formatted record is transferred to such a device, the first character of the record is not printed, but instead is used to control vertical spacing. The remaining characters of the record, if any, are printed on one line beginning at the left margin. This transfer of information is called printing.

The first character of such a record must be of character type and determines vertical spacing as specified in Table 1-3.

If there are no characters in the record, a blank line is printed. If the first character is not a blank, 0, 1, or +, the character is treated as a blank.

The PRINT statement does not imply that printing actually will occur on a printer, and the WRITE statement does not imply that printing will not occur. Whether printing occurs depends on the disposition of the file connected to the unit number.

You can use the asa(1) command to interpret Fortran carriage control characters.

You can use the BUFFER IN and BUFFER OUT statements to transfer data.

---

Note: The Fortran standard does not describe the BUFFER IN or BUFFER OUT statements.

---

Data can be transferred while allowing the subsequent execution sequence to proceed concurrently. This is called asynchronous I/O. Asynchronous I/O may require the use of nondefault file formats or FFIO layers, as discussed in the Application Programmer's I/O Guide. BUFFER IN and BUFFER OUT operations can proceed concurrently on several units or files.

BUFFER IN is for reading, and BUFFER OUT is for writing. A BUFFER IN or BUFFER OUT operation includes only data from a single array or a single common block.

Either statement initiates a data transfer between a specified file or unit (at the current record) and memory. If the unit or file is completing an operation initiated by any earlier BUFFER IN or BUFFER OUT statement, the current BUFFER IN or BUFFER OUT statement suspends the execution sequence until the earlier operation is complete. When the unit's preceding operation terminates, execution of the BUFFER IN or BUFFER OUT statement completes as if no delay had occurred.

You can use the UNIT(3i) or LENGTH(3i) intrinsic procedures to delay the execution sequence until the BUFFER IN or BUFFER OUT operation is complete. These functions can also return information about the I/O operation at its termination. On UNICOS and UNICOS/mk systems, you can use the SETPOS(3) library routine with BUFFER IN and BUFFER OUT for random positioning.

The general format of the BUFFER IN and BUFFER OUT statements follows:

BUFFER IN (id, mode) (start_loc, end_loc)

BUFFER OUT (id, mode) (start_loc, end_loc)

external_file_unit

file_name_expr

scalar_integer_expr

variable

variable

In the preceding definition, the variable specified for start_loc and end_loc cannot be of a derived type if you are performing implicit data conversion. The data items between start_loc and end_loc must be of the same type.

The BUFFER IN and BUFFER OUT statements are defined as follows.

BUFFER IN (io_unit, mode) (start_loc, end_loc)
BUFFER OUT (io_unit, mode) (start_loc, end_loc)

The mode identifier, mode, controls the position of the record at unit io_unit after the data transfer is complete. The values of mode have the following effects:

The amount of data to be transferred is specified in words without regard to types or formats. However, the data type of end_loc affects the exact ending location of a transfer. If end_loc is of a multiple-word data type, the location of the last word in its multiple-word form of representation marks the ending location of the data transfer.

BUFFER OUT with start_loc = end_loc + 1 and mode≥0 causes a zero-word transfer and concludes the record being created. Except for terminating a partial record, start_loc following end_loc in a storage sequence causes a run-time error.

Example:

  PROGRAM XFR
  DIMENSION A(1000), B(2,10,100), C(500)
  ...
  BUFFER IN(32,0) (A(1),A(1000))
  ...
  DO 9 J=1,100
    B(1,1,J) = B(1,1,J) + B(2,1,J)
9 CONTINUE
  BUFFER IN(32,0) (C(1),C(500))
  BUFFER OUT(22,0) (A(1),A(1000))
  ...
  END

The first BUFFER IN statement in this example initiates a transfer of 1000 words from unit 32. If asynchronous I/O is available, processing unrelated to that transfer proceeds. When this is complete, a second BUFFER IN is encountered, which causes a delay in the execution sequence until the last of the 1000 words is received. A transfer of another 500 words is initiated from unit 32 as the execution sequence continues. BUFFER OUT begins a transfer of the first 1000 words to unit 22. In all cases mode = 0, indicating full record processing.

Data is transferred between records in the file and entities in the I/O list or namelist. The list items are processed in the order of the I/O list for all data transfer I/O statements except namelist data transfer statements. The list items for a namelist formatted data transfer input statement are processed in the order of the entities specified within the input records. The list items for a namelist data transfer output statement are processed in the order in which the data objects (variables) are specified in the namelist group object list.

The next item to be processed in the input or output item list is the next effective item, which is used to determine the interaction between the I/O item list and the format specification.

Zero-sized arrays and implied-DO lists with zero iteration counts are ignored in determining the next effective item.

Before beginning the I/O processing of a particular list item, the compiler first evaluates all values needed to determine which entities are specified by the list item. For example, the subscripts of a variable in an I/O list are evaluated before any data is transferred.

The value of an item that appears early in an I/O list can affect the processing of an item that appears later in the list. In the following example, the old value of N identifies the unit, but the new value of N is the subscript of X:

READ(N) N, X(N)

The file position prior to data transfer depends on the method of access: sequential or direct.

For sequential access on input, if there is a current record, the file position is not changed; this will be the case if the previous data transfer was nonadvancing. Otherwise, the file is positioned at the beginning of the next record and this record becomes the current record. Input must not occur if there is no next record (there must be an end-of-file record at least) or if there is a current record and the last data transfer statement accessing the file performed output.

If the file contains an end-of-file record, the file must not be positioned after the end-of-file record prior to data transfer. If you are using the CF90 compiler, multiple end-of-file records are permitted for some file structures. The MIPSpro 7 Fortran 90 compiler does not allow multiple end-of-file records, but a REWIND or BACKSPACE statement can be used to reposition the file.

---

Note: The Fortran standard does not allow files that contain an end-of-file record to be positioned after the end-of-file record prior to data transfer.

---

For sequential access on output, if there is a current record, the file position is not changed; this will be the case if the previous data transfer was nonadvancing. Otherwise, a new record is created as the next record of the file; this new record becomes the last and current record of the file and the file is positioned at the beginning of this record.

For direct access, the file is positioned at the beginning of the record specified. This record becomes the current record.

If an error condition exists, the file position is indeterminate. If no error condition exists, but an end-of-file condition exists as a result of reading an end-of-file record, the file is positioned after the end-of-file record.

If no error condition or end-of-file condition exists, but an end-of-record condition exists, the file is positioned after the record just read. If no error condition, end-of-file condition, or end-of-record condition exists, and the data transfer was a nonadvancing input or output statement, the file position is not changed. In all other cases, the file is positioned after the record just read or written, and that record becomes the preceding record.

The OPEN statement connects an external file to a unit. If the file does not exist, it is created. If a unit is already connected to a file that exists, an OPEN statement referring to that unit may be executed. If the FILE= specifier is not included, the unit remains connected to the file. If the FILE= specifier names the same file, the OPEN statement may change the connection properties. If it specifies a different file by name, the effect is as if a CLOSE statement without a STATUS= specifier is executed on that unit and the OPEN statement is then executed. For information on default values for the STATUS= specifier, see “STATUS= Specifier”.

If a unit is preconnected to a file that does not exist, the OPEN statement creates the file and establishes properties of the connection.

Execution of an OPEN statement can change the properties of a connection that is already established. The properties that can be changed are those indicated by BLANK=, DELIM=, PAD=, ERR=, and IOSTAT= specifiers. If new values for DELIM=, PAD=, and BLANK= specifiers are specified, these will be used in subsequent data transfer statements; otherwise, the old ones will be used. However, the values in ERR= and IOSTAT= specifiers, if present, apply only to the OPEN statement being executed; after that, the values of these specifiers have no effect. If no ERR= or IOSTAT= specifier appears in the new OPEN statement, error conditions will terminate the execution of the program.

The OPEN statement and the connection specifier are defined as follows:

OPEN (connect_spec_list)

[UNIT = ]external_file_unit

IOSTAT = scalar_default_int_variable

ERR = label

FILE = file_name_expr

STATUS = scalar_char_expr

ACCESS = scalar_char_expr

FORM = scalar_char_expr

RECL = scalar_int_expr

BLANK = scalar_char_expr

POSITION = scalar_char_expr

ACTION = scalar_char_expr

DELIM = scalar_char_expr

PAD = scalar_char_expr

scalar_char_expr

A unit specifier is required. If the keyword UNIT is omitted, the scalar integer expression must be the first item in the list. Note that the form * for the unit specifier is not allowed in the OPEN statement. However, in cases where the default external unit specified by an asterisk also corresponds to a nonnegative unit specifier (such as unit numbers 5 and 6 on many systems), inquiries about these default units and connection properties are possible.

A specifier must not appear more than once in an OPEN statement.

The character expression established for many of the specifiers must contain one of the permitted values from the list of alternative values for each specifier described in the following section. For example, OLD, NEW, REPLACE, UNKNOWN, or SCRATCH are permitted for the STATUS= specifier; any other combination of letters is not permitted. Trailing blanks in any specifier are ignored. The value specified can contain both uppercase and lowercase letters.

If the last data transfer to a unit connected for sequential access to a particular file is an output data transfer statement, an OPEN statement for that unit connecting it to a different file writes an end-of-file record to the original file.

The OPEN statement specifies the connection properties between the file and the unit, using keyword specifiers, which are described in this section. Table 1-4 indicates the possible values for the specifiers in an OPEN statement and their default values when the specifier is omitted.

---

Note: The Fortran standard does not describe the FORM=SYSTEM specifier.

---

[ UNIT= ]scalar_int_expr

ACCESS= scalar_char_expr

ACTION= scalar_char_expr

BLANK= scalar_char_expr

DELIM= scalar_char_expr

ERR= label

FILE= scalar_char_expr

FILENM = 'dir/fnam'
FNUM = '/subfnum'
OPEN (UNIT = 8, FILE = 'beauty')
OPEN (UNIT = 9, FILE = FILENM)
OPEN (UNIT = 10, FILE = FNAME//FNUM)

FORM= Specifier

The FORM= specifier has the following format:

FORM= scalar_char_expr

For scalar_char_expr, specify either FORMATTED, UNFORMATTED, or SYSTEM. FORMATTED indicates that all records are formatted. UNFORMATTED indicates that all records are unformatted.

The default value is UNFORMATTED if the file is connected for direct access and the FORM= specifier is absent.

The default value is FORMATTED if the file is connected for sequential access and the FORM= specifier is absent.

A file opened with SYSTEM is unformatted and has no record marks.

If the file is new, the allowed forms given for the file must include the one indicated.

If the file exists, the form specified by the FORM= specifier must be one of the allowed forms for the file.

---

Note: The Fortran standard does not define the SYSTEM argument to the FORM= specifier.

---

IOSTAT= scalar_default_int_variable

PAD= scalar_char_expr

POSITION= scalar_char_expr

RECL= scalar_int_expr

STATUS= scalar_char_expr

The UNIT= specifier has the following format:

[ UNIT= ]scalar_int_expr

The value of scalar_int_expr must be nonnegative.

A unit specifier is required. If the keyword UNIT is omitted, scalar_int_expr must be the first item in the list.

A unit number identifies one and only one external unit in all program units in a Fortran program.

ERR= label

IOSTAT= scalar_default_int_variable

STATUS= scalar_char_expr

There are three kinds of INQUIRE statements: inquiry by unit, by name, and by an output item list. The first two kinds use the inquire_spec_list form of the INQUIRE statement. The third kind uses the IOLENGTH form. Inquiry by unit uses a unit specifier. Inquiry by file uses a file specifier with the keyword FILE=. These statements are defined as follows:

INQUIRE (inquire_spec_list)

INQUIRE (IOLENGTH = scalar_default_int_variable) output_item_list

[UNIT = ]external_file_unit

FILE = file_name_expr

IOSTAT = scalar_default_int_variable

ERR = label

EXIST = scalar_default_logical_variable

OPENED = scalar_default_logical_variable

NUMBER = scalar_default_int_variable

NAMED = scalar_default_logical_variable

NAME = scalar_char_variable

SEQUENTIAL = scalar_char_variable

ACCESS = scalar_char_variable

DIRECT = scalar_char_variable

FORM = scalar_char_variable

FORMATTED = scalar_char_variable

UNFORMATTED = scalar_char_variable

RECL = scalar_default_int_variable

NEXTREC = scalar_default_int_variable

BLANK = scalar_char_variable

POSITION = scalar_char_variable

ACTION = scalar_char_variable

READ = scalar_char_variable

WRITE = scalar_char_variable

READWRITE = scalar_char_variable

DELIM = scalar_char_variable

PAD = scalar_char_variable

An INQUIRE statement with an inquire_spec_list must have a unit specifier or a FILE= specifier, but not both. If the keyword UNIT is omitted, a scalar integer expression must be the first item in the list and must have a nonnegative value.

No specifier can appear more than once in a given inquiry specifier list.

For an inquiry by an output item list, the output item list must be a valid output list for an unformatted, direct-access, output statement. The length value returned in the scalar default integer variable must be a value that is acceptable when used as the value of the RECL= specifier in an OPEN statement. This value can be used in a RECL= specifier to connect a file whose records will hold the data indicated by the output list of the INQUIRE statement.

An INQUIRE statement can be executed before or after a file is connected to a unit. The specifier values returned by the INQUIRE statement are those current at the time at which the INQUIRE statement is executed.

A variable appearing in a specifier or any entity associated with it must not appear in another specifier in the same INQUIRE statement if that variable can become defined or undefined as a result of executing the INQUIRE statement. That is, do not try to assign two inquiry results to the same variable.

Except for the NAME= specifier, character values are returned in uppercase.

If an error condition occurs during the execution of an INQUIRE statement, all the inquiry specifier variables become undefined except the IOSTAT= specifier. The following are examples of INQUIRE statements:

INQUIRE (9, EXIST = EX)
INQUIRE (FILE = "T123", OPENED = OP, ACCESS = AC)
INQUIRE (IOLENGTH = IOLEN)  X, Y, CAT

This section describes the format and effect of the inquiry specifiers that may appear in the inquiry by unit and file forms of the INQUIRE statement.

[ UNIT= ]scalar_int_expr

ACCESS= scalar_char_variable

ACTION= scalar_char_variable

BLANK= scalar_char_variable

DELIM= scalar_char_variable

DIRECT= scalar_char_variable

ERR= label

EXIST= scalar_default_logical_variable

FILE= scalar_char_expr

FORM= scalar_char_variable

FORMATTED= scalar_char_variable

IOSTAT= scalar_default_int_variable

NAME= scalar_char_variable

NAMED= scalar_default_logical_variable

NEXTREC= scalar_default_int_variable

NUMBER= scalar_default_int_variable

OPENED= scalar_default_logical_variable

PAD= scalar_char_variable

POSITION= scalar_char_variable

READ= scalar_char_variable

READWRITE= scalar_char_variable

RECL= scalar_default_int_variable

SEQUENTIAL= scalar_char_variable

UNFORMATTED= scalar_char_variable

WRITE= scalar_char_variable

Figure 1-6, summarizes the values assigned to the INQUIRE specifier variables by the execution of an INQUIRE statement.

Figure 1-6. Values for specifier variables in an INQUIRE statement

Executing a BACKSPACE statement causes the file to be positioned before the current record if there is a current record, or before the preceding record if there is no current record. If there is no current record and no preceding record, the file position is not changed. If the preceding record is an end-of-file record, the file becomes positioned before the end-of-file record.

If the last data transfer to a file connected for sequential access was an output data transfer statement, a BACKSPACE statement on that file writes an end-of-file record to the file. If there is a preceding record, the BACKSPACE statement causes the file to become positioned before the record that precedes the end-of-file record.

The BACKSPACE statement is defined as follows:

BACKSPACE external_file_unit

BACKSPACE (position_spec_list)

The BACKSPACE statement is used only to position external files.

If the file is already at its initial point, a BACKSPACE statement has no effect. If the file is connected, but does not exist, backspacing is prohibited. Backspacing over records written using list-directed or namelist formatting is prohibited.

BACKSPACE  ERROR_UNIT        ! ERROR_UNIT is an
                             !    integer variable
BACKSPACE (10, &             ! STAT is an integer
                             !    variable of
           IOSTAT = STAT)    !    default type

A REWIND statement positions the file at its initial point. Rewinding has no effect on the file position when the file is already positioned at its initial point. If a file does not exist, but it is connected, rewinding the file is permitted, but it has no effect.

If the last data transfer to a file was an output data transfer statement, a REWIND statement on that file writes an end-of-file record to the file.

The file must be connected for sequential access.

The REWIND statement is defined as follows:

REWIND external_file_unit

REWIND (position_spec_list)

The REWIND statement is used only to position external files.

REWIND  INPUT_UNIT      ! INPUT_UNIT is an integer
                        !   variable
REWIND (10, ERR = 200)  ! 200 is a label of branch
                        !   target in this
                        !   scoping unit

The ENDFILE writes an end-of-file record as the next record and positions the file after the end-of-file record written. Writing records past the end-of-file record is prohibited, except for certain file structures.

If you are using the CF90 compiler, you can find more information on file structures in the Application Programmer's I/O Guide.

If you are using the MIPSpro 7 Fortran 90 compiler, IRIX record blocking is the default form for sequential unformatted files. Text files are used for all other types of Fortran I/O.

---

Note: The Fortran standard does not address writing past an end-of-file record.

---

After executing an ENDFILE statement, it is necessary to execute a BACKSPACE or REWIND statement to position the file ahead of the end-of-file record before reading or writing the file. If the file is connected but does not exist, writing an end-of-file record creates the file.

The file must be connected for sequential access.

The ENDFILE statement is defined as follows:

ENDFILE external_file_unit

ENDFILE (position_spec_list)

The ENDFILE statement is used only to position external files.

                     ! OUTPUT_UNIT is an integer variable.
ENDFILE  OUTPUT_UNIT
ENDFILE (10, ERR = 200, IOSTAT = ST)
                     !   200 is a label of a branch
                     !   target in this scoping unit
                     !   ST is a default scalar integer
                     !   variable

A file can be connected for sequential and direct access, but not for both simultaneously. If a file is connected for sequential access and an ENDFILE statement is executed on the file, only those records written before the ENDFILE statement is executed are considered to have been written. Consequently, if the file is subsequently connected for direct access, only those records before the end-of-file record can be read.

The position_spec_list is defined as follows (note that no specifier can be repeated in a position_spec_list):

[UNIT = ]scalar_int_expr

IOSTAT = scalar_default_int_variable

ERR = label

The following sections describe the form and effect of the position specifiers that can appear in the file positioning statements.

[ UNIT= ]scalar_int_expr

IOSTAT= scalar_default_int_variable

ERR= label