[Next] [Up] [Previous] [Home] [Other]


The FORTRAN II language became available very shortly after the original FORTRAN language. It resembled the original FORTRAN language in its syntax; for example, function names still ended in the letter F. But it added a very important new feature.

It was now possible to write subroutines in FORTRAN that could be compiled separately; the SUBROUTINE, FUNCTION, CALL, and RETURN statements were added to the language.

It was possible to use the ASSIGNed GO TO statement in the original FORTRAN language as a way of returning from a subroutine in the body of the main program, and this statement was used for that purpose; the manual for the original FORTRAN language explicitly referred to subroutines. Users could also define their own statement functions in the original FORTRAN language.

In FORMAT statements, O format, for printing out or reading in the internal binary representation of a number in octal form, and A format, for directly transmitting the binary contents of variables without editing, were added.

In the version of FORTRAN II offered for the IBM 7090 computer, but not the version for the IBM 704, some other features were added:

Bitwise logical operations could be performed on integer variables. This was done by placing the letter B in column 1 of the line containing an assignment statement; then, + would mean OR, * would mean AND, and - would mean bitwise negation.

If D were placed in column 1 of a card containing a statement, the floating-point variables and functions referenced in that line would be double-precision. In addition to assignment statements, this was used with function declarations.

Similarly, if the letter I was placed in column 1, the line of the program would deal with complex numbers rather than real numbers.

Finally, the letter F in column 1 was used to declare functions that could be passed as arguments to subroutines. In this declaration, the trailing letter F was stripped off the function names.

Of course, C in column 1 still indicated a comment.

Also, the END statement which indicated the end of a program had an unusual feature: it could look like this:

      END (2,2,0,1,2)

and the END statement in this example meant that the actual values of sense switches 1, 2, and 5 would be visible to the program, but it would run as if sense switch 3 was OFF, and sense switch 4 was ON, regardless of their actual values. The actual value of sense switch 6 could never be hidden from a program.

When the computer was directly available to the programmer, this statement allowed whether the program was to run in a debugging mode or not to be controlled conveniently from one place.


Many other computer manufacturers, besides IBM, made FORTRAN compilers available for their computers. One of the first companies to do so was Philco; as they did so while FORTRAN was still perhaps an IBM trademark, they called their language ALTAC (ALgebraic translator into TRANSAC Assembly Code).

However, ALTAC and FORTRAN II were not absolutely identical. A very short program (unlike the example on the previous page) is shown first in FORTRAN II below, and then in its ALTAC version.


C PROGRAM TO SOLVE THE QUADRATIC EQUATION                               MAIN0001
      READ 10,A,B,C                                                     MAIN0002
      DISC = B*B-4*A*C                                                  MAIN0003
      IF (DISC) 15,25,35                                                MAIN0004
   15 R = 0.0 - 0.5 * B/A                                               MAIN0005
      AI = 0.5 * SQRTF(0.0-DISC)/A                                      MAIN0006
      PRINT 11,R,AI                                                     MAIN0007
      GO TO 99                                                          MAIN0008
   25 R = 0.0 - 0.5 * B/A                                               MAIN0009
      PRINT 21,R                                                        MAIN0010
      GO TO 99                                                          MAIN0011
   35 SD = SQRTF(DISC)                                                  MAIN0012
      R1 = 0.5*(SD-B)/A                                                 MAIN0013
      R2 = 0.5*(0.0-(B+SD))/A                                           MAIN0014
      PRINT 31,R2,R1                                                    MAIN0015
   99 STOP                                                              MAIN0016
   10 FORMAT( 3F12.5 )                                                  MAIN0017
   11 FORMAT( 19H TWO COMPLEX ROOTS:, F12.5,14H PLUS OR MINUS,          MAIN0018
     * F12.5, 2H I )                                                    MAIN0019
   21 FORMAT( 15H ONE REAL ROOT:, F12.5 )                               MAIN0020
   31 FORMAT( 16H TWO REAL ROOTS:, F12.5, 5H AND , F12.5 )              MAIN0021
      END                                                               MAIN0022

This illustrative program, unlike the one on the previous page, has sequence numbers. Now, here's the same program in ALTAC:

MAIN0002        READ 10,A,B,C $
MAIN0003        DISC = B*B-4*A*C $
MAIN0005   NEGA R = 0.0 - 0.5 * B/A $
MAIN0006        AI = 0.5 * SQRTF(0.0-DISC)/A $
MAIN0007        PRINT 11,R,AI $
MAIN0008        GO TO FINISH $
MAIN0009   ZERO R = 0.0 - 0.5 * B/A $
MAIN0010        PRINT 21,R $
MAIN0011        GO TO FINISH $
MAIN0013        R1 = 0.5*(SD-B)/A $
MAIN0014        R2 = 0.5*(0.0-(B+SD))/A $
MAIN0015        PRINT 31,R2,R1 $
MAIN0017     10 FORMAT( 3F12.5 ) $
MAIN0019        F12.5, 2H I ) $
MAIN0020     21 FORMAT( 15H ONE REAL ROOT:, F12.5 ) $
MAIN0021     31 FORMAT( 16H TWO REAL ROOTS:, F12.5, 5H AND , F12.5 ) $
MAIN0022        END $

In ALTAC, by default, the first 8 characters, rather than the last 8 characters, of the card were ignored. This was done in order to retain compatibility with the format of the existing assembler language for that computer. An option was available, however, to read in programs using the same columns as regular FORTRAN, although using that option did not do away with the requirement to end each statement with a dollar sign.

Note that ALTAC, like PL/I and ALGOL, allowed labels to be names, not just numbers, and that ending each statement with a dollar sign means that no explicit symbol for a continuation card is required.

Also note that the asterisk character is required to indicate a comment.

There were other versions of FORTRAN II that were modified slightly, so that the format of the language was not quite compatible.

The same program, in 4K FORTRAN for the PDP-8 computer (and its predecessor, the PDP-5) would look like this:

      READ 10,A,B,C
      DISC = B*B-4*A*C
      IF (DISC) 15,25,35
  15; R = 0.0 - 0.5 * B/A
      AI = 0.5 * SQTF(0.0-DISC)/A
      PRINT 11,R,AI
      GO TO 99
  25; R = 0.0 - 0.5 * B/A
      PRINT 21,R
      GO TO 99
  35; SD = SQTF(DISC)
      R1 = 0.5*(SD-B)/A
      R2 = 0.5*(0.0-(B+SD))/A
      PRINT 31,R2,R1
  99; STOP
  10; FORMAT( 3F12.5 )
      F12.5, 2H I )
  21; FORMAT( 15H ONE REAL ROOT:, F12.5 )
  31; FORMAT( 16H TWO REAL ROOTS:, F12.5, 5H AND , F12.5 )

The most noticeable difference between this version of FORTRAN and conventional FORTRAN is that a semicolon is required after every statement label. Note that one is also required after the C indicating a comment card.

Less easily visible is that a continuation card is indicated by a single quote on the previous line, the one to be continued. Also, the square root function is now SQTF.

As the PDP-8 is a computer with a 12-bit word, statement numbers can only be in the range from 1 to 2047.

Using a semicolon to separate the statement number from the statement, and ' to continue a statement on the next line, indicates that this form of FORTRAN supported free-format entry of programs. This was reasonable, given that it was for use with smaller PDP-8 systems that used an ASR 33 teletypewriter for input and not a card reader. The semicolon after the C for a comment may have meant that statements could even start in column 1; in designing my own language, I felt this was taking free format too far, but free-format input in Fortran 90 and its successors also permits this, but in a different way, as we shall see.

Copyright (c) 2007 John J. G. Savard

[Next] [Up] [Previous] [Home] [Other]