MainframeMaster

COBOL Tutorial

COBOL END-INVOKE Clause - Quick Reference

Progress0 of 0 lessons

Overview

The END-INVOKE clause marks the end of an INVOKE statement block. It is a required terminator that ensures proper structure for object-oriented method calls and exception handling in COBOL programs.

Purpose and Usage

  • Block termination - End INVOKE statement blocks
  • Exception handling - Terminate exception handling blocks
  • Object-oriented support - Support object method calls
  • Compilation requirement - Required for successful compilation
  • Nesting support - Enable nested INVOKE statements

INVOKE Block Structure

INVOKE object "method" USING parameters
ON EXCEPTION
exception-handling...
NOT ON EXCEPTION
success-handling...
END-INVOKE ← Terminator
Object method call with exception handling

END-INVOKE marks the end of the INVOKE block structure.

Syntax

The END-INVOKE clause follows specific syntax patterns and is required to properly terminate INVOKE statement blocks.

Basic Syntax

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
* Basic END-INVOKE syntax
INVOKE object "method" USING parameters
    ON EXCEPTION
        exception-handling...
    NOT ON EXCEPTION
        success-handling...
END-INVOKE
 
* Simple example
INVOKE WS-OBJECT "GET-VALUE" USING WS-PARAMETER
    ON EXCEPTION
        DISPLAY "Method call failed"
    NOT ON EXCEPTION
        DISPLAY "Method call successful"
END-INVOKE
 
* With multiple parameters
INVOKE WS-OBJECT "PROCESS-DATA" 
    USING WS-PARAM1 WS-PARAM2 WS-RESULT
    ON EXCEPTION
        MOVE "ERROR" TO WS-STATUS
    NOT ON EXCEPTION
        MOVE "SUCCESS" TO WS-STATUS
END-INVOKE

END-INVOKE is required to terminate every INVOKE statement block.

INVOKE vs CALL Structure

FeatureINVOKECALL
UsageObject method callsSubprogram calls
Exception handlingBuilt-in ON EXCEPTIONManual error checking
TerminationEND-INVOKE requiredNo special termination
Object-orientedYesNo
Modern COBOLPreferredTraditional

Exception Handling Structure

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
* Exception handling with INVOKE
INVOKE WS-OBJECT "METHOD-NAME" USING WS-PARAM
    ON EXCEPTION
        * Handle exception
        DISPLAY "Exception occurred"
        MOVE "ERROR" TO WS-STATUS
    NOT ON EXCEPTION
        * Handle success
        DISPLAY "Method executed successfully"
        MOVE "SUCCESS" TO WS-STATUS
END-INVOKE
 
* Multiple exception types
INVOKE WS-OBJECT "COMPLEX-METHOD" USING WS-DATA
    ON EXCEPTION
        EVALUATE WS-EXCEPTION-TYPE
            WHEN "INVALID-PARAMETER"
                DISPLAY "Invalid parameter"
            WHEN "OBJECT-NOT-FOUND"
                DISPLAY "Object not found"
            WHEN OTHER
                DISPLAY "Unknown exception"
        END-EVALUATE
    NOT ON EXCEPTION
        DISPLAY "Method completed successfully"
END-INVOKE

INVOKE provides built-in exception handling with ON EXCEPTION and NOT ON EXCEPTION clauses.

Practical Examples

These examples demonstrate how to use the END-INVOKE clause effectively in different object-oriented scenarios.

Basic Object Method Call

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
IDENTIFICATION DIVISION.
PROGRAM-ID. BASIC-INVOKE-EXAMPLE.
 
DATA DIVISION.
WORKING-STORAGE SECTION.
01  WS-OBJECT         OBJECT REFERENCE.
01  WS-PARAMETER      PIC X(20).
01  WS-RESULT         PIC X(50).
01  WS-STATUS         PIC X(10).
 
PROCEDURE DIVISION.
MAIN-PROCESS.
    * Set up parameter
    MOVE "Test Parameter" TO WS-PARAMETER
    
    * Invoke object method with proper END-INVOKE
    INVOKE WS-OBJECT "PROCESS-DATA" USING WS-PARAMETER
        ON EXCEPTION
            MOVE "ERROR" TO WS-STATUS
            DISPLAY "Method call failed"
        NOT ON EXCEPTION
            MOVE "SUCCESS" TO WS-STATUS
            DISPLAY "Method call successful"
    END-INVOKE
    
    * Check status and continue
    IF WS-STATUS = "SUCCESS"
        DISPLAY "Processing completed successfully"
    ELSE
        DISPLAY "Processing failed"
    END-IF
    
    STOP RUN.

Basic object method call with proper END-INVOKE termination and exception handling.

Factory Object Usage

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
IDENTIFICATION DIVISION.
PROGRAM-ID. FACTORY-INVOKE-EXAMPLE.
 
DATA DIVISION.
WORKING-STORAGE SECTION.
01  WS-FACTORY        OBJECT REFERENCE.
01  WS-NEW-OBJECT     OBJECT REFERENCE.
01  WS-OBJECT-TYPE    PIC X(20).
01  WS-CREATION-STATUS PIC X(10).
 
PROCEDURE DIVISION.
MAIN-PROCESS.
    * Set object type
    MOVE "CUSTOMER" TO WS-OBJECT-TYPE
    
    * Create object using factory
    INVOKE WS-FACTORY "CREATE-OBJECT" 
        USING WS-OBJECT-TYPE
        RETURNING WS-NEW-OBJECT
        ON EXCEPTION
            MOVE "ERROR" TO WS-CREATION-STATUS
            DISPLAY "Failed to create object"
        NOT ON EXCEPTION
            MOVE "SUCCESS" TO WS-CREATION-STATUS
            DISPLAY "Object created successfully"
    END-INVOKE
    
    * Use the created object if successful
    IF WS-CREATION-STATUS = "SUCCESS"
        INVOKE WS-NEW-OBJECT "INITIALIZE" USING WS-OBJECT-TYPE
            ON EXCEPTION
                DISPLAY "Failed to initialize object"
            NOT ON EXCEPTION
                DISPLAY "Object initialized successfully"
        END-INVOKE
    END-IF
    
    STOP RUN.

Factory object usage with nested INVOKE statements and proper END-INVOKE termination.

Complex Exception Handling

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
IDENTIFICATION DIVISION.
PROGRAM-ID. COMPLEX-EXCEPTION-INVOKE.
 
DATA DIVISION.
WORKING-STORAGE SECTION.
01  WS-DATABASE-OBJECT OBJECT REFERENCE.
01  WS-QUERY-PARAM    PIC X(100).
01  WS-RESULT-SET     PIC X(500).
01  WS-EXCEPTION-TYPE PIC X(20).
01  WS-ERROR-COUNT    PIC 9(3) VALUE 0.
 
PROCEDURE DIVISION.
MAIN-PROCESS.
    * Set up query parameter
    MOVE "SELECT * FROM CUSTOMERS WHERE STATUS = 'ACTIVE'" TO WS-QUERY-PARAM
    
    * Execute database query with complex exception handling
    INVOKE WS-DATABASE-OBJECT "EXECUTE-QUERY" 
        USING WS-QUERY-PARAM
        RETURNING WS-RESULT-SET
        ON EXCEPTION
            ADD 1 TO WS-ERROR-COUNT
            MOVE "DATABASE-ERROR" TO WS-EXCEPTION-TYPE
            
            * Handle different types of database errors
            EVALUATE WS-EXCEPTION-TYPE
                WHEN "CONNECTION-ERROR"
                    DISPLAY "Database connection failed"
                    PERFORM RECONNECT-DATABASE
                WHEN "QUERY-ERROR"
                    DISPLAY "Query syntax error"
                    PERFORM VALIDATE-QUERY
                WHEN "PERMISSION-ERROR"
                    DISPLAY "Insufficient permissions"
                    PERFORM REQUEST-PERMISSIONS
                WHEN OTHER
                    DISPLAY "Unknown database error"
                    PERFORM LOG-ERROR
            END-EVALUATE
        NOT ON EXCEPTION
            DISPLAY "Query executed successfully"
            PERFORM PROCESS-RESULTS
    END-INVOKE
    
    * Check if we need to retry
    IF WS-ERROR-COUNT > 0 AND WS-ERROR-COUNT < 3
        DISPLAY "Retrying operation..."
        GO TO MAIN-PROCESS
    END-IF
    
    STOP RUN.
 
RECONNECT-DATABASE.
    DISPLAY "Attempting to reconnect...".
 
VALIDATE-QUERY.
    DISPLAY "Validating query syntax...".
 
REQUEST-PERMISSIONS.
    DISPLAY "Requesting additional permissions...".
 
LOG-ERROR.
    DISPLAY "Logging error for analysis...".
 
PROCESS-RESULTS.
    DISPLAY "Processing query results...".

Complex exception handling with multiple exception types and proper END-INVOKE termination.

Nested INVOKE Statements

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
IDENTIFICATION DIVISION.
PROGRAM-ID. NESTED-INVOKE-EXAMPLE.
 
DATA DIVISION.
WORKING-STORAGE SECTION.
01  WS-SERVICE-OBJECT OBJECT REFERENCE.
01  WS-DATA-OBJECT    OBJECT REFERENCE.
01  WS-INPUT-DATA     PIC X(200).
01  WS-PROCESSED-DATA PIC X(200).
01  WS-FINAL-RESULT   PIC X(100).
 
PROCEDURE DIVISION.
MAIN-PROCESS.
    * Set up input data
    MOVE "Sample input data for processing" TO WS-INPUT-DATA
    
    * First INVOKE - Get data object
    INVOKE WS-SERVICE-OBJECT "GET-DATA-OBJECT" 
        USING WS-INPUT-DATA
        RETURNING WS-DATA-OBJECT
        ON EXCEPTION
            DISPLAY "Failed to get data object"
            STOP RUN
        NOT ON EXCEPTION
            DISPLAY "Data object retrieved successfully"
            
            * Nested INVOKE - Process data
            INVOKE WS-DATA-OBJECT "PROCESS-DATA" 
                USING WS-INPUT-DATA
                RETURNING WS-PROCESSED-DATA
                ON EXCEPTION
                    DISPLAY "Failed to process data"
                NOT ON EXCEPTION
                    DISPLAY "Data processed successfully"
                    
                    * Third level INVOKE - Generate result
                    INVOKE WS-DATA-OBJECT "GENERATE-RESULT" 
                        USING WS-PROCESSED-DATA
                        RETURNING WS-FINAL-RESULT
                        ON EXCEPTION
                            DISPLAY "Failed to generate result"
                        NOT ON EXCEPTION
                            DISPLAY "Result generated: " WS-FINAL-RESULT
                    END-INVOKE  * Third level
            END-INVOKE  * Second level
    END-INVOKE  * First level
    
    STOP RUN.

Nested INVOKE statements with proper END-INVOKE termination at each level.

Best Practices and Considerations

Understanding best practices ensures proper INVOKE block structure and exception handling.

END-INVOKE Best Practices

  • Always include END-INVOKE - Required for every INVOKE block
  • Use proper indentation - Makes nested structures clear
  • Handle exceptions properly - Always include ON EXCEPTION handling
  • Add comments for clarity - Mark which END-INVOKE belongs to which INVOKE
  • Test exception paths - Ensure all exception scenarios are handled

Common Pitfalls to Avoid

PitfallProblemSolution
Missing END-INVOKECompilation errorAlways include END-INVOKE
Missing exception handlingUnhandled exceptionsInclude ON EXCEPTION clause
Mismatched nestingLogic errorsUse proper indentation and comments
Wrong object referenceRuntime errorsValidate object references
Complex nestingHard to maintainLimit nesting depth

Exception Handling Guidelines

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
* Good exception handling structure
INVOKE WS-OBJECT "METHOD-NAME" USING WS-PARAM
    ON EXCEPTION
        * Log the exception
        PERFORM LOG-EXCEPTION
        
        * Take appropriate action
        EVALUATE WS-EXCEPTION-TYPE
            WHEN "RECOVERABLE"
                PERFORM RETRY-OPERATION
            WHEN "FATAL"
                PERFORM TERMINATE-PROCESS
        END-EVALUATE
    NOT ON EXCEPTION
        * Handle success
        PERFORM PROCESS-SUCCESS
END-INVOKE
 
* Avoid empty exception handlers
INVOKE WS-OBJECT "METHOD-NAME" USING WS-PARAM
    ON EXCEPTION
        * Don't leave empty - always handle exceptions
        DISPLAY "Exception occurred: " WS-EXCEPTION-MESSAGE
    NOT ON EXCEPTION
        DISPLAY "Operation successful"
END-INVOKE

Proper exception handling ensures robust object-oriented COBOL programs.

END-INVOKE Clause Quick Reference

UsageSyntaxExample
Basic terminationINVOKE...END-INVOKEINVOKE obj "method"...END-INVOKE
With exception handlingINVOKE...ON EXCEPTION...END-INVOKEINVOKE obj "method"...ON EXCEPTION...END-INVOKE
With success handlingINVOKE...NOT ON EXCEPTION...END-INVOKEINVOKE obj "method"...NOT ON EXCEPTION...END-INVOKE
Nested structureINVOKE...INVOKE...END-INVOKE...END-INVOKEINVOKE obj1...INVOKE obj2...END-INVOKE...END-INVOKE
With commentsEND-INVOKE * CommentEND-INVOKE * Method call termination

Test Your Knowledge

1. What is the primary purpose of the END-INVOKE clause in COBOL?

  • To start an INVOKE statement
  • To terminate an INVOKE statement block
  • To invoke methods
  • To define objects

2. Which statement does END-INVOKE terminate?

  • CALL statement
  • INVOKE statement
  • PERFORM statement
  • WRITE statement

3. What happens if you forget to include END-INVOKE?

  • The program crashes
  • Compilation error occurs
  • The INVOKE block continues indefinitely
  • Nothing happens

4. What is typically used with INVOKE statements?

  • File operations
  • Object method calls and exception handling
  • Arithmetic operations
  • String manipulation

5. Can you nest INVOKE statements?

  • No, never
  • Yes, but only two levels deep
  • Yes, with proper END-INVOKE termination
  • Only in certain COBOL versions

Frequently Asked Questions

Related Concepts

INVOKE Statement

INVOKE statement for object method calls.

Object-Oriented COBOL

Object-oriented programming in COBOL.

Exception Handling

Exception handling techniques in COBOL.

CALL Statement

CALL statement for traditional subprogram calls.

Program Structure

Program structure and organization in COBOL.

END-EVALUATEENVIRONMENT DIVISION