How was character data handled in Fortran IV/66?

Question

One of the notable contributions in FORTRAN 77 was the CHARACTER data type, which made character processing quite usable.

As I understand it, FORTRAN 66 (sometimes called FORTRAN IV, but they're not identical) relied on Hollerith codes to work with characters, and these were mapped into machine words, which then had to be decomposed (using shifts and masks) to work with.

But it's not clear to me how FORTRAN 66 worked with reading and writing the data in and out. I've heard anecdotes about working with or modifying FORMAT statements, but I've never seen an example.

I'm curious if anyone has any examples of character work with FORTRAN 66.

Answer 1

Individual characters could be read into integer variables (or elements of integer arrays) using the format specifier A1, manipulated at will, then printed using the A1 format specifier.

For example (using the BESM-6 clone of the CDC 1604 FORTRAN compiler),

                PROGRAM MAIN
                INTEGER STR(80)
                READ 10,STR
            10  FORMAT(80A1)
       2        PRINT 11,STR
            11  FORMAT(’ READ: ’, 80A1)
       3        DO 2 I = 1,80
       4        IF (STR(81-I).NE.1H )
       5       -                      GOTO 3
       6     2  CONTINUE
       7     3  I=81-I
       8        PRINT 12,I
            12  FORMAT(’ STRING LENGTH = ’, I3)
       9        DO 4 J=1,I
      10        K=STR(J)
      11        STR(J)=STR(81-J)
      12     4  STR(81-J)=K
      13        I=81-I
      14        PRINT 13,(STR(J),J=I,80)
            13  FORMAT(’ REVERSED: ’, 80A1)
                END
           *EXECUTE
 READ:  HELLO, WORLD!
 STRING LENGTH =  14
 REVERSED: !DLROW ,OLLEH

Also there were operators ENCODE and DECODE, said to be non-standard in FORTRAN 77 but provided for compatibility with older versions of FORTRAN.

They are somewhat analogous in functionality to the C library functions snprintf and sscanf, allowing to perform formatted I/O to/from packed character strings. For example, generating a format string on the fly and printing something using it could look like

                PROGRAM MAIN
                INTEGER STR(80),FMT(20)
                READ 10,STR
            10  FORMAT(80A1)
       2        ENCODE (80, 11, FMT) STR
            11  FORMAT (2H(’,20A1,5H’,I6))
       3        PRINT FMT,123456
                END
           *EXECUTE
ARBITRARY PREFIX    123456

Here the input stream contained the line ARBITRARY PREFIX which was read into an "unpacked character" array, then interpolated into an array containing "packed characters" using the ENCODE statement to form a valid format string, then the newly formed packed character string was used as the format to print an integer.

Answer 2

With respect to this:

I've heard anecdotes about working with or modifying FORMAT statements, but I've never seen an example.

The FORTRAN IV language for IBM 7090/7094 IBSYS version 13 supported this.

Under 'H-conversion' the manual says:

On input, n characters are extracted from the input record and replace the n characters included with the source program FORMAT specification.

Thus, you code 6HFOOBAR in your FORMAT statement. If you use that in a READ, FOOBAR gets overwritten; a subsequent WRITE referencing the same format will print the new characters.

Reference: 7090 FORTRAN IV manual at Bitsavers; see page 17. This is a slightly earlier edition than my paper manual, but the H-conversion details are the saeme.

I imagine this is useful only for captions and headings, since there's no processing, just read in and write out.

The same behaviour existed in the FORTRAN II language; see page 47. And even before that, in the 1956 FORTRAN system for the IBM 704, see page 28.

(KDF9 Algol, of approximately the same vintage, used to have a 'copytext' library function that directly copied string data from input to output, for similar reasons).

Answer 3

In FORTRAN 66, you could store up to the word size in characters. For instance, on a 24-bit machine with 6-bit characters

      INTEGER C1(80), C2(40), C4(20)
      READ(10,11) (C1(II), II=1, 80)
11    FORMAT(80A1)
      READ(10,12) (C2(II), II=1, 40)
12    FORMAT(40A2)
      READ(10,13) (C3(II), II=1, 20)
13    FORMAT(20A4)

These could then be manipulated in chunks of 1, 2 or 4. The only problem is splitting them up or having wildcards. Simple like-for-like comparisons could be done just using .EQ.

On some implementations, this is not restricted to just integers: double precision could also be used. This had the advantage of storing more characters, which was useful if you had names mixed in with values. They could be printed like

      DIMENSION VAL(5)
      DOUBLE PRECISION VAL
      ...
      WRITE(11,14) (VAL(II), II = 1, 5)
14    FORMAT(1X, A8, 4D9.2)

The only problem is that if this was used for calculations, your arrays all began at 2.

On CDCs, with their 60 bit words, 10 6-bit characters could be stored in each integer. The problem was that the integers were only 48 bits so if a word, full of alphanumerics was printed as an integer, you'd get an overflow error.