Listed-Directed Input: The READ Statement

List-directed input is carried out with the Fortran READ statements. The READ statement can read input values into a set of variables from the keyboard.

The READ statement has the following forms:

READ(*,*)  var1, var2, ..., varn
READ(*,*)

The first form starts with READ(*,*), followed by a list of variable names, separated by commas. The computer will read values from the keyboard successively and puts the value into the variables. The second form only has READ(*,*), which has a special meaning.

The following example reads in four values into variables Factor, N, Multiple and tolerance in this order.

INTEGER  ::  Factor, N
REAL     ::  Multiple, tolerance

READ(*,*)  Factor, N, Multiple, tolerance

The following example reads in a string into Title, followed by three real numbers into Height, Length and Area.
```
CHARACTER(LEN=10)  :: Title
REAL               :: Height, Length, Area

READ(*,*)  Title, Height, Length, Area
```

Preparing Input Data:

Preparing input data is simple. Here are the rules:

If a READ statement needs some input values, start a new line that contains the input. Make sure the type of the input value and the type of the corresponding variable are the same. The input data values must be separated by space or commas.
For the following READ
```
CHARACTER(LEN=5)  :: Name
REAL              :: height, length
INTEGER           :: count, MaxLength

READ(*,*)  Name, height, count, length, MaxLength
```
The input data may look like the following:
```
"Smith"   100.0  25  123.579  10000
```
Note that all input data are on the same line and separated with spaces. After reading in this line, the contents of the variables are
```
Name         "Smith"
height       100.0
count        25
length       123.579
MaxLength    100000
```
Input values can be on several lines. As long as the number of input values and the number of variables in the corresponding READ agree, the computer will search for the input values. Thus, the following input should produce the same result. Note that even blank lines are allowed in input.
```
"Smith"   100.0

25
123.579
10000
```
The execution of a READ always starts searching for input values with a new input line.
```
INTEGER   ::  I, J, K, L, M, N

READ(*,*)  I, J
READ(*,*)  K, L, M
READ(*,*)  N
```
If the above READ statements are used to read the following input lines,
```
100 200
300 400 500
600
```
then I, J, K, L, M and N will receive 100, 200, 300, 400, 500 and 600, respectively.
Consequently, if the number of input values is larger than the number of variables in a READ statement, the extra values will be ignored. Consider the following:
```
INTEGER  ::  I, J, K, L, M, N

READ(*,*)  I, J, K
READ(*,*)  L, M, N
```
If the input lines are
```
100  200  300  400
500  600  700  800
900
```
Variables I, J and K receive 100, 200 and 300, respectively. Since the second READ starts with a new line, L, M and N receive 500, 600 and 700, respectively. 400 on the first input line is lost. The next READ will start reading with the third line, picking up 900. Hence, 800 is lost.
A limited type conversion is possible in a READ statement. If the input value is an integer and the corresponding variable is of REAL type, the input integer will be convert to a real number.
But, if the input value is a real number and the corresponding variable is of INTEGER type, an error will occur.
The length of the input string and the length of the corresponding CHARACTER variable do not have to be equal. If they are not equal, truncation or padding with spaces will occur as discussed in the PARAMETER attribute page.
Finally, a READ without a list of variables simply skips a line of input. Consider the following:
```
INTEGER  ::  P, Q, R, S

READ(*,*)  P, Q
READ(*,*)
READ(*,*)  R, S
```
If the input lines are
```
100  200  300
400  500  600
700  800  900
```
The first READ reads 100 and 200 into P and Q and 300 is lost. The second READ starts with a new input line, which is the second one. It does not read in anything. The third READ starts with the third line and reads 700 and 800 into R and S. As a result, the three input values (i.e., 400, 500 and 600) are all lost. The third value on the third line, 900, is also lost.