Of Middle-Tested Loops

July 27, 2005 Hey, Ted

I recently came across the Recursion and the Alternatives story that you wrote, which gives an example of a program that explodes a bill of material. I noticed that in this program, you used the following statement:

DOW      '1'

Can you explain what this means? I have been preaching the importance of readability in programs and this baffles me. It seems like it would be better to code something like DOW NOT %EOF(MYFILE). I am actually using a modified version of your “Chase” routine, but this DOW ‘1’ statement bugs me.

–Eric

This is not the sort of thing I like to deal with in Four Hundred Guru. I prefer to address practical problems, and how a person codes loops seems like small potatoes to me. However, I’ve received some email about this topic, and this topic shows up occasionally in Web forums, so here goes.

RPG has been a very successful language because it is suited for business computing tasks, especially file processing and report generation. In all its forms, even indicator-infested RPG II, it stands in contradistinction to academic, scientific, and mathematical languages such as those I have studied, used, and taught. To sum it up in one word, RPG is practical.

But RPG is not perfect. Consider its looping structures. There are three: a top-tested loop, which controls operations that may not need to be executed at all; a bottom-tested loop, which controls operations that must be executed at least once, and a counted loop.

But many loops don’t fit these patterns. RPG lacks a middle-tested loop, a structure to control a set of operations that must be executed at least once and a set of operations that may not need to run at all. Look at this section of code from the article Eric mentioned.

C                   dow       '1'
C                   read      EndItem
C                   if        %eof()
C                   leave
C                   endif
C                   callp     Chase (EI_ItemNbr: EI_ItemNbr)
C                   enddo

This example contains both top-tested and bottom-tested operations. The READ must be done at least once. The CALLP may not run at all.

The DOW ‘1’ construct sets up an infinite loop. It’s up to the programmer to ensure that at least one LEAVE is coded in the loop somewhere. Consider the alternatives. Here are two.

C                   read      EndItem
C                   dow       not %eof(EndItem)
C                   callp     Chase (EI_ItemNbr: EI_ItemNbr)
C                   read      EndItem
C                   enddo

This version uses a top-tested loop, but requires that the READ be duplicated.

C                   dou       %eof(EndItem)
C                   read      EndItem
C                   if        not %eof(EndItem)
C                   callp     Chase (EI_ItemNbr: EI_ItemNbr)
C                   endif
C                   enddo

This version uses a bottom-tested loop with a redundant test for end-of-file. Neither of these seems an improvement to me over the DOW ‘1’ method.

Another problem is that loops are often terminated by more than one condition. For instance, end-of-file might be the normal way to stop a loop, but a certain error condition might also stop it. DOW NOT %EOF gives the impression that there is only one way to stop the loop. A middle-tested loop would contain two LEAVE operations, which makes it obvious that more than one condition can terminate the loop.

I’ve coded middle-tested loops various ways and I like this method best of all. Once you get used to it, which doesn’t take long, it’s as intuitive as DOW and DOU.

I would like to see IBM add another looping structure that could handle top-, bottom-, and middle-tested loops. Here’s a suggestion.

C                   loop
C                   read      EndItem
C                   if        %eof()
C                   leave
C                   endif
C                   callp     Chase (EI_ItemNbr: EI_ItemNbr)
C                   endloop

I like Eric’s premise, which is that code should be readable. I have to work on the code of people who didn’t share his programming philosophy.

–Ted