COBOL Tutorial

COBOL PERFORM Statement

Progress0 of 0 lessons

PERFORM Statement Overview

The PERFORM statement is one of the most important control structures in COBOL. It is used to execute paragraphs or sections and control program flow. PERFORM provides various forms for different types of program control needs.

What PERFORM Can Do

The PERFORM statement has several primary uses:

Simple Execution - Execute a paragraph or section once
Conditional Loops - Execute until a condition becomes true (PERFORM UNTIL)
Fixed Iterations - Execute a specific number of times (PERFORM TIMES)
Indexed Loops - Execute with a varying variable (PERFORM VARYING)
Condition-Based Loops - Execute while a condition is true (PERFORM WHILE)
Inline Execution - Execute statements directly without separate paragraphs

Each form serves different program flow control needs.

PERFORM Statement Types

Type	Syntax	Purpose	Use Case
Simple	PERFORM paragraph-name	Execute once	One-time operations
TIMES	PERFORM paragraph-name TIMES	Execute N times	Fixed iterations
UNTIL	PERFORM paragraph-name UNTIL condition	Execute until condition true	File processing, end conditions
VARYING	PERFORM VARYING variable FROM start BY increment UNTIL condition	Execute with varying index	Table processing, arrays
WHILE	PERFORM paragraph-name WHILE condition	Execute while condition true	Condition-based loops
Inline	PERFORM statements END-PERFORM	Execute statements directly	Simple operations

Simple PERFORM

Simple PERFORM executes a paragraph or section once and then returns to the next statement in the calling paragraph.

Basic Syntax

cobol

1
2
3
4
PERFORM paragraph-name
PERFORM section-name
PERFORM paragraph-name THRU paragraph-name
PERFORM section-name THRU section-name

Simple PERFORM executes the specified paragraph or section once and returns to the next statement.

Simple PERFORM Example

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
IDENTIFICATION DIVISION.
PROGRAM-ID. SIMPLEPERFORM.
 
PROCEDURE DIVISION.
MAIN-PROCESS.
    DISPLAY "Starting main process"
    PERFORM INITIALIZATION
    PERFORM PROCESS-DATA
    PERFORM FINALIZATION
    DISPLAY "Main process completed"
    STOP RUN.
 
INITIALIZATION.
    DISPLAY "Performing initialization"
    MOVE 0 TO COUNTER
    MOVE SPACES TO OUTPUT-MESSAGE.
 
PROCESS-DATA.
    DISPLAY "Performing data processing"
    ADD 1 TO COUNTER
    MOVE "Data processed" TO OUTPUT-MESSAGE.
 
FINALIZATION.
    DISPLAY "Performing finalization"
    DISPLAY "Counter: " COUNTER
    DISPLAY "Message: " OUTPUT-MESSAGE.

This example shows how simple PERFORM calls different paragraphs in sequence.

PERFORM THRU Example

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
PROCEDURE DIVISION.
MAIN-PROCESS.
    PERFORM PROCESS-START THRU PROCESS-END
    STOP RUN.
 
PROCESS-START.
    DISPLAY "Starting process"
    PERFORM STEP-1
    PERFORM STEP-2
    PERFORM STEP-3.
 
STEP-1.
    DISPLAY "Step 1 completed".
 
STEP-2.
    DISPLAY "Step 2 completed".
 
STEP-3.
    DISPLAY "Step 3 completed".
 
PROCESS-END.
    DISPLAY "Process completed".

PERFORM THRU executes from the first paragraph through the last paragraph, including all paragraphs in between.

PERFORM TIMES

PERFORM TIMES executes a paragraph or section a specific number of times. This is useful when you know exactly how many iterations are needed.

Basic Syntax

cobol

1
2
3
4
PERFORM paragraph-name TIMES
PERFORM paragraph-name 5 TIMES
PERFORM paragraph-name COUNTER TIMES
PERFORM paragraph-name (COUNTER + 1) TIMES

PERFORM TIMES can use a literal number, a variable, or an expression to specify the number of iterations.

PERFORM TIMES Example

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
IDENTIFICATION DIVISION.
PROGRAM-ID. PERFORMTIMES.
 
WORKING-STORAGE SECTION.
01  COUNTER           PIC 9(2) VALUE 0.
01  ITERATION-COUNT   PIC 9(2) VALUE 3.
 
PROCEDURE DIVISION.
MAIN-PROCESS.
    DISPLAY "Starting PERFORM TIMES example"
    
    * Execute with literal number
    PERFORM DISPLAY-MESSAGE 5 TIMES
    
    * Execute with variable
    PERFORM DISPLAY-MESSAGE ITERATION-COUNT TIMES
    
    * Execute with expression
    PERFORM DISPLAY-MESSAGE (ITERATION-COUNT + 2) TIMES
    
    DISPLAY "PERFORM TIMES example completed"
    STOP RUN.
 
DISPLAY-MESSAGE.
    ADD 1 TO COUNTER
    DISPLAY "Iteration " COUNTER " completed".

This example shows different ways to specify the number of iterations in PERFORM TIMES.

PERFORM UNTIL

PERFORM UNTIL executes a paragraph or section repeatedly until a specified condition becomes true. This is commonly used for file processing and other scenarios where you need to continue until a termination condition is met.

Basic Syntax

cobol

1
2
3
4
PERFORM paragraph-name UNTIL condition
PERFORM section-name UNTIL condition
PERFORM paragraph-name UNTIL condition-1 OR condition-2
PERFORM paragraph-name UNTIL condition-1 AND condition-2

PERFORM UNTIL continues executing until the condition evaluates to true. The condition is checked before each iteration.

File Processing Example

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
IDENTIFICATION DIVISION.
PROGRAM-ID. PERFORMUNTIL.
 
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
    SELECT CUSTOMER-FILE ASSIGN TO "CUSTOMER.DAT"
        ORGANIZATION IS SEQUENTIAL
        ACCESS MODE IS SEQUENTIAL
        FILE STATUS IS FILE-STATUS.
 
DATA DIVISION.
FILE SECTION.
FD  CUSTOMER-FILE
    LABEL RECORDS ARE STANDARD
    RECORD CONTAINS 80 CHARACTERS.
01  CUSTOMER-RECORD.
    05  CUSTOMER-ID       PIC 9(5).
    05  CUSTOMER-NAME     PIC X(30).
    05  CUSTOMER-BALANCE  PIC 9(7)V99.
 
WORKING-STORAGE SECTION.
01  FILE-STATUS       PIC XX.
01  RECORD-COUNT      PIC 9(5) VALUE 0.
01  EOF-FLAG          PIC X VALUE "N".
    88  END-OF-FILE     VALUE "Y".
 
PROCEDURE DIVISION.
MAIN-PROCESS.
    PERFORM INITIALIZATION
    PERFORM PROCESS-FILE UNTIL END-OF-FILE
    PERFORM FINALIZATION
    STOP RUN.
 
INITIALIZATION.
    OPEN INPUT CUSTOMER-FILE
    IF FILE-STATUS NOT = "00"
        DISPLAY "Error opening file: " FILE-STATUS
        STOP RUN
    END-IF.
 
PROCESS-FILE.
    READ CUSTOMER-FILE
        AT END
            MOVE "Y" TO EOF-FLAG
        NOT AT END
            PERFORM PROCESS-CUSTOMER
    END-READ.
 
PROCESS-CUSTOMER.
    ADD 1 TO RECORD-COUNT
    DISPLAY "Processing customer " CUSTOMER-ID ": " CUSTOMER-NAME
    DISPLAY "  Balance: " CUSTOMER-BALANCE.
 
FINALIZATION.
    CLOSE CUSTOMER-FILE
    DISPLAY "Total records processed: " RECORD-COUNT.

This example shows how PERFORM UNTIL is used for file processing until end-of-file is reached.

Counter-Based Example

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
WORKING-STORAGE SECTION.
01  COUNTER           PIC 9(3) VALUE 0.
01  MAX-COUNT         PIC 9(3) VALUE 10.
01  SUM               PIC 9(5) VALUE 0.
 
PROCEDURE DIVISION.
MAIN-PROCESS.
    DISPLAY "Starting counter-based PERFORM UNTIL"
    PERFORM CALCULATE-SUM UNTIL COUNTER >= MAX-COUNT
    DISPLAY "Sum of numbers 1 to " MAX-COUNT ": " SUM
    STOP RUN.
 
CALCULATE-SUM.
    ADD 1 TO COUNTER
    ADD COUNTER TO SUM
    DISPLAY "Added " COUNTER " to sum. Current sum: " SUM.

This example shows PERFORM UNTIL with a counter-based condition.

PERFORM VARYING

PERFORM VARYING executes a paragraph or section with a variable that changes value on each iteration. This is particularly useful for table processing and indexed loops.

Basic Syntax

cobol

1
2
3
4
5
6
PERFORM VARYING variable FROM start-value BY increment UNTIL condition
PERFORM VARYING variable FROM start-value BY increment UNTIL condition
    AFTER variable2 FROM start-value2 BY increment2 UNTIL condition2
PERFORM VARYING variable FROM start-value BY increment UNTIL condition
    AFTER variable2 FROM start-value2 BY increment2 UNTIL condition2
    AFTER variable3 FROM start-value3 BY increment3 UNTIL condition3

PERFORM VARYING can have multiple AFTER clauses for nested loops. The variable is automatically incremented on each iteration.

Table Processing Example

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
IDENTIFICATION DIVISION.
PROGRAM-ID. PERFORMVARYING.
 
WORKING-STORAGE SECTION.
01  PRODUCT-TABLE.
    05  PRODUCT-ENTRY OCCURS 5 TIMES
        INDEXED BY PRODUCT-INDEX.
        10  PRODUCT-CODE      PIC X(5).
        10  PRODUCT-NAME      PIC X(20).
        10  PRODUCT-PRICE     PIC 9(5)V99.
 
01  TABLE-SIZE          PIC 9(2) VALUE 5.
01  TOTAL-VALUE         PIC 9(8)V99 VALUE 0.
 
PROCEDURE DIVISION.
MAIN-PROCESS.
    PERFORM INITIALIZE-TABLE
    PERFORM PROCESS-TABLE
    PERFORM DISPLAY-RESULTS
    STOP RUN.
 
INITIALIZE-TABLE.
    MOVE "P001" TO PRODUCT-CODE(1)
    MOVE "LAPTOP" TO PRODUCT-NAME(1)
    MOVE 999.99 TO PRODUCT-PRICE(1)
    
    MOVE "P002" TO PRODUCT-CODE(2)
    MOVE "MOUSE" TO PRODUCT-NAME(2)
    MOVE 25.50 TO PRODUCT-PRICE(2)
    
    MOVE "P003" TO PRODUCT-CODE(3)
    MOVE "KEYBOARD" TO PRODUCT-NAME(3)
    MOVE 75.00 TO PRODUCT-PRICE(3)
    
    MOVE "P004" TO PRODUCT-CODE(4)
    MOVE "MONITOR" TO PRODUCT-NAME(4)
    MOVE 299.99 TO PRODUCT-PRICE(4)
    
    MOVE "P005" TO PRODUCT-CODE(5)
    MOVE "PRINTER" TO PRODUCT-NAME(5)
    MOVE 199.99 TO PRODUCT-PRICE(5).
 
PROCESS-TABLE.
    PERFORM VARYING PRODUCT-INDEX FROM 1 BY 1 
        UNTIL PRODUCT-INDEX > TABLE-SIZE
        PERFORM PROCESS-PRODUCT
    END-PERFORM.
 
PROCESS-PRODUCT.
    DISPLAY "Product " PRODUCT-INDEX ": " 
            PRODUCT-CODE(PRODUCT-INDEX) " - " 
            PRODUCT-NAME(PRODUCT-INDEX) " - $" 
            PRODUCT-PRICE(PRODUCT-INDEX)
    ADD PRODUCT-PRICE(PRODUCT-INDEX) TO TOTAL-VALUE.
 
DISPLAY-RESULTS.
    DISPLAY "Total value of all products: $" TOTAL-VALUE.

This example shows how PERFORM VARYING is used for table processing with automatic index management.

Nested Loops Example

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
WORKING-STORAGE SECTION.
01  ROW-INDEX          PIC 9(2) VALUE 0.
01  COL-INDEX          PIC 9(2) VALUE 0.
01  MATRIX-VALUE       PIC 9(3) VALUE 0.
 
PROCEDURE DIVISION.
MAIN-PROCESS.
    DISPLAY "Creating 3x3 matrix:"
    PERFORM VARYING ROW-INDEX FROM 1 BY 1 UNTIL ROW-INDEX > 3
        AFTER COL-INDEX FROM 1 BY 1 UNTIL COL-INDEX > 3
        PERFORM CALCULATE-MATRIX-VALUE
    END-PERFORM
    STOP RUN.
 
CALCULATE-MATRIX-VALUE.
    COMPUTE MATRIX-VALUE = (ROW-INDEX - 1) * 3 + COL-INDEX
    DISPLAY "Matrix[" ROW-INDEX "," COL-INDEX "] = " MATRIX-VALUE.

This example shows nested loops using PERFORM VARYING with AFTER clauses.

PERFORM WHILE

PERFORM WHILE executes a paragraph or section while a specified condition remains true. It stops when the condition becomes false.

Basic Syntax

cobol

1
2
3
4
PERFORM paragraph-name WHILE condition
PERFORM section-name WHILE condition
PERFORM paragraph-name WHILE condition-1 AND condition-2
PERFORM paragraph-name WHILE condition-1 OR condition-2

PERFORM WHILE continues executing as long as the condition remains true. The condition is checked before each iteration.

PERFORM WHILE Example

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
WORKING-STORAGE SECTION.
01  COUNTER           PIC 9(3) VALUE 0.
01  MAX-COUNT         PIC 9(3) VALUE 10.
01  CONTINUE-FLAG     PIC X VALUE "Y".
    88  CONTINUE-PROCESSING VALUE "Y".
    88  STOP-PROCESSING     VALUE "N".
 
PROCEDURE DIVISION.
MAIN-PROCESS.
    DISPLAY "Starting PERFORM WHILE example"
    PERFORM PROCESS-DATA WHILE CONTINUE-PROCESSING AND COUNTER < MAX-COUNT
    DISPLAY "PERFORM WHILE completed. Final counter: " COUNTER
    STOP RUN.
 
PROCESS-DATA.
    ADD 1 TO COUNTER
    DISPLAY "Processing iteration " COUNTER
    
    * Simulate some condition that might stop processing
    IF COUNTER = 5
        MOVE "N" TO CONTINUE-FLAG
        DISPLAY "Stopping processing at iteration 5"
    END-IF.

This example shows PERFORM WHILE with multiple conditions.

UNTIL vs WHILE Comparison

Aspect	PERFORM UNTIL	PERFORM WHILE
Logic	Continue until condition becomes true	Continue while condition remains true
Termination	When condition becomes true	When condition becomes false
Common Use	File processing, end conditions	Valid data processing
Example	UNTIL END-OF-FILE	WHILE VALID-RECORD

Inline PERFORM

Inline PERFORM allows you to execute statements directly within the PERFORM block without defining a separate paragraph. This is useful for simple operations that don't need to be reused elsewhere in the program.

Basic Syntax

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
PERFORM
    statement-1
    statement-2
    statement-3
END-PERFORM
 
PERFORM UNTIL condition
    statement-1
    statement-2
END-PERFORM
 
PERFORM VARYING variable FROM start BY increment UNTIL condition
    statement-1
    statement-2
END-PERFORM
 
PERFORM TIMES
    statement-1
    statement-2
END-PERFORM

Inline PERFORM can be used with all PERFORM variations. The statements are executed directly without calling a separate paragraph.

Simple Inline PERFORM Example

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
IDENTIFICATION DIVISION.
PROGRAM-ID. INLINEPERFORM.
 
WORKING-STORAGE SECTION.
01  COUNTER           PIC 9(3) VALUE 0.
01  SUM               PIC 9(5) VALUE 0.
 
PROCEDURE DIVISION.
MAIN-PROCESS.
    DISPLAY "Starting inline PERFORM example"
    
    * Simple inline PERFORM
    PERFORM
        DISPLAY "Executing inline statements"
        ADD 1 TO COUNTER
        MOVE "Inline execution completed" TO OUTPUT-MESSAGE
    END-PERFORM
    
    DISPLAY "Counter: " COUNTER
    STOP RUN.

This example shows a simple inline PERFORM that executes statements directly.

Inline PERFORM with Conditions

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
WORKING-STORAGE SECTION.
01  COUNTER           PIC 9(3) VALUE 0.
01  MAX-COUNT         PIC 9(3) VALUE 5.
01  TOTAL             PIC 9(5) VALUE 0.
 
PROCEDURE DIVISION.
MAIN-PROCESS.
    DISPLAY "Inline PERFORM with UNTIL condition"
    
    * Inline PERFORM UNTIL
    PERFORM UNTIL COUNTER >= MAX-COUNT
        ADD 1 TO COUNTER
        ADD COUNTER TO TOTAL
        DISPLAY "Counter: " COUNTER " Total: " TOTAL
    END-PERFORM
    
    DISPLAY "Final total: " TOTAL
    STOP RUN.

This example shows inline PERFORM with a condition.

Inline PERFORM VARYING

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
WORKING-STORAGE SECTION.
01  INDEX-VAR         PIC 9(2) VALUE 0.
01  ARRAY-VALUES.
    05  VALUE-ENTRY   OCCURS 5 TIMES PIC 9(3).
 
PROCEDURE DIVISION.
MAIN-PROCESS.
    * Initialize array
    PERFORM VARYING INDEX-VAR FROM 1 BY 1 UNTIL INDEX-VAR > 5
        MOVE INDEX-VAR * 10 TO VALUE-ENTRY(INDEX-VAR)
    END-PERFORM
    
    * Display array values
    DISPLAY "Array values:"
    PERFORM VARYING INDEX-VAR FROM 1 BY 1 UNTIL INDEX-VAR > 5
        DISPLAY "Value[" INDEX-VAR "]: " VALUE-ENTRY(INDEX-VAR)
    END-PERFORM
    
    STOP RUN.

This example shows inline PERFORM VARYING for array initialization and display.

Practical Examples

These examples demonstrate real-world applications of PERFORM statements for common business scenarios.

Example 1: File Processing with PERFORM UNTIL

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
IDENTIFICATION DIVISION.
PROGRAM-ID. FILEPROCESS.
 
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
    SELECT TRANSACTION-FILE ASSIGN TO "TRANS.DAT"
        ORGANIZATION IS SEQUENTIAL
        ACCESS MODE IS SEQUENTIAL
        FILE STATUS IS FILE-STATUS.
 
DATA DIVISION.
FILE SECTION.
FD  TRANSACTION-FILE
    LABEL RECORDS ARE STANDARD
    RECORD CONTAINS 100 CHARACTERS.
01  TRANSACTION-RECORD.
    05  TRANS-ID         PIC 9(8).
    05  TRANS-AMOUNT     PIC 9(7)V99.
    05  TRANS-TYPE       PIC X.
        88  DEBIT         VALUE "D".
        88  CREDIT        VALUE "C".
    05  TRANS-DATE       PIC 9(8).
 
WORKING-STORAGE SECTION.
01  FILE-STATUS       PIC XX.
01  RECORD-COUNT      PIC 9(5) VALUE 0.
01  TOTAL-DEBITS      PIC 9(9)V99 VALUE 0.
01  TOTAL-CREDITS     PIC 9(9)V99 VALUE 0.
01  EOF-FLAG          PIC X VALUE "N".
    88  END-OF-FILE     VALUE "Y".
 
PROCEDURE DIVISION.
MAIN-PROCESS.
    PERFORM INITIALIZATION
    PERFORM PROCESS-TRANSACTIONS UNTIL END-OF-FILE
    PERFORM DISPLAY-SUMMARY
    STOP RUN.
 
INITIALIZATION.
    OPEN INPUT TRANSACTION-FILE
    IF FILE-STATUS NOT = "00"
        DISPLAY "Error opening file: " FILE-STATUS
        STOP RUN
    END-IF.
 
PROCESS-TRANSACTIONS.
    READ TRANSACTION-FILE
        AT END
            MOVE "Y" TO EOF-FLAG
        NOT AT END
            PERFORM PROCESS-TRANSACTION
    END-READ.
 
PROCESS-TRANSACTION.
    ADD 1 TO RECORD-COUNT
    IF DEBIT
        ADD TRANS-AMOUNT TO TOTAL-DEBITS
        DISPLAY "Debit transaction: " TRANS-ID " Amount: " TRANS-AMOUNT
    ELSE
        IF CREDIT
            ADD TRANS-AMOUNT TO TOTAL-CREDITS
            DISPLAY "Credit transaction: " TRANS-ID " Amount: " TRANS-AMOUNT
        END-IF
    END-IF.
 
DISPLAY-SUMMARY.
    CLOSE TRANSACTION-FILE
    DISPLAY "Processing Summary:"
    DISPLAY "  Total records: " RECORD-COUNT
    DISPLAY "  Total debits: " TOTAL-DEBITS
    DISPLAY "  Total credits: " TOTAL-CREDITS.

This example shows file processing using PERFORM UNTIL for end-of-file handling.

Example 2: Table Processing with PERFORM VARYING

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
IDENTIFICATION DIVISION.
PROGRAM-ID. TABLEPROCESS.
 
WORKING-STORAGE SECTION.
01  EMPLOYEE-TABLE.
    05  EMPLOYEE-ENTRY OCCURS 10 TIMES
        INDEXED BY EMP-INDEX.
        10  EMP-ID          PIC 9(5).
        10  EMP-NAME        PIC X(30).
        10  EMP-SALARY      PIC 9(6)V99.
        10  EMP-DEPARTMENT  PIC X(20).
 
01  TABLE-STATISTICS.
    05  TOTAL-EMPLOYEES    PIC 9(2) VALUE 0.
    05  TOTAL-SALARY       PIC 9(8)V99 VALUE 0.
    05  AVERAGE-SALARY     PIC 9(6)V99 VALUE 0.
    05  HIGHEST-SALARY     PIC 9(6)V99 VALUE 0.
    05  LOWEST-SALARY      PIC 9(6)V99 VALUE 999999.99.
 
PROCEDURE DIVISION.
MAIN-PROCESS.
    PERFORM INITIALIZE-EMPLOYEES
    PERFORM CALCULATE-STATISTICS
    PERFORM DISPLAY-STATISTICS
    STOP RUN.
 
INITIALIZE-EMPLOYEES.
    MOVE 10001 TO EMP-ID(1)
    MOVE "JOHN SMITH" TO EMP-NAME(1)
    MOVE 45000.00 TO EMP-SALARY(1)
    MOVE "IT" TO EMP-DEPARTMENT(1)
    
    MOVE 10002 TO EMP-ID(2)
    MOVE "JANE DOE" TO EMP-NAME(2)
    MOVE 52000.00 TO EMP-SALARY(2)
    MOVE "HR" TO EMP-DEPARTMENT(2)
    
    MOVE 10003 TO EMP-ID(3)
    MOVE "BOB JOHNSON" TO EMP-NAME(3)
    MOVE 38000.00 TO EMP-SALARY(3)
    MOVE "SALES" TO EMP-DEPARTMENT(3)
    
    MOVE 3 TO TOTAL-EMPLOYEES.
 
CALCULATE-STATISTICS.
    PERFORM VARYING EMP-INDEX FROM 1 BY 1 
        UNTIL EMP-INDEX > TOTAL-EMPLOYEES
        PERFORM PROCESS-EMPLOYEE
    END-PERFORM
    
    IF TOTAL-EMPLOYEES > 0
        COMPUTE AVERAGE-SALARY = TOTAL-SALARY / TOTAL-EMPLOYEES
    END-IF.
 
PROCESS-EMPLOYEE.
    ADD EMP-SALARY(EMP-INDEX) TO TOTAL-SALARY
    
    IF EMP-SALARY(EMP-INDEX) > HIGHEST-SALARY
        MOVE EMP-SALARY(EMP-INDEX) TO HIGHEST-SALARY
    END-IF
    
    IF EMP-SALARY(EMP-INDEX) < LOWEST-SALARY
        MOVE EMP-SALARY(EMP-INDEX) TO LOWEST-SALARY
    END-IF.
 
DISPLAY-STATISTICS.
    DISPLAY "Employee Statistics:"
    DISPLAY "  Total employees: " TOTAL-EMPLOYEES
    DISPLAY "  Total salary: " TOTAL-SALARY
    DISPLAY "  Average salary: " AVERAGE-SALARY
    DISPLAY "  Highest salary: " HIGHEST-SALARY
    DISPLAY "  Lowest salary: " LOWEST-SALARY.

This example shows table processing using PERFORM VARYING for employee statistics.

Example 3: Menu-Driven Program

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
IDENTIFICATION DIVISION.
PROGRAM-ID. MENUPROGRAM.
 
WORKING-STORAGE SECTION.
01  MENU-CHOICE       PIC 9.
01  CONTINUE-FLAG     PIC X VALUE "Y".
    88  CONTINUE-PROGRAM VALUE "Y".
    88  EXIT-PROGRAM     VALUE "N".
 
PROCEDURE DIVISION.
MAIN-PROCESS.
    PERFORM DISPLAY-MENU
    PERFORM PROCESS-MENU UNTIL EXIT-PROGRAM
    PERFORM FINALIZATION
    STOP RUN.
 
DISPLAY-MENU.
    DISPLAY "=== MENU ==="
    DISPLAY "1. Add Record"
    DISPLAY "2. Delete Record"
    DISPLAY "3. Update Record"
    DISPLAY "4. Display Records"
    DISPLAY "5. Exit"
    DISPLAY "Enter your choice (1-5): ".
 
PROCESS-MENU.
    ACCEPT MENU-CHOICE
    
    EVALUATE MENU-CHOICE
        WHEN 1
            PERFORM ADD-RECORD
        WHEN 2
            PERFORM DELETE-RECORD
        WHEN 3
            PERFORM UPDATE-RECORD
        WHEN 4
            PERFORM DISPLAY-RECORDS
        WHEN 5
            MOVE "N" TO CONTINUE-FLAG
        WHEN OTHER
            DISPLAY "Invalid choice. Please try again."
    END-EVALUATE
    
    IF CONTINUE-PROGRAM
        PERFORM DISPLAY-MENU
    END-IF.
 
ADD-RECORD.
    DISPLAY "Adding record...".
 
DELETE-RECORD.
    DISPLAY "Deleting record...".
 
UPDATE-RECORD.
    DISPLAY "Updating record...".
 
DISPLAY-RECORDS.
    DISPLAY "Displaying records...".
 
FINALIZATION.
    DISPLAY "Program terminated.".

This example shows a menu-driven program using PERFORM UNTIL for program control.

Best Practices and Tips

Following these best practices ensures efficient and maintainable use of PERFORM statements in COBOL programs.

PERFORM Statement Best Practices

Use meaningful paragraph names that clearly describe what the paragraph does
Keep paragraphs focused on a single responsibility
Use PERFORM UNTIL for file processing and other termination conditions
Use PERFORM VARYING for table processing instead of manual index manipulation
Use PERFORM TIMES when you know the exact number of iterations needed
Use PERFORM WHILE for condition-based loops that continue while true
Use inline PERFORM sparingly and only for simple operations
Ensure PERFORM UNTIL loops have clear termination conditions to avoid infinite loops
Document complex PERFORM logic with comments
Avoid deeply nested PERFORM statements that can make code hard to follow

Performance Considerations

PERFORM VARYING is more efficient than manual index manipulation for table access
Inline PERFORM can be faster for simple operations by avoiding paragraph calls
PERFORM UNTIL with complex conditions may impact performance - simplify when possible
Use appropriate loop types for the specific use case
Consider the overhead of paragraph calls vs inline execution
Profile performance-critical sections to identify bottlenecks

Common Pitfalls to Avoid

Infinite loops from unclear termination conditions in PERFORM UNTIL
Using wrong loop type for the specific use case
Not initializing variables used in PERFORM conditions
Complex inline PERFORM blocks that should be separate paragraphs
Nested PERFORM statements that are too deep and hard to follow
Not handling edge cases in PERFORM conditions
Using PERFORM when simple sequential execution would be clearer
Not documenting complex PERFORM logic for maintenance

When to Use Each PERFORM Type

PERFORM Type	Best Use Case	Example
Simple	One-time operations, modular code	PERFORM INITIALIZATION
TIMES	Fixed number of iterations	PERFORM PROCESS-RECORD 10 TIMES
UNTIL	File processing, end conditions	PERFORM READ-FILE UNTIL END-OF-FILE
VARYING	Table processing, indexed loops	PERFORM VARYING INDEX FROM 1 BY 1 UNTIL INDEX > SIZE
WHILE	Condition-based processing	PERFORM PROCESS WHILE VALID-DATA
Inline	Simple operations, one-time logic	PERFORM DISPLAY "Hello" END-PERFORM

Test Your Knowledge

1. What is the primary purpose of the PERFORM statement in COBOL?

To perform arithmetic calculations
To execute paragraphs or sections and control program flow
To read data from files
To display output to the screen

2. Which PERFORM statement executes a paragraph or section only once?

PERFORM UNTIL
PERFORM VARYING
Simple PERFORM
PERFORM TIMES

3. What does PERFORM UNTIL do?

Executes a paragraph until a condition becomes true
Executes a paragraph a specific number of times
Executes a paragraph while a condition is true
Execforms a paragraph once and stops

4. How do you execute a paragraph a specific number of times?

PERFORM paragraph-name UNTIL condition
PERFORM paragraph-name TIMES
PERFORM paragraph-name VARYING variable
PERFORM paragraph-name WHILE condition

5. What is an inline PERFORM?

A PERFORM that calls another program
A PERFORM that executes statements directly without calling a paragraph
A PERFORM that uses a pointer
A PERFORM that accesses files

COBOL Tutorial

COBOL PERFORM Statement

PERFORM Statement Overview

What PERFORM Can Do

PERFORM Statement Types

Simple PERFORM

Basic Syntax

Simple PERFORM Example

PERFORM THRU Example

PERFORM TIMES

Basic Syntax

PERFORM TIMES Example

PERFORM UNTIL

Basic Syntax

File Processing Example

Counter-Based Example

PERFORM VARYING

Basic Syntax

Table Processing Example

Nested Loops Example

PERFORM WHILE

Basic Syntax

PERFORM WHILE Example

UNTIL vs WHILE Comparison

Inline PERFORM

Basic Syntax

Simple Inline PERFORM Example

Inline PERFORM with Conditions

Inline PERFORM VARYING

Practical Examples

Example 1: File Processing with PERFORM UNTIL

Example 2: Table Processing with PERFORM VARYING

Example 3: Menu-Driven Program

Best Practices and Tips

PERFORM Statement Best Practices

Performance Considerations

Common Pitfalls to Avoid

When to Use Each PERFORM Type

Test Your Knowledge

Frequently Asked Questions

What are the different types of PERFORM statements in COBOL?

What is the difference between PERFORM UNTIL and PERFORM WHILE?

How do I use PERFORM VARYING for table processing?

What are the advantages of using inline PERFORM?

What are some best practices for using PERFORM statements?

Related Concepts

Program Structure

Table Handling

File Operations

Conditional Execution

Program Flow Control

Related Pages