IF, ELSE and Condition Names

Conditionals are the bedrock of any program’s logic. In COBOL, testing conditions is primarily done using the IF statement. While the syntax might seem familiar at first glance, COBOL has a few unique quirks regarding how it handles the end of an IF block and how it deals with boolean values.

The IF Statement

A basic IF statement in COBOL reads like English. You test a condition, optionally provide an ELSE branch, and close the block.

       IDENTIFICATION DIVISION.
       PROGRAM-ID. BASIC-IF.
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 AGE PIC 99 VALUE 20.
       PROCEDURE DIVISION.
           IF AGE >= 18
               DISPLAY 'ADULT'
           ELSE
               DISPLAY 'MINOR'
           END-IF.
           STOP RUN.

ADULT

The Crucial END-IF

In the example above, notice the END-IF. This is an explicit scope terminator. It tells the compiler exactly where the IF statement ends.

In older dialects of COBOL (prior to COBOL-85), END-IF didn’t exist. Instead, you had to close an IF block using a period (.). This led to one of the most infamous bugs in COBOL history: the runaway period bug.

If you accidentally placed a period inside an IF branch, it would implicitly close all currently open IF statements.

       IDENTIFICATION DIVISION.
       PROGRAM-ID. RUNAWAY.
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 COUNTER PIC 9 VALUE 1.
       PROCEDURE DIVISION.
           IF COUNTER = 0
               DISPLAY 'ZERO'.
               ADD 1 TO COUNTER.
           DISPLAY COUNTER.
           STOP RUN.

2

A novice would expect this program to output 1 because COUNTER is not 0, so the entire indented block should be skipped. But because of the rogue period after 'ZERO', the IF statement closes immediately. The ADD 1 TO COUNTER statement is entirely outside the IF logic and executes unconditionally, resulting in 2! This is why modern COBOL developers strongly prefer END-IF.

The SVG: Scope Terminations

This diagram visualizes how END-IF safely encapsulates logic, whereas a stray period slices through scopes unexpectedly.

CONTINUE vs NEXT SENTENCE

Sometimes you want an IF branch to explicitly do nothing. You have two options, but they behave very differently.

• CONTINUE: Passes control to the next executable statement. It acts like a pass statement in modern languages.
• NEXT SENTENCE: Completely abandons the current flow and jumps to the statement following the closest following period (.).

       IDENTIFICATION DIVISION.
       PROGRAM-ID. NEXT-TEST.
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 AGE PIC 99 VALUE 25.
       PROCEDURE DIVISION.
           IF AGE > 20
               IF AGE = 25
                   NEXT SENTENCE
               ELSE
                   DISPLAY 'NOT 25'
               END-IF
               DISPLAY 'INSIDE OUTER IF'
           END-IF.
           DISPLAY 'AFTER OUTER IF'.
           STOP RUN.

AFTER OUTER IF

Notice how INSIDE OUTER IF was completely skipped! NEXT SENTENCE bypassed the END-IFs and jumped directly to the period at the end of the outer IF block. IBM’s official documentation notes that NEXT SENTENCE is considered an archaic construct. Always use CONTINUE.

88-Levels: COBOL’s Boolean Variables

COBOL does not have a native boolean data type (like true or false). Instead, it uses 88-level condition names.

An 88-level item doesn’t occupy any memory itself. It sits immediately below a variable and acts as an alias for a specific value (or range of values) that the parent variable might hold.

       IDENTIFICATION DIVISION.
       PROGRAM-ID. COND-NAME.
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 USER-ROLE PIC X VALUE 'A'.
          88 IS-ADMIN VALUE 'A'.
          88 IS-GUEST VALUE 'G'.
       PROCEDURE DIVISION.
           IF IS-ADMIN
               DISPLAY 'WELCOME ADMIN'
           END-IF.
           STOP RUN.

WELCOME ADMIN

Instead of writing IF USER-ROLE = 'A', we can simply write IF IS-ADMIN. This makes the PROCEDURE DIVISION highly readable and self-documenting.