Controls execution of DO loop.
Syntax
[ construct-name :] DO [ label ] [ loop-control ] |
 |
- construct-name
is the name given to the DO
construct. If construct-name is specified,
an END DO statement
must appear at the end of the DO
construct and have the same construct-name.
- label
is the label of an executable statement that terminates
the DO loop.
If you specify label, you can terminate
the DO loop either
with an END DO
statement or with an executable statement; the terminating statement
must include label. If you do not specify
label, you must terminate the DO
loop with the END DO
statement.
- loop-control
is information used by the DO
statement to control the loop. It can take one of the following
forms:
index = init, limit
[, step]
WHILE (logical-expression)
In the first form, index is a scalar
variable of type integer or real; init,
limit, and step
are scalar expressions of type integer or real. In the second form,
logical-expression is a scalar logical
expression. In the third form, loop-control
is omitted. If you use the second or third form, you must terminate
the DO loop with the END DO
statement.
Description
The syntax of the DO
statement allows for the following types of DO
loops:
Counter-controlled loop: a loop count
is calculated that controls the number of times the block is executed,
unless a prior exit occurs. A loop variable is incremented or decremented
after each execution.
While loop: a condition (logical-expression)
is tested before each execution of the block; when it is false,
execution ceases. An exit may occur at any time.
Infinite loop: there is no loop-control;
repeated execution of the block ceases only when an exit from the
loop occurs.
When label is present in the DO
statement, it specifies the label of the terminating statement of
the DO loop.
The terminating statement cannot be any
of the following statements:
END,
END IF, END SELECT,
or END WHERE
Any nonexecutable statement
Note, however, that the terminating statement can be an IF
(logical) or an END DO
statement.
To maintain compatibility with some older versions of Fortran,
you can use the +onetrip
compile-line option to ensure that every counter-controlled DO
loop in the program executes at least once.
Extended-range DO loops
Extended-range DO
loops—a compatibility extension—allow a program
to transfer control outside the DO
loop's range and then back into the DO
loop. Extended-range DO
loops work as follows: if a control statement inside a DO
loop transfers control to a statement outside the DO
loop, then any subsequent statement can transfer control back into
the body of the DO
loop.
For example, in the following code, the range of the DO
loop is extended to include the statement GOTO
20, which transfers
control back to the body of the DO
loop:
DO 50 i = 1, 10
20 n = n + 1
IF (n > 10) GOTO 60
50 CONTINUE ! normally, the range ends here
60 n = n + 100 ! this is the extended range,
GOTO 20 ! which extends down to this line
|
Examples
The following DO
construct displays the integers 1 through 10:
DO i = 1, 10
WRITE (*, *) i
END DO |
The next example is a FORTRAN 77-style DO
loop that does the same as the preceding example:
DO 50 i = 1, 10
WRITE (*, *) i
50 CONTINUE |
The following DO
construct iterates 5 times, decrementing the loop index from 10
to 2:
The following is an example of a DO WHILE
loop:
DO WHILE (sum < 100.0)
sum = sum + get_num(unit)
END DO |
The following example illustrates the use of the EXIT
statement to exit from a nested DO
loop. The loops are named to control which loop is exited. Note
that loop-control is missing from both
the inner and outer loops, which therefore can be exited only by
means of one of the EXIT
statements:
outer:DO
READ *, val
new_val = 0
inner:DO
new_val = new_val + proc_val(val)
IF (new_val >= max_val) EXIT inner
IF (new_val == 0) EXIT outer
END DO inner
END DO outer |
The next DO
construct never executes:
Related statements
CONTINUE,
CYCLE, END
(construct), and EXIT
Related concepts
For related information, see the following:
Printable version
