Easytrieve DO Statement

Statement Format

1
2
3
4
5
6
7
8
9
     {WHILE}
DO   {     }  conditional-expression
     {UNTIL}
 
     statement-1
     ...
     statement-n
 
END-DO

You pick either WHILE or UNTIL - the braces in the syntax mean the choice is mandatory. After the keyword comes a conditional expression, the same kind of test you would write on an IF statement. Between the DO line and END-DO you place the statements to repeat, called the loop body. END-DO is required: every DO must have a matching END-DO, and the compiler rejects the program if one is missing.

DO WHILE: Test First, Then Loop

DO WHILE evaluates the condition before executing the body. If the condition is true, the body runs and control branches back to test the condition again. The loop continues as long as the condition stays true. As soon as the condition is false, control jumps to the first statement after END-DO. Because the test happens first, a DO WHILE whose condition is false at the very start executes its body zero times - the loop is completely skipped. This makes DO WHILE the right choice when it is valid, and sometimes necessary, to do nothing.

1
2
3
4
5
6
JOB INPUT PERSNL NAME DO-EX-1
   CTR = 0
   DO WHILE CTR LT 10
     CTR = CTR + 1
     ** Logic **
   END-DO

Here CTR starts at 0. The condition CTR LT 10 (CTR less than 10) is tested first; while it holds, the body increments CTR and does its work. When CTR reaches 10 the condition is false and the loop ends, so the body runs exactly ten times. Notice the counter is both initialized before the loop and incremented inside it - that is what makes the loop terminate.

DO UNTIL: Loop First, Then Test

DO UNTIL runs the body first, then evaluates the condition. If the condition is false the loop repeats; when the condition becomes true, control passes to the statement after END-DO. Because the body executes before the first test, DO UNTIL always runs at least once - even if the exit condition is already true when the loop is entered. Use DO UNTIL when the work inside must happen at least one time regardless of the starting state.

1
2
3
4
5
6
JOB INPUT PERSNL NAME DO-EX-2
   CTR = 0
   DO UNTIL CTR GE 10
     CTR = CTR + 1
     ** Logic **
   END-DO

This loop increments CTR once, then checks whether CTR is greater than or equal to 10. It keeps going until that test is true, again giving ten passes. The logic looks similar to the WHILE version because both counters run 0 through 10, but the mental model is reversed: WHILE says "keep going while there is more to do", UNTIL says "keep going until the goal is reached".

WHILE Versus UNTIL Side by Side

Conditional Expressions in DO

The condition on a DO uses the same relational operators as IF. You compare a field to another field, a literal, or an arithmetic expression using operators such as EQ or =, NE, LT or <, LE or <=, GT or >, and GE or >=. You can combine several tests with AND and OR, and use parentheses to group them. This lets a loop exit on more than one condition at once, such as stopping when a counter overflows or a sentinel value appears.

1
2
3
4
5
6
7
DO UNTIL (W20-STRIP-COUNT > 30) +
         OR (W20-OUT-COUNT > 20)
   IF W20-STRIP-CHAR(W20-STRIP-COUNT) ALPHABETIC
      W20-OUT-COUNT = W20-OUT-COUNT + 1
   END-IF
   W20-STRIP-COUNT = W20-STRIP-COUNT + 1
END-DO

This loop stops as soon as either counter passes its limit. The plus sign at the end of the first line is the Easytrieve continuation character, letting a long condition span two source lines.

Nesting DO Loops

You can put one DO loop inside another. Each loop keeps its own condition and its own END-DO, and the inner loop runs completely for every single pass of the outer loop. Nested loops are the standard way to process grids, tables of tables, or every combination of two ranges.

1
2
3
4
5
6
7
8
9
10
11
JOB INPUT NULL NAME MYPROG
   DO WHILE COUNT-1 LT 10
     COUNT-1 = COUNT-1 + 1
     COUNT-2 = 0
     DO WHILE COUNT-2 < 10
       COUNT-2 = COUNT-2 + 1
       RESULT = COUNT-1 * COUNT-2
       DISPLAY 'COUNT-1= ' COUNT-1 '  COUNT-2= ' COUNT-2 +
               '  RESULT= ' RESULT
     END-DO
   END-DO

The outer loop advances COUNT-1 from 1 to 10. For each value the inner loop resets COUNT-2 to 0 and counts it up to 10, printing the product. Resetting COUNT-2 at the top of every outer pass is essential - forget it and the inner loop only runs the first time.

Avoiding Infinite Loops

A DO loop only ends when its condition changes. If the body never moves the control variable toward the exit, the condition never flips and the program loops forever, eventually abending on a time limit. Three rules prevent this: initialize the control variable before the loop, test it in the DO condition, and change it inside the body on every path. When a loop has multiple exit conditions, make sure at least one of them is guaranteed to be reached.

• Initialize the counter or flag before the DO.
• Make sure every path through the body moves toward the exit condition.
• Reset inner-loop counters at the top of each outer-loop pass.
• Prefer a counter with a clear upper bound over an open-ended flag when possible.

DO Versus GOTO Looping

Older Easytrieve code sometimes built loops with LABEL and GOTO instead of DO. The DO construct is strongly preferred because the loop boundary is explicit (DO to END-DO), the exit condition is stated up front, and there is no risk of jumping into the middle of a block. Reserve GOTO for special early-exit cases such as GOTO JOB to skip to the next record, and use DO for genuine repetition.

Explain It Like I'm Five

A DO loop is like being told "keep clapping". DO WHILE is the careful teacher who checks first: "Do you still have energy? Yes? Then clap once more" - and if you were already tired you would not clap at all. DO UNTIL is the teacher who says "Clap once, now are we done? No? Clap again" - so you always clap at least one time. END-DO is the teacher saying "okay, stop now". And if the teacher forgets to ever ask if you are done, you would clap forever - that is an infinite loop.

Exercises

1. Write a DO WHILE loop that prints the numbers 1 through 5 using a counter.
2. Rewrite the same loop as a DO UNTIL and explain why the counter test changes.
3. Describe a situation where DO WHILE running zero times is the correct behaviour.
4. Write nested loops that print every pair (row, column) for a 3 by 3 grid.
5. Identify the missing statement that would turn a working loop into an infinite loop.