{"id":11217,"date":"2025-07-17T02:00:00","date_gmt":"2025-07-17T06:00:00","guid":{"rendered":"https:\/\/www.both.org\/?p=11217"},"modified":"2025-07-15T16:26:56","modified_gmt":"2025-07-15T20:26:56","slug":"3-ways-to-write-bugs-with-fortran-77","status":"publish","type":"post","link":"https:\/\/www.both.org\/?p=11217","title":{"rendered":"3 ways to write bugs with FORTRAN 77"},"content":{"rendered":"
\r\n
\r\n \r\n <\/i>\r\n <\/a>\r\n <\/span>\r\n<\/div><\/div>\n

I learned FORTRAN 77 programming when I was an undergraduate physics student in the early 1990s. While the Fortran 90 version of the language had been defined since 1990, and accepted by ANSI shortly after, my university didn’t have a Fortran 90 compiler on our VAX systems. And because FORTRAN 77 was long known as the standard FORTRAN<\/em>, I never bothered to learn the newer variations.<\/p>\n\n\n\n

I used FORTRAN 77 throughout my undergraduate career to analyze lab data. I also programmed in FORTRAN 77 during a summer internship at a research laboratory; when the other researchers realized I “knew FORTRAN,” they asked me to update an older program that was originally written in FORTRAN IV, then updated to FORTRAN 66, and later to FORTRAN 77. This really gave me a “deep dive” into some weird corners of FORTRAN.<\/p>\n\n\n\n

FORTRAN 77 introduced the familiar IF<\/code> and END IF<\/code> blocks, with optional ELSE IF<\/code> and ELSE<\/code> statements, but earlier editions supported some strange IF<\/code> variations to create conditional branches. In fact, three structures from the original FORTRAN (version 1 from the mid 1950s) were interesting solutions, but can cause endless headaches if used in modern times.<\/p>\n\n\n\n

These structures will be very unfamiliar for new programmers, so I wanted to share this short list of 3 ways you can use these features to add interesting bugs to your FORTRAN programs:<\/p>\n\n\n\n

1. Arithmetic IF<\/h2>\n\n\n\n

Classic FORTRAN has a three-way IF<\/code> statement that can jump to different statement labels (labels are similar to line numbers<\/em>, but not really) depending on the value of a variable. It looks like a normal IF<\/code> statement, but you give an expression or value inside parentheses, then a list of three statement labels.<\/p>\n\n\n\n

      IF (N) 20, 90, 30<\/code><\/pre>\n\n\n\n
The IF<\/code> jumps to the first label if the value is less than zero, to the second label if the value is equal to zero, and the third label if greater than zero. Since that covers all possible values, the program should never just continue<\/em> to the next statement; it should always jump to a new statement.<\/p>\n\n\n\n
Here’s a sample program that shows the Arithmetic IF<\/code> in action. This reads an integer from the user, and prints if it is less than zero, equal to zero, or greater than zero. Enter 0<\/strong> to quit:<\/p>\n\n\n\n
      PROGRAM ARITHIF\n      INTEGER N\n10    PRINT *, 'ENTER N: (0=STOP)'\n      READ *, N\n      IF (N) 20, 90, 30\n      PRINT *, 'ERROR?'\n      GOTO 10\n20    PRINT *, '.LT.0'\n      GOTO 10\n30    PRINT *, '.GT.0'\n      GOTO 10\n90    PRINT *, '.EQ.0'\n      END<\/code><\/pre>\n\n\n\n
Note that the two lines immediately after the Arithmetic IF<\/code> should never be executed; that’s why I printed an error message, then looped back to the start:<\/p>\n\n\n\n
      PRINT *, 'ERROR?'\n      GOTO 10<\/code><\/pre>\n\n\n\n
Compile and run this program, then type in a few values to experiment with the Arithmetic IF<\/code>. I’m compiling with GNU Fortran on Linux; if you don’t have the gfortran<\/code> program, you can install it as the gcc-gfortran<\/code> package. The -Wall<\/code> option prints any warnings, and -std=legacy<\/code> tells the compiler to assume legacy<\/em> code syntax (such as FORTRAN 77) when it compiles the program:<\/p>\n\n\n\n
$ gfortran -Wall -std=legacy -o aif aif.f\n\n$ .\/aif\n ENTER N: (0=STOP)\n2\n .GT.0\n ENTER N: (0=STOP)\n1\n .GT.0\n ENTER N: (0=STOP)\n-2\n .LT.0\n ENTER N: (0=STOP)\n-1\n .LT.0\n ENTER N: (0=STOP)\n0\n .EQ.0<\/code><\/pre>\n\n\n\n
You can see that for 1 or 2, the program prints .GT.0<\/code> which is “FORTRAN-speak” for greater than zero<\/em>. For -1 or -2, the program prints .LT.0<\/code>, and for zero is prints .EQ.0<\/code> then quits.<\/p>\n\n\n\n
2. Computed GOTO<\/h2>\n\n\n\n
The Computed GOTO<\/code> is a strange beast that still gives me nightmares. It uses a list of statement labels in parentheses, plus a value or expression. If the value is 1, the GOTO<\/code> jumps to the first label; if 2, it jumps to the second label; if 3, the third label; and so on.<\/p>\n\n\n\n
      GOTO (10, 20, 30) N<\/code><\/pre>\n\n\n\n
If the value is zero or less, or if the value is greater than the count of labels<\/em>, then control passes to the next statement in the program. If the value is well controlled and you know it will always be in a specific range<\/em>, then this is a neat solution. But beware any programmer that does not put a “catch-all” statement after the Computed GOTO<\/code> to trap any errant values.<\/p>\n\n\n\n
Here’s a sample program that demonstrates how to use the Computed GOTO<\/code>. This reads an integer from the user, then prints ONE<\/code> if the value is 1, TWO<\/code> if the value is 2, and THREE<\/code> if it’s 3. For other values, the program prints a message and loops back to the start; enter zero to quit.<\/p>\n\n\n\n
      PROGRAM COMPGOTO\n      INTEGER N\n1     PRINT *, 'ENTER N: (0=STOP)'\n      READ *, N\n      GOTO (10, 20, 30) N\n      IF (N.LT.1) PRINT *, '.LT.1'\n      IF (N.GT.3) PRINT *, '.GT.3'\n      IF (N.EQ.0) GOTO 90\n      GOTO 1\n10    PRINT *, 'ONE'\n      GOTO 1\n20    PRINT *, 'TWO'\n      GOTO 1\n30    PRINT *, 'THREE'\n      GOTO 1\n90    END<\/code><\/pre>\n\n\n\n
If you compile and run the program, you can test it with a few values to see how the Computed GOTO<\/code> jumps to each statement:<\/p>\n\n\n\n
$ gfortran -Wall -std=legacy -o cgoto cgoto.f\n\n$ .\/cgoto\n ENTER N: (0=STOP)\n1\n ONE\n ENTER N: (0=STOP)\n2\n TWO\n ENTER N: (0=STOP)\n3\n THREE\n ENTER N: (0=STOP)\n4\n .GT.3\n ENTER N: (0=STOP)\n-2\n .LT.1\n ENTER N: (0=STOP)\n-1\n .LT.1\n ENTER N: (0=STOP)\n0\n .LT.1<\/code><\/pre>\n\n\n\n
When you enter zero, that’s still less than 1<\/em>, so the program prints .LT.1<\/code> before it exits.<\/p>\n\n\n\n
3. Assigned GOTO<\/h2>\n\n\n\n
The Assigned GOTO<\/code> statement is actually a two-part solution: first you use the ASSIGN<\/code> statement to save a statement label in a variable, then use GOTO<\/code> with the variable to jump to it.<\/p>\n\n\n\n
10    ASSIGN 10 TO L<\/code><\/pre>\n\n\n\n
\u2026and\u2026<\/p>\n\n\n\n
      GOTO L<\/code><\/pre>\n\n\n\n
This can be an interesting way to create a callback<\/em> so you can jump back to some previous instruction, such as before the SUBROUTINE<\/code> was added with FORTRAN II in 1958. But I never found a good reason to use this in a FORTRAN 77 program.<\/p>\n\n\n\n
Here’s an example of an Assigned GOTO<\/code> to see how to use it. This program reads an integer from the user, then prints ONE<\/code> if the value is 1, or TWO<\/code> if the value is 2, or THREE<\/code> if 3. It prints nothing for other values, and quits when the user enters zero:<\/p>\n\n\n\n
      PROGRAM AGOTO\n      INTEGER N,L\n10    ASSIGN 10 TO L\n      PRINT *, 'ENTER N: (0=STOP)'\n      READ *, N\n      IF (N.EQ.0) ASSIGN 90 TO L\n      IF (N.EQ.1) ASSIGN 1 TO L\n      IF (N.EQ.2) ASSIGN 2 TO L\n      IF (N.EQ.3) ASSIGN 3 TO L\n      GOTO L\n1     PRINT *, 'ONE'\n      GOTO 10\n2     PRINT *, 'TWO'\n      GOTO 10\n3     PRINT *, 'THREE'\n      GOTO 10\n90    END<\/code><\/pre>\n\n\n\n
Notice that statement label 10 has the initial ASSIGN<\/code> statement, which sets the label 10 to the L<\/code> variable. Later, the program can assign another label to the variable, which means we can use a simple GOTO L<\/code> statement to jump to whatever label is stored in the L<\/code> variable at the time.<\/p>\n\n\n\n
You can see the Assigned GOTO<\/code> in action if you compile the program and test it with a few values. While I usually use the -Wall<\/code> option to print all warnings, I skipped that option here because otherwise the compiler complains that my statement labels are never used; the GNU Fortran compiler doesn’t track the labels with the different values in the ASSIGN<\/code> and Assigned GOTO<\/code> statements:<\/p>\n\n\n\n
$ gfortran -std=legacy -o agoto agoto.f\n\n$ .\/agoto\n ENTER N: (0=STOP)\n1\n ONE\n ENTER N: (0=STOP)\n2\n TWO\n ENTER N: (0=STOP)\n3\n THREE\n ENTER N: (0=STOP)\n4\n ENTER N: (0=STOP)\n-1\n ENTER N: (0=STOP)\n0<\/code><\/pre>\n\n\n\n
Test them with Countdown<\/h2>\n\n\n\n
It might be helpful to compare these methods by writing several programs that do the same thing<\/em> but in different ways. This program is just a “Countdown” program; it counts from 10 to 1, and prints each number. The simplest example of this program uses the DO<\/code> loop, introduced to the language in FORTRAN 66. The basic concept of DO<\/code> is the same as a for<\/code> loop in other programming languages; you specify the start, stop, and increment values, and the program iterates a variable’s value through the loop:<\/p>\n\n\n\n
      PROGRAM COUNT\n      INTEGER I\n      DO 10 I= 10, 1, -1\n10    PRINT *, I\n      END<\/code><\/pre>\n\n\n\n
If you compile and run the program, you will get a list of numbers counting down from 10 to 1:<\/p>\n\n\n\n
$ gfortran -Wall -std=legacy -o count count.f\n\n$ .\/count\n          10\n           9\n           8\n           7\n           6\n           5\n           4\n           3\n           2\n           1<\/code><\/pre>\n\n\n\n
Now let’s make the program a little more complicated by using the Computed GOTO<\/code> instead of the DO<\/code> loop. This uses a trivial example of the Computed GOTO<\/code> with just one statement label, so the GOTO<\/code> will only jump to statement 20 (the END<\/code> statement) when N<\/code> has reached the value 1. Otherwise, control passes to the next statement, which decrements the N<\/code> variable and restarts the loop:<\/p>\n\n\n\n
      PROGRAM COUNT\n      INTEGER N\n      N = 10\n10    PRINT *, N\n      GOTO (20) N\n      N = N - 1\n      GOTO 10\n20    END<\/code><\/pre>\n\n\n\n
A slightly more unnecessarily complex version of the program uses the Arithmetic IF<\/code>. This restructures the program a little bit, by initializing the N<\/code> variable to 10, then entering a kind of “manual loop.” The Arithmetic IF<\/code> jumps to label 10 (the start of the loop) as long as the N<\/code> counter variable is greater than zero. When the count reaches zero, the Arithmetic IF<\/code> jumps to line 30 (the END<\/code> statement). This program should never have N<\/code> less than zero, so I’ve added an error statement as a fallback:<\/p>\n\n\n\n
      PROGRAM COUNT\n      INTEGER N\n      N = 10\n10    PRINT *, N\n      N = N - 1\n      IF (N) 20, 30, 10\n20    PRINT *, 'LESS THAN ZERO .. SHOULD NOT GET HERE'\n30    END<\/code><\/pre>\n\n\n\n
Walk through the program yourself to see what it does: On the first pass, N<\/code> starts at 10, the program prints it, and then decrements the N<\/code> variable. The new value (9) is greater than zero, so the program starts the loop over again. On the final pass when N<\/code> is 1, the program prints it, then decrements the variable to zero. Since N<\/code> is now zero, the Arithmetic IF<\/code> jumps to line 30, which ends the program.<\/p>\n\n\n\n
One more way to write this in the old-style syntax is with the Assigned GOTO<\/code>. This uses a separate variable called L<\/code> to store a line label. Before starting the loop, the program assigns label 10 to the L<\/code> variable; this allows the program to simply use GOTO L<\/code> to jump back to 10 by default. In the last pass of the loop when N<\/code> is 1, the program assigns label 20 (the END<\/code> statement) to the L<\/code> variable, so the program can exit.<\/p>\n\n\n\n
      PROGRAM COUNT\n      INTEGER N, L\n      ASSIGN 10 TO L\n      N = 10\n10    PRINT *, N\n      IF (N.EQ.1) ASSIGN 20 TO L\n      N = N - 1\n      GOTO L\n20    END<\/code><\/pre>\n\n\n\n
Each of these variations of the program do the same thing: count down from 10 to 1, and print each value. Writing the same program in four different ways helps us to compare what the program is doing<\/em> so we can see Arithmetic IF<\/code>, Assigned GOTO<\/code>, and Computed GOTO<\/code> in action.<\/p>\n","protected":false},"excerpt":{"rendered":"
Explore old-style FORTRAN programming with Arithmetic IF, Computed GOTO, and Assigned GOTO.<\/p>\n","protected":false},"author":33,"featured_media":5230,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_lmt_disableupdate":"","_lmt_disable":"","footnotes":""},"categories":[150],"tags":[522,152],"class_list":["post-11217","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-programming","tag-fortran77","tag-programming"],"modified_by":"David Both","_links":{"self":[{"href":"https:\/\/www.both.org\/index.php?rest_route=\/wp\/v2\/posts\/11217","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.both.org\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.both.org\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.both.org\/index.php?rest_route=\/wp\/v2\/users\/33"}],"replies":[{"embeddable":true,"href":"https:\/\/www.both.org\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=11217"}],"version-history":[{"count":1,"href":"https:\/\/www.both.org\/index.php?rest_route=\/wp\/v2\/posts\/11217\/revisions"}],"predecessor-version":[{"id":11218,"href":"https:\/\/www.both.org\/index.php?rest_route=\/wp\/v2\/posts\/11217\/revisions\/11218"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.both.org\/index.php?rest_route=\/wp\/v2\/media\/5230"}],"wp:attachment":[{"href":"https:\/\/www.both.org\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=11217"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.both.org\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=11217"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.both.org\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=11217"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}