tstate: Get Logical State of Tape I/O Channel

The function is called by:

For details, see st(4s).

While eoff is true, you cannot read from that tlu. You can set this EOF status flag to false by using tskipf() to skip one file and zero records:

    n = tskipf( tlu, 1, 0). 

Then you can read any valid record that follows.

End-of-tape (EOT) is indicated by an empty file, often referred to as a double EOF mark. You cannot read past EOT, but you can write past it.

Example: Write three files of two records each:

    CHARACTER devnam*10 / '/dev/nrst0' /,
&                 f0rec1*512 / "eins" /, f0rec2*512 / "zwei" /,
&                 f1rec1*512 / "ichi" /, f1rec2*512 / "ni__" /,
&                 f2rec1*512 / "un__" /, f2rec2*512 / "deux" /
    INTEGER*4 n / 0 /, tlu / 1 /, tclose, topen, trewin, twrite
    LOGICAL islabeled / .false. /
    n = topen( tlu, devnam, islabeled )
    n = trewin( tlu )
    n = twrite( tlu, f0rec1 )
    n = twrite( tlu, f0rec2 )
    n = tclose( tlu )
    n = topen( tlu, devnam, islabeled )
    n = twrite( tlu, f1rec1 )
    n = twrite( tlu, f1rec2 )
    n = tclose( tlu )
    n = topen( tlu, devnam, islabeled )
    n = twrite( tlu, f2rec1 )
    n = twrite( tlu, f2rec2 )
    n = tclose( tlu )
    END

The next example uses tstate() to trap EOF and get at all files.

Example: Use tstate() in a loop that reads all records of the 3 files written in the previous example:

    CHARACTER devnam*10 / '/dev/nrst0' /, onerec*512 / " " /
    INTEGER*4 f, n / 0 /, tlu / 1 /, tcsr, topen, tread, 
&        trewin, tskipf, tstate
    LOGICAL errf, eoff, eotf, islabeled / .false. /
    n = topen( tlu, devnam, islabeled )
    n = tstate( tlu, fn, rn, errf, eoff, eotf, tcsr )
    WRITE(*,1)  'open:', fn, rn, errf, eoff, eotf, tcsr
1    FORMAT(1X, A10, 2I2, 1X, 1L, 1X, 1L,1X, 1L, 1X, I2 )
2    FORMAT(1X, A10,1X,A4,1X,2I2,1X,1L,1X,1L,1X,1L,1X,I2)
    n = trewin( tlu )
    n = tstate( tlu, fn, rn, errf, eoff, eotf, tcsr )
    WRITE(*,1)  'rewind:', fn, rn, errf, eoff, eotf, tcsr
    DO f = 1, 3
       eoff = .false.
       DO WHILE ( .NOT. eoff )
          n = tread( tlu, onerec )
          n = tstate( tlu, fn, rn, errf, eoff, eotf, tcsr )
          IF (.NOT. eoff) WRITE(*,2) 'read:', onerec, 
&            fn, rn, errf, eoff, eotf, tcsr
       END DO
       n = tskipf( tlu, 1, 0 )
       n = tstate( tlu, fn, rn, errf, eoff, eotf, tcsr )
       WRITE(*,1)  'tskip: ', fn, rn, errf, eoff, eotf, tcsr
    END DO
    END

The output is:

open: 0 0 F F F 0 
rewind: 0 0 F F F 0 
read: eins 0 1 F F F 0 
read: zwei 0 2 F F F 0 
tskip: 1 0 F F F 0 
read: ichi 1 1 F F F 0 
read: ni__ 1 2 F F F 0 
tskip: 2 0 F F F 0 
read: un__ 2 1 F F F 0 
read: deux 2 2 F F F 0 
tskip: 3 0 F F F 0 

A summary of EOF and EOT follows:

• If you are at either EOF or EOT, then:

  • Any tread() just returns; it does not read the tape.

  • A successful tskipf(tlu,1,0) resets the EOF status to false, and returns; it does not advance the tape pointer.

• A successful twrite() resets the EOF and EOT status flags to false.

• A successful tclose() resets all those flags to false.

• tclose() truncates; it places an EOF marker immediately after the current location of the unit pointer, and then closes the unit. So, if you use trewin() to rewind a unit before you use tclose() to close it, its contents are discarded. This behavior of tclose() is inherited from the Berkeley code.

See also: ioctl(2), mtio(4s), perror(3F), read(2), st(4s), and write(2).