Syntax of I/O statements

In a read operation, the simple data element specifies a variable, which can include:

In a write operation, the simple data element can include any variable that is valid for a read operation, plus most expressions. Note that, if the expression includes a function reference, the function must not itself perform I/O.

The output list in the following PRINT statement contains two simple list elements, a variable named radius and an expression formed from radius:

99 FORMAT('Radius = ', F10.2, 'Area = ', F10.2)
   PRINT 99, radius, 3.14159*radius**2

The next READ statement contains three simple elements: a character substring (name(1:10)), a variable (id), and an array name (scores):

88 FORMAT(A10,I9,10I5)
   READ(5, 88) name(1:10), id, scores

If an array name is used as a simple data element in the I/O list of a WRITE statement, then every element in the array will be displayed. If a format specification is also used, then the format will be reused if necessary to display every element. For example, the following code

   INTEGER :: i(10) = (/1,2,3,4,5,6,7,8,9,10/)
88 FORMAT('   N1:',I5, ' N2:',I5, ' N3:',I5)
   PRINT 88, i

will output the following:

   N1:    1 N2:    2 N3:    3
   N1:    4 N2:    5 N3:    6
   N1:    7 N2:    8 N3:    9
   N1:   10 N2:

The following restrictions apply to the use of arrays in input and output:

The following restrictions apply to the use of structures and records in input and output:

An implied-DO loop consists of a list of data elements to be read, written, or initialized, and a set of indexing parameters. The syntax of an implied-DO loop in an I/O statement is:

(list , index = init , limit [, step ])

where

Inner loops can use the indexes of outer loops.

The implied-DO loop acts like a DO construct. The range of the implied-DO loop is the list of elements to be input or output. The implied-DO loop can transfer a list of data elements that are valid for a write operation. index is assigned the value of init at the start of the loop. Execution continues in the same manner as for DO loops (see “DO construct”).

The implied-DO loop is generally used to transmit arrays and array elements, as in the following:

INTEGER :: b(10)
PRINT *, (b(i), i = 1,10)

If b has been initialized with the values 1 through 10 in order, the PRINT statement will produce the following output:

1 2 3 4 5 6 7 8 9 10

If an nonsubscripted array name occurs in the list, the entire array is transmitted at each iteration. For example:

REAL :: x(3)
PRINT *, (x, i=1, 2)

If x has been initialized to be [ 1 2 3 ], the output will be:

 1.0 2.0 3.0 1.0 2.0 3.0

The list can contain expressions that use the index value. For example:

REAL :: x(10) = (/.1, .2, .3, .4, .5, .6,  .7, .8, .9, 1 /)
PRINT *, (i*2, x(i*2), i = 1, 5)

print the numbers

2 .2 4 .4 6 .6 8 .8 10 1

Implied-DO loops can also be nested. The form of a nested implied-DO loop in an I/O statement is:

(((list, index1 = init1, limit1, step1), index2 = init2, limit2,
         step2) ... indexN = initN, limitN, stepN)

Nested implied-DO loops follow the same rules as do other nested DO loops. For example, given the following statements:

REAL :: a(2,2)
 
a(1,1) = 1
a(2,1) = 2
a(1,2) = 3
a(2,2) = 4
 
WRITE(6,*)((a(i,j),i=1,2),j=1,2)

the output will be:

 1.0 2.0 3.0 4.0

The first, or nested DO loop, is completed once for each execution of the outer loop.