|
HP OpenVMS Systems Documentation |
|
HP Fortran for OpenVMS
|
| Previous | Contents | Index |
The CONTINUE statement is primarily used to terminate a labeled DO construct when the construct would otherwise end improperly with either a GO TO, arithmetic IF, or other prohibited control statement.
The CONTINUE statement takes the following form:
|
The statement by itself does nothing and has no effect on program results or execution sequence.
The following example shows a CONTINUE statement:
DO 150 I = 1,40
40 Y = Y + 1
Z = COS(Y)
PRINT *, Z
IF (Y .LT. 30) GO TO 150
GO TO 40
150 CONTINUE
|
The DO construct controls the repeated execution of a block of statements or constructs. (This repeated execution is called a loop.)
The number of iterations of a loop can be specified in the initial DO statement in the construct, or the number of iterations can be left indefinite by a simple DO ("DO forever") construct or DO WHILE statement.
The EXIT and CYCLE statements modify the execution of a loop. An EXIT statement terminates execution of a loop, while a CYCLE statement terminates execution of the current iteration of a loop. For example:
DO READ (EUNIT, IOSTAT=IOS) Y IF (IOS /= 0) EXIT IF (Y < 0) CYCLE CALL SUB_A(Y) END DO |
If an error or end-of-file occurs, the DO construct terminates. If a negative value for Y is read, the program skips to the next READ statement.
A DO construct takes one of the following forms:
Block Form
|
Nonblock Form
|
name
Is the name of the DO construct.label
Is a statement label identifying the terminal statement.loop-control
Is a DO iteration (see Section 7.6.2.1) or a (DO) WHILE statement (see Section 7.6.3).block
Is a sequence of zero or more statements or constructs.term-stmt
Is the terminal statement for the construct.
A block DO construct is terminated by an END DO or CONTINUE statement. If the block DO statement contains a label, the terminal statement must be identified with the same label. If no label appears, the terminal statement must be an END DO statement.
If a construct name is specified in a block DO statement, the same name must appear in the terminal END DO statement. If no construct name is specified in the block DO statement, no name can appear in the terminal END DO statement.
A nonblock DO construct is terminated by an executable statement (or construct) that is identified by the label specified in the nonblock DO statement. A nonblock DO construct can share a terminal statement with another nonblock DO construct. A block DO construct cannot share a terminal statement.
The following cannot be terminal statements for nonblock DO constructs:
The nonblock DO construct is an obsolescent feature in Fortran 95 and Fortran 90.
The following example shows equivalent block DO and nonblock DO constructs:
DO I = 1, N ! Block DO
TOTAL = TOTAL + B(I)
END DO
DO 20 I = 1, N ! Nonblock DO
20 TOTAL = TOTAL + B(I)
|
The following example shows a simple block DO construct (contains no iteration count or DO WHILE statement):
DO READ *, N IF (N == 0) STOP CALL SUBN END DO |
The DO block executes repeatedly until the value of zero is read. Then the DO construct terminates.
The following example shows a named block DO construct:
LOOP_1: DO I = 1, N
A(I) = C * B(I)
END DO LOOP_1
|
The following example shows a nonblock DO construct with a shared terminal statement:
DO 20 I = 1, N DO 20 J = 1 + I, N 20 RESULT(I,J) = 1.0 / REAL(I + J) |
On obsolescent features in Fortran 95 and Fortran 90, see Appendix A.
7.6.2 Execution of DO Constructs
The range of a DO construct includes all the statements and constructs that follow the DO statement, up to and including the terminal statement. If the DO construct contains another construct, the inner (nested) construct must be entirely contained within the DO construct.
Execution of a DO construct differs depending on how the loop is controlled, as follows:
DO iteration loop control takes the following form:
|
do-var
Is the name of a scalar variable of type integer or real. It cannot be the name of an array element or structure component.expr
Is a scalar numeric expression of type integer or real. If it is not the same type as do-var, it is converted to that type.
A DO variable or expression of type real is a deleted feature in Fortran 95; it was obsolescent in Fortran 90. HP Fortran fully supports features deleted in Fortran 95.
The following steps are performed in iteration loop control:
MAX(INT((expr2 - expr1 + expr3) / expr3), 0)
expr1 > expr2 and expr3 > 0
expr1 < expr2 and expr3 < 0
After termination, the DO variable retains its last value (the one it had when the iteration count was tested and found to be zero).
The DO variable must not be redefined or become undefined during execution of the DO range.
If you change variables in the initial, terminal, or increment expressions during execution of the DO construct, it does not affect the iteration count. The iteration count is fixed each time the DO construct is entered.
The following example specifies 25 iterations:
DO 100 K=1,50,2 |
K=49 during the final iteration, K=51 after the loop.
The following example specifies 27 iterations:
DO 350 J=50,-2,-2 |
J=--2 during the final iteration, J=--4 after the loop.
The following example specifies 9 iterations:
DO NUMBER=5,40,4 |
NUMBER=37 during the final iteration, NUMBER=41 after the loop. The terminating statement of this DO loop must be END DO.
On obsolescent features in Fortran 95 and Fortran 90, as well as
features deleted in Fortran 95, see Appendix A.
7.6.2.2 Nested DO Constructs
A DO construct can contain one or more complete DO constructs (loops). The range of an inner nested DO construct must lie completely within the range of the next outer DO construct. Nested nonblock DO constructs can share a labeled terminal statement.
Figure 7-2 shows correctly and incorrectly nested DO constructs.
Figure 7-2 Nested DO Constructs
In a nested DO construct, you can transfer control from an inner construct to an outer construct. However, you cannot transfer control from an outer construct to an inner construct.
If two or more nested DO constructs share the same terminal statement,
you can transfer control to that statement only from within the range
of the innermost construct. Any other transfer to that statement
constitutes a transfer from an outer construct to an inner construct,
because the shared statement is part of the range of the innermost
construct.
A DO construct has an extended range if both of the following are true:
The range of the construct is extended to include all executable
statements between the destination statement of the first transfer and
the statement that returns control to the construct.
The following rules apply to a DO construct with extended range:
Figure 7-3 illustrates valid and invalid extended range control
transfers.
Figure 7-3 Control Transfers and Extended Range
7.6.2.3 Extended Range
7.6.3 DO WHILE Statement
The DO WHILE statement executes the range of a DO construct while a specified condition remains true. The statement takes the following form:
|
label
Is a label specifying an executable statement in the same program unit.expr
Is a scalar logical expression enclosed in parentheses.
Before each execution of the DO range, the logical expression is evaluated. If it is true, the statements in the body of the loop are executed. If it is false, the DO construct terminates and control transfers to the statement following the loop.
If no label appears in a DO WHILE statement, the DO WHILE loop must be terminated with an END DO statement.
You can transfer control out of a DO WHILE loop but not into a loop from elsewhere in the program.
The following example shows a DO WHILE statement:
CHARACTER*132 LINE ... I = 1 DO WHILE (LINE(I:I) .EQ. ' ') I = I + 1 END DO |
The following examples show required and optional END DO statements:
| Required | Optional |
| DO WHILE (I .GT. J) | DO 10 WHILE (I .GT. J) |
| ARRAY(I,J) = 1.0 | ARRAY(I,J) = 1.0 |
| I = I - 1 | I = I - 1 |
| END DO | 10 END DO |
The CYCLE statement interrupts the current execution cycle of the innermost (or named) DO construct.
The CYCLE statement takes the following form:
|
name
Is the name of the DO construct.
When a CYCLE statement is executed, the following occurs:
Any executable statements following the CYCLE statement (including a labeled terminal statement) are not executed.
A CYCLE statement can be labeled, but it cannot be used to terminate a DO construct.
The following example shows a CYCLE statement:
DO I =1, 10 A(I) = C + D(I) IF (D(I) < 0) CYCLE ! If true, the next statement is omitted A(I) = 0 ! from the loop and the loop is tested again. END DO |
The EXIT statement terminates execution of a DO construct. It takes the following form:
|
name
Is the name of the DO construct.
The EXIT statement causes execution of the named (or innermost) DO construct to be terminated.
If a DO construct name is specified, the EXIT statement must be within the range of that construct.
Any DO variable present retains its last defined value.
An EXIT statement can be labeled, but it cannot be used to terminate a DO construct.
The following example shows an EXIT statement:
LOOP_A : DO I = 1, 15 N = N + 1 IF (N > I) EXIT LOOP_A END DO LOOP_A |
The END statement marks the end of a program unit. It takes one of the following forms:
|
For internal procedures and module procedures, you must specify the FUNCTION and SUBROUTINE keywords in the END statement; otherwise, the keywords are optional.
In main programs, function subprograms, and subroutine subprograms, END statements are executable and can be branch target statements. If control reaches the END statement in these program units, the following occurs:
The END statement cannot be continued in a program unit, and no other statement in the program unit can have an initial line that appears to be the program unit END statement.
The END statements in a module or block data program unit are nonexecutable.
The IF construct conditionally executes one block of statements or constructs.
The IF statement conditionally executes one statement.
The decision to transfer control or to execute the statement or block is based on the evaluation of a logical expression within the IF statement or construct.
On the arithmetic IF statement, see Section 7.2.4.
7.8.1 IF Construct
The IF construct conditionally executes one block of constructs or statements depending on the evaluation of a logical expression. (This construct was called a block IF statement in FORTRAN 77.)
The IF construct takes the following form:
|
name
Is the name of the IF construct.expr
Is a scalar logical expression enclosed in parentheses.block
Is a sequence of zero or more statements or constructs.
If a construct name is specified at the beginning of an IF THEN statement, the same name must appear in the corresponding END IF statement. The same construct name must not be used for different named constructs in the same scoping unit.
Depending on the evaluation of the logical expression, one block or no block is executed. The logical expressions are evaluated in the order in which they appear, until a true value is found or an ELSE or END IF statement is encountered.
Once a true value is found or an ELSE statement is encountered, the block immediately following it is executed and the construct execution terminates.
If none of the logical expressions evaluate to true and no ELSE statement appears in the construct, no block in the construct is executed and the construct execution terminates.
No additional statement can be placed after the IF THEN statement in a block IF construct. For example, the following statement is invalid in the block IF construct:
This statement is translated as the following logical IF statement:
|
You cannot use branching statements to transfer control to an ELSE IF statement or ELSE statement. However, you can branch to an END IF statement from within the IF construct.
Figure 7-4 shows the flow of control in IF constructs.
Figure 7-4 Flow of Control in IF Constructs
You can include an IF construct in the statement block of another IF construct, if the nested IF construct is completely contained within a statement block. It cannot overlap statement blocks.
The following example shows the simplest form of an IF construct:
| Form | Example |
|---|---|
| IF (expr) THEN | IF (ABS(ADJU) .GE. 1.0E-6) THEN |
| block | TOTERR = TOTERR + ABS(ADJU) |
| QUEST = ADJU/FNDVAL | |
| END IF | END IF |
This construct conditionally executes the block of statements between the IF THEN and the END IF statements.
The following example shows an IF construct containing an ELSE statement:
| Form | Example |
|---|---|
| IF (expr) THEN | IF (NAME .LT. 'N') THEN |
| block1 | IFRONT = IFRONT + 1 |
| FRLET(IFRONT) = NAME(1:2) | |
| ELSE | ELSE |
| block2 | IBACK = IBACK + 1 |
| END IF | END IF |
Block1 consists of all the statements between the IF THEN and ELSE statements. Block2 consists of all the statements between the ELSE and the END IF statements.
If the value of the character variable NAME is less than ' N ' , block1 is executed. If the value of NAME is greater than or equal to ' N ' , block2 is executed.
The following example shows an IF construct containing an ELSE IF THEN statement:
| Form | Example |
|---|---|
| IF (expr) THEN | IF (A .GT. B) THEN |
| block1 | D = B |
| F = A - B | |
| ELSE IF (expr) THEN | ELSE IF (A .GT. B/2.) THEN |
| block2 | D = B/2. |
| F = A - B/2. | |
| END IF | END IF |
| Previous | Next | Contents | Index |