Control Flow

EQ or =	True when values are equal.
NE or ><	True when values are not equal.
GT or >	True when the first value is greater than the second value.
GE or >= or =>	True when first value is greater than or equal to the second value.
LT or <	True when the first value is less than the second value.
LE or <= or =<	True when first value is less than or equal to the second value.

The logical condition can also contain the special operator NOT:

NOT

NOT operates on a logical expression and negates its logical value. A true (non-zero, non-missing) expression is made false and a false expression is made true. NOT operates on the expression that follows up through the next relational operator or the next un-matched right parenthesis. NOT is evaluated and resolved after the entire expression to which it applies has been resolved and before other logical operators at the same level of nesting are evaluated. For example: IF( NOT 1 GT 2 ) WRITE 'TRUE'

AND	Intersection. True if both expressions are true.
OR	Inclusive Union. True if either expression is true.
XOR	Exclusive Union. True if one but not both expressions are true.

These logical expressions resolve to either true or false. For example,

IF(1 LT 2 AND 'A' LT 'B') WRITE 'Both statements are true'

Compound Logical Operations on the same variable.

IF(ID EQ 1 OR 3 OR 12 OR 16)   WRITE ID

IF(ID EQ 1 OR ID EQ 3 OR ID EQ 12 OR ID EQ 16) WRITE ID

The following two statements are equivalent:

IF (ID EQ 1 OR ID GT 10) WRITE 'TRUE'
IF (ID EQ 1 OR GT 10)    WRITE 'TRUE'

IF (ID EQ A OR B AND NOT C)             WRITE 'TRUE'
IF (ID EQ A OR ID EQ B AND NOT ID EQ C) WRITE 'TRUE'

Precedence

1. parenthesised expressions

2. functions

3. string concatenation

4. exponentiation ( ** )

5. multiplication and division ( * and / )

6. addition and subtraction ( + and - )

7. relational operators EQ, NE, GT, GE, LT, LE

8. logical operator NOT

9. compound logical operators AND, OR, XOR

Logical Values

IF commands can directly test expressions which resolve to numeric values. Zero tests to false, missing tests to false and all other values test to true. In the following example, LOGICVAR contains the value 0 (zero) if the value of A does not equal the value of B, or 1 if it does:

COMPUTE LOGICVAR = (A EQ B)
IF (LOGICVAR) WRITE 'TRUE'
Because of the simple syntax for multiple tests on a single variable, compound conditions on logical variables must be specified with care. Consider the following two statements,

IF ( LOGVAR1 AND AGE GT 21) WRITE 'TRUE'
IF ( AGE GT 21 AND LOGVAR1) WRITE 'TRUE'

The first statement test LOGVAR1 to be 1 (true) and AGE greater than 21. However the second statement is expanded to:

IF ( AGE GT 21 AND AGE GT LOGVAR1) WRITE 'TRUE'

IF     ( logical expression ) command(s)
IFNOT  ( logical expression ) command(s)

Any VisualPQL command may be specified as the executable result of an IF/IFNOT except:

• other logical test commands

• data definition commands

• block definition commands

• compiler commands

Separate multiple commands with semi-colons (;). For example:

IF (1 EQ 1) SET X(1); WRITE 'OK'
IF (X EQ 1) SET X(0);
            WRITE 'OK 2';
            EXIT RETRIEVAL
PROCESS REC EMPLOYEE
. IFNOT(SALARY  GE  2000) NEXT REC
. WRITE NAME SALARY
END REC

JUMP  statement label
JUMP  (statement label , statement label, ...) variable

Statement labels are specified in column 1 and are a name, up to eight characters, terminated with a colon (:). When referenced in the JUMP command, do not specify the colon.

The first form of JUMP specifies a single statement label and transfers control to the point at which that label occurs.

The second form of the command, the computed JUMP, transfers control to the nth label in a specified list of labels, where the numeric variable contains the value N.

Specifies a block of commands executed when the program or retrieval is complete. The block is typically used to print report ending information and for actions that are taken just before ending the program.

Table, case or record processing commands are not allowed. Reference may not be made to any data in the database or table files. Local variables are available for output.

Specifies the beginning of a block of commands. The commands in a BEGIN block are executed when control reaches this point.

END BEGIN
Delimits the BEGIN block.

EXIT BEGIN
Transfers program control to the statement following the END BEGIN command. It is usually used conditionally to terminate processing of the block.

BEGIN can be used to anywhere in a program to group a set of commands which have some common purpose. For example, initialisation at the start of the program.

PROGRAM
BEGIN
. COMPUTE TOTAL = 0
. other initialisation commands
END BEGIN
PROCESS ROWS SCHOOLS.STUDENTS
. COMPUTE TOTAL = TOTAL + 1
. other commands performed for every row
END ROW
END PROGRAM

BEGIN is often used to create a better structure in a program with complex logical conditions and to avoid the use of JUMP or very complex IFTHEN / ELSEIF constructs. For example:

BEGIN
. IF (logical condition) EXIT BEGIN
. visualpql code
. IF (logical condition) EXIT BEGIN
. IF (logical condition) EXIT BEGIN
. visualpql code
END BEGIN

EXIT BEGIN	Exits the current BEGIN block.
EXIT CASE	Exits the current case processing block.
EXIT FOR	Exits the current FOR block.
EXIT IF	Exits the current IFTHEN or IFNOTTHEN block.
EXIT LOOP	Exits the current LOOP block.
EXIT PROCESS RECORD	Exits the current PROCESS RECORD loop.
EXIT PROCESS ROW	Exits the current PROCESS ROW loop.
EXIT PROGRAM	Terminates the PROGRAM after executing any commands in the AFTER PROGRAM block. STOP is a synonym for EXIT PROGRAM.
EXIT RECORD	Exits the current record processing block.
EXIT RETRIEVAL	Terminates the RETRIEVAL after executing any commands in the AFTER RETRIEVAL block. STOP is a synonym for EXIT RETRIEVAL.
EXIT ROW	Exits the current row processing block.
EXIT UNTIL	Exits the current UNTIL block.
EXIT WHILE	Exits the current WHILE block.

The FOR command specifies the number of times the commands in a FOR block are executed. FOR assigns a new value to the control variable each time the block is repeated.

control_var	The control variable must be a numeric variable and may not be an array element. It is incremented by the value of increment during each pass through the block. When the value of this variable exceeds the endvalue, the block is exited and control is transferred to the first statement following END FOR. If the control variable is not explicitly declared, it is declared implicitly as a REAL*8 local variable.
startvalue	Is the value to which the control variable is set when the block is first executed. This value may be a program variable, array element reference, expression or a numeric constant.
endvalue	Is the value that determines the final pass through the FOR block. This value may be a program variable, array element reference, expression or a numeric constant.
increment	Is the value by which the control variable is incremented during each pass through the block. This value may be a program variable, array element reference, expression or a numeric constant. The default increment value is 1 (one).
END FOR	Delimits the FOR block.
EXIT FOR	Terminates processing of the FOR block and transfers program control to the first statement following END FOR. This command is usually executed conditionally with an IF command or from within a conditionally executed block of commands.
NEXT FOR	Terminates processing of the current pass through the FOR block and passes control to the start of the next FOR loop after incrementing and checking the control variable.

The following sequence is executed in a FOR block:

• The control variable is set equal to the starting value, all commands in the block are executed, then the increment is added to the control variable.

• If the control variable is greater than the end value or if the control variable becomes a missing value, execution of the block is terminated. Otherwise the block is executed again.

• If either start value or end value is missing, the FOR block is skipped.

• If the control variable is a database variable (the FOR block is within a record or case block), the database variable is updated on each pass through the block.

• When the increment is positive, the FOR block is not performed when the start value is larger than the end value. When increment is negative the FOR block is not performed when the start value is smaller than the end value.

IFTHEN    (logical_expression)
IFNOTTHEN (logical_expression)

The IFTHEN command defines a block of commands which is executed conditionally.

In its simplest form, IFTHEN defines a block of commands which is executed when a logical expression is true. An IFNOTTHEN block of commands is executed when the logical expression is false. Any command may be included within an IFTHEN or IFNOTTHEN block, including other complete blocks of commands and other logical test commands.

Other conditional blocks within the condition, can be defined with the ELSE , ELSEIF, and ELSEIFNOT commands. Each conditional block is terminated with another ELSEIF, ELSE or the END IF. An IFTHEN block may contain multiple ELSEIF and ELSEIFNOT blocks. It may only contain one ELSE block.

END IF	delimits the IFTHEN block.
EXIT IF	directs the flow of the program to the statement following the END IF of the block within which it appears.
ELSE	specifies a block of commands which is executed when no other commands are executed within the IFTHEN block. The block of commands is delimited by the END IF.
ELSEIF ELSEIFNOT	specifies a block of commands which is executed when the conditions specified on the IFTHEN and any other previous ELSEIF commands are not satisfied and the condition specified on this command is satisfied. The block of commands is delimited by a further ELSEIF, ELSE or the END IF.

IFTHEN (logical expression)
.  commands executed when above expression is TRUE
. ELSEIF (logical expression)
.  commands executed when above expression is TRUE
. ELSEIFNOT (logical expression)
.  commands executed when above expression is FALSE
. ELSE
.  commands executed when no other blocks are executed
END IF

LOOP repeatedly executes a block of commands. By definition, a LOOP block is an infinite loop and a command such as EXIT or JUMP must be used to terminate looping. The compiler does not check for the existence of these commands within a LOOP.

END LOOP	delimits the LOOP block.
EXIT LOOP	Terminates looping, directing program execution to the statement following the END LOOP. This command is frequently executed conditionally, as with an IF command, to terminate the looping.
NEXT LOOP	Terminates processing of the current pass through the block and passes control to the next iteration of the current LOOP block (control is passed to the statement following LOOP).

Some blocks (e.g. WHILE) are looping structures and execute repeatedly until some controlling condition is met. In looping blocks, the NEXT blocktype command transfers control to the first command in the block at the next iteration.

If the blocktype is specified, the command transfers control to the next iteration of the innermost block of that type. If blocktype is not specified, control is transferred to the next iteration of the innermost looping block. It is good practice to specify blocktype. NEXT may be specified in the following looping blocks:

NEXT CASE	Transfers control to the next iteration of PROCESS CASES if another case exists.
NEXT FOR	Transfers control to the next iteration of the FOR, if the end condition specified on the FOR has not yet been reached.
NEXT LOOP	Transfers control to the next iteration of the LOOP.
NEXT REC	Transfers control to the next iteration of PROCESS RECORDS if another record exists.
NEXT ROW	Transfers control to the next iteration of PROCESS ROWS if another row exists.
NEXT UNTIL	Transfers control to the next iteration of the UNTIL, if the end condition specified on the UNTIL has not yet been reached.
NEXT WHILE	Transfers control to the next iteration of the WHILE, if the end condition specified on the WHILE has not yet been reached.

For example:

PROCESS REC EMPLOYEE
.  IF ( GENDER = 1 ) NEXT PROCESS REC
    ...
END  PROCESS  REC

UNTIL repeatedly executes a block of commands until the logical expression becomes true. When the expression becomes true, the block is exited and program control is transferred to the statement following the END UNTIL command.

The condition of the logical expression is tested at the start of each pass through the UNTIL block. If the condition is initially true, the block is skipped entirely.

END UNTIL	delimits the UNTIL block
NEXT UNTIL	Terminates the current pass through the block and transfers control to the next iteration of the UNTIL command. This command is usually executed conditionally, as the result of a logical test (e.g. with the IF command). This command may only be used within an UNTIL block.
EXIT UNTIL	Terminates processing of the UNTIL block and transfers program control to the statement following the END UNTIL. This command is usually executed conditionally, as the result of a logical test (e.g. with the IF command). This command may only be used within an UNTIL block.

WHILE repeatedly executes a block of commands while the expression is true. When the expression becomes false, execution of the block is terminated and program control is transferred to the statement following the END WHILE. The condition of the expression is tested at the start of each pass through the WHILE block. If the condition is initially false, the block is skipped entirely.

END WHILE	delimits the WHILE block
NEXT WHILE	Terminates the processing of the current pass through the block and passes control to the next iteration of the block. This command is usually executed conditionally, as the result of a logical test (e.g. with the IF command).
EXIT WHILE	Terminates processing of the WHILE block and transfers program control to the statement following the END WHILE. This command is usually executed conditionally, as the result of a logical test (e.g. with the IF command).

Transfers control to the first line of code in the named subprocedure. When the subprocedure is exited, control returns to the first statement following the EXECUTE SUBPROCEDURE. This command may appear anywhere in a routine including within a subprocedure.

Subprocedure Example:

PROGRAM
TIME NOON NOWTIME ('HHiMM')   | declare time variables
COMPUTE NOON = '12:00'        | set the value of midday
COMPUTE NOWTIME = NOW(0)      | get the current time
IFTHEN (NOWTIME LT NOON)
.   EXECUTE SUBPROCEDURE MORNING    | execute MORNING
. ELSE
.   EXECUTE SUBPROCEDURE AFTERN     | execute AFTERN
ENDIF
SUBPROCEDURE MORNING
. WRITE 'Good Morning'
END SUBPROCEDURE
SUBPROCEDURE AFTERN
. WRITE 'Good Afternoon'
END SUBPROCEDURE
END PROGRAM