Input/Output

Almost all FORTRAN 77 programs read data from external sources such as files or the user's terminal, perform calculations on that data, and then write the results to other files or the terminal. FORTRAN 77 provides a powerful and flexible set of features for reading and writing data which are independent of the underlying operating system.

Unit Numbers

Every input or output device is identified by a small, positive integer known as the unit number. These unit numbers are used in READ and WRITE statements to indicates the source or destination for the operation. Two of these numbers are always pre-defined at the start of every FORTRAN 77 program: unit 5 corresponds to standard input, which is often the user's terminal, and unit 6 corresponds to standard output, which is also often the terminal but may be another device, such as a printer.

      READ(5,100)I
      WRITE(6,200)I

      READ(*,100)I
      WRITE(*,200)I

READ and WRITE Statements

The READ statement reads information from one or more records in a file or standard pre-connected input device (like the terminal) into a data-transfer-list of variables, array elements, etc. Its general form is

READ(UNIT=integer-expression, control-list) data-transfer-list

Correspondingly, the WRITE statement prints information to one or more records in a file or standard pre-connected output device (like the terminal) from a data-transfer-list of variables, array elements, expressions, etc. Its general form is

WRITE(UNIT=integer-expression, control-list) data-transfer-list

The control-list is a set of keyword/value pairs which define the characteristics of the I/O. The unit number must always be given. The following table lists the standard specifiers in FORTRAN 77.

      DO 10, I = 1,100
         READ(7,*,END=20,ERR=900)COUNT(I),A(I),NAME(I)
         FILENO = I
   10 CONTINUE
   20 WRITE(*,*)'Input complete. Number of records: ',FILENO
…  
  900 STOP 'Error in input file'
      END

Formatting

When no specific formatting is specified by the programmer, the computer uses a system-dependent system called list-directed formatting. For output, the formatting depends on the data type of the item and varies from system to system. In general, however, the following rules apply:

• each WRITE statement starts a new record or line;
• arithmetic data types are given to the number of digits appropriate for the internal precision;
• the system will choose decimal or exponential form for floating point numbers, according to the magnitude of the value;
• COMPLEX data types are output as (real,imaginary);
• LOGICAL data types are output as a single T or F;
• CHARACTER data types are output as a string without enclosing apostrophes;
• except for CHARACTER values, all items are followed by a blank or comma to separate it from the next value.

As for input, list-directed formatting allows free-format entry for numerical data. The following rules are generally applicable:

• each READ statement starts with a new record or line, and reads as many records as is necessary to complete its data-transfer list;
• when expecting a DOUBLE PRECISION or REAL data type, an INTEGER will be accepted;
• when expecting a COMPLEX data type, the number must be in the form (real,imaginary);
• when expecting a LOGICAL data type, only a T or F is necessary;
• when expecting a CHARACTER data type, the string must be enclosed in apostrophes;
• the input values must consist of a sequence of values and separators (which are blanks or commas or both);
• two successive commas represent a null value;
• a slash / in place of a separator terminates the current READ statement.

Except for CHARACTER data, list-directed input and output files are usually compatible.

It is also possible for the programmer to specify the formatting. The format specification consists of a list of edit descriptors enclosed by a pair of parentheses.

      WRITE(*,'(1X,3A,F12.2,A)')'The distance to ',STAR(I),' is ',
     $                          DIST(I),' ly'

      CHARACTER*15 FORM
      PARAMETER(FORM='(1X,3A,F12.2,A)')
      WRITE(*,FMT=FORM)'The distance to ',STAR(I),' is ',DIST(I),' ly'

      WRITE(*,100)'The distance to ',STAR(I),' is ',DIST(I),' ly'
  100 FORMAT(1X,3A,F12.2,A)

Implied DO loop

The simplest way to input or output all the elements of an array is to simply put the unsubscripted array name in the data transfer list. An implied DO loop allows selective access to array elements and is used in DATA statements as well as READ and WRITE statements. The general form of the implied DO loop is

(data-list, loop-control-variable = initial-value, final-value, step-size)

The rules for the initial-value, final-value and step-size are exactly the same as for a DO loop. An implied DO loop may contain other implied DO loops nested within.

      INTEGER   NMAX
      PARAMETER(NMAX=10)
      REAL      TEMPC(NMAX)

      WRITE(*,*)'Enter ',NMAX,' temperatures in Celsius'
      READ(*,*)(TEMPC(I),I=1,NMAX)
      WRITE(*,100)(TEMPC(I),I=1,NMAX)
  100 FORMAT(' ',5F8.2)
      STOP 'End of program'
      END

Nested implied DO loops are particularly useful when dealing with multi-dimensional arrays.

      WRITE(*,100)((MATRIX(I,J),J=1,8),I=1,5)

Simplified READ and PRINT Statements

The simplified READ statement

READ format, data-transfer-list

reads in list-directed or formatted input from the standard input device and is directly equivalent to

READ(*,format)data-transfer-list

The equivalent statement for WRITE is

PRINT format, data-transfer-list

which writes out list-directed or formatted output to the standard output device. It is directly equivalent to

WRITE(*,format)data-transfer-list

There is nothing to recommend the simplified versions of READ and PRINT. Use the standard READ and WRITE statements in their place.

Opening a File

Files are associated with specific unit numbers using the OPEN statement. The general form of this statement is:

OPEN(UNIT=integer-expression, control-list)

The control-list is a set of keyword/value pairs which define the characteristics of the file to be opened. The unit number must always be given. The file name also must be given except in the case of scratch files. The following table lists the standard specifiers in FORTRAN 77.

  100 WRITE(*,*)'Enter the input file name'
      READ(*,'(A)',END=999)FNAME
      OPEN(13,FILE=FNAME,STATUS='OLD',BLANK='ZERO',ERR=100)

Scratch Files

FORTRAN 77 provides an easy way to open a temporary file to act as scratch storage for a program. Consider the following example:

      OPEN(8,STATUS='SCRATCH')

Closing a File

When a file is no longer required by the program, it should be closed. This breaks the association between the file and its unit number. The general form of this statement is

CLOSE(UNIT=integer-expression, control-list)

The control-list is a set of keyword/value pairs which define the how the file is to be closed. The unit number must always be given. The following table lists the standard specifiers in FORTRAN 77.

      CLOSE(27,STATUS='DELETE')
      CLOSE(39)

INQUIRE Statement

The INQUIRE statement is useful when you wish to learn more about a file, such as whether it exists or if it is already connected. This statement takes on two slightly different forms. If you wish to determine whether a unit number is already in use and the characteristics of the file associated with it, then you use the inquire by unit form for the statement:

INQUIRE(UNIT=integer-expression, inquire-list)

If no file is connected to the specified unit number, then most of the arguments in the inquire-list will be undefined or return 'UNKNOWN' as their values.

The inquire by file form of the statement can be used to find out whether or not a named file exists.

INQUIRE(FILE=character-expression, inquire-list)

You may inquire by unit or inquire by file but not both in the same INQUIRE command.

The inquire-list is a set of keyword/value pairs which return values to the named variables or array elements. (The only exception is ERR=label where label is the label of a statement within the same program unit.) The following table lists the standard specifiers in FORTRAN 77.

      INTEGER FUNCTION IFREE(IFIRST,ILAST)
      INTEGER IFIRST,ILAST,IUNIT
      LOGICAL ISOPEN

      DO 10, IUNIT=IFIRST,ILAST
         INQUIRE(UNIT=IUNIT, OPENED=ISOPEN)
         IF (.NOT.ISOPEN) THEN
            IFREE = IUNIT
            RETURN
         END IF
   10 CONTINUE
      IFREE = -1
      END

Unformatted I/O

When reading or writing very large data sets, it is often more efficient to store the data in the host machine's native binary format rather than in human-readable format. FORTRAN 77 provides unformatted I/O for this purpose. Unformatted files are generally more compact and can be read and written much more quickly, because there is no need for the computer to convert between human-readable text and its native binary format.

However, unformatted files cannot be opened with a text editor. They can only be read by a FORTRAN 77 program.

      PROGRAM XAMPLE
      DOUBLE PRECISION D
      INTEGER          I,J

      I = 1024*1024
      J = -1
      D = 10.0D0

      OPEN(8,FILE='xample.out',STATUS='NEW',FORM='UNFORMATTED')
      WRITE(8)I,J,D
      CLOSE(8,STATUS='KEEP')
      STOP 'End of program'
      END

00000000  10 00 00 00 00 00 10 00  ff ff ff ff 00 00 00 00  |................|
00000010  00 00 24 40 10 00 00 00                           |..$@....|

Sequential I/O

Most programs use sequential I/O. They open a data file, and read its contents from start to finish, processing the values as they are read, and writing results to an output file.

REWIND Statement

It is possible to re-read a sequential input file from the first record by using the REWIND command. The name is a reminder that FORTRAN originates from an era when magnetic tapes were the most common mass-storage medium. The REWIND command once did exactly what its name implies: it caused a magnetic tape to be rewound to the start, so that the data on it could be re-read.

The general form of this statement is

REWIND(UNIT=integer-expression, control-list)

The control-list must contain the UNIT specifier and may contain the ERR and IOSTAT specifiers, which have exactly the same syntax and meaning as their counterparts in the OPEN and CLOSE statements. As always, if the unit number is listed first in the control-list, the UNIT= part of the keyword/value pair may be omitted.

BACKSPACE Statement

If the program needs to re-read only the most recently read (or written) record, then the BACKSPACE statement can be used. The general form of this statement is

BACKSPACE(UNIT=integer-expression, control list)

The control list may contain the same specifiers as the REWIND statement.

Direct I/O

Some programs may need to access records in a data file in a non-sequential manner. Consider, for example, a data file which contains customer information, with one record per customer. It would be inefficient to read the entire file in order to obtain the data on a single customer. Instead, the program should be able to skip all of the intervening records, and read only the record for that customer. FORTRAN 77 provides direct-access I/O for this purpose.

In order to make direct-access I/O efficient, FORTRAN 77 mandates that all records in a direct-access file must be exactly the same length. This allows the FORTRAN 77 I/O subsystem to determine the offset of the desired record in the file by performing a simple arithmetic calculation. It is the programmer's responsibility to specify the correct record length when opening the file.

Direct-access I/O is normally carried out on unformatted files, although it can also be used with formatted files, if sufficient caution is used.

      PROGRAM XAMPLE
      DOUBLE PRECISION D
      INTEGER          I,J

      I = 1024*1024
      J = -1
      D = 10.0D0

      OPEN(8,FILE='xample.out',STATUS='NEW',FORM='UNFORMATTED',
     $     ACCESS='DIRECT',RECL=16)
      WRITE(8,REC=1)I,J,D
      CLOSE(8,STATUS='KEEP')
      STOP 'End of program'
      END

00000000  00 00 10 00 ff ff ff ff  00 00 00 00 00 00 24 40  |..............$@|

FORTRAN 77 allows us to write to any record in a direct-access file. We do not have to write the records sequentially. We can open a new file and write record number 3 without having to write records 1 and 2.

WRITE(8,REC=3)I,J,D

00000000  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000020  00 00 10 00 ff ff ff ff  00 00 00 00 00 00 24 40  |..............$@|

Internal Files

The files discussed above are all external files. FORTRAN 77 also allows computer memory to be used as if it was an external file. This internal file exists only whilst the program is executing and behaves like a formatted sequential file.

An internal file is a CHARACTER object such as a constant, variable, substring, array or array element, and is most often used for converting between CHARACTER and other data types. It is accessed only with READ and WRITE statements with explicit format specifications. However, instead of a number, the unit in the READ or WRITE statement must be an object of type CHARACTER.

      CHARACTER*40 TITLE
      REAL         STIME
 
   10 CONTINUE
         WRITE(*,*)'Enter the decimal sidereal time'
         READ(*,*,END=999)STIME
      IF (STIME .LT. 0.0 .OR. STIME .GT. 24.0) GOTO 10
      WRITE(TITLE,100)INT(STIME),NINT((STIME-INT(STIME))*60)
  100 FORMAT('The sidereal time is ',I2,' hours ',I2,' minutes')

The␣sidereal␣time␣is␣15␣hours␣36␣minutes

      CHARACTER*10 NUMBER
      INTEGER      I,J

      NUMBER = '1 2 3 4 5 '
      READ(NUMBER,'(2I5)')I,J      

      READ(NUMBER,'(BZ,2I5)')I,J      

The statements BACKSPACE and REWIND may be used with internal files but no other I/O commands are permitted.

Table of Contents Index Format Descriptors

Copyright © 2014–2021 by L.M. Stockman and David Harper
All Rights Reserved
Designed and maintained by Obliquity
https://www.obliquity.com/computer/fortran/io.html