MainframeMaster

COBOL Tutorial

COBOL END-CALL Statement

The END-CALL statement represents a fundamental component of structured modular programming in COBOL, serving as an explicit scope terminator that clearly defines the boundaries of CALL statement blocks. This statement embodies modern programming principles by providing unambiguous termination points for subprogram invocation operations, enabling sophisticated error handling for call failures and resource management, and supporting the development of robust, maintainable enterprise applications that leverage modular architecture patterns for code reusability and system scalability.

In contemporary enterprise COBOL development, END-CALL plays a vital role in creating sophisticated modular applications that must handle complex subprogram interactions, parameter passing scenarios, and error conditions that may arise during program execution. By providing explicit termination for CALL blocks, this statement enables developers to implement comprehensive modular programming logic while maintaining code clarity and ensuring that subprogram invocations are properly bounded and controlled within the application's execution flow.

Understanding END-CALL Architecture

The END-CALL statement implements a sophisticated scope management system specifically designed for subprogram invocation operations. This architecture addresses the complexity inherent in modern modular programming scenarios where CALL statements must manage parameter passing, return value handling, exception conditions, and resource cleanup operations. The explicit termination provided by END-CALL ensures that all these operations are properly contained within defined boundaries.

The architectural design of END-CALL reflects the evolution of COBOL toward structured programming paradigms that emphasize modularity, reusability, and error prevention in subprogram interactions. When used with conditional phrases like ON EXCEPTION and ON OVERFLOW, END-CALL creates a comprehensive framework for handling both successful subprogram calls and error conditions that may arise during program execution or resource allocation.

END-CALL also plays a crucial role in compiler optimization and call stack management. Modern COBOL compilers can perform more sophisticated analysis when subprogram call blocks are explicitly terminated, leading to better error detection during compilation, more efficient runtime code generation, and improved memory management. This capability is particularly important in enterprise environments where performance and resource utilization are critical requirements.

Key END-CALL Capabilities:

  • Explicit Scope Termination: Provides clear boundaries for CALL statement blocks, eliminating ambiguity in nested subprogram invocation structures.
  • Exception Handling Support: Works with ON EXCEPTION and ON OVERFLOW phrases to create comprehensive error handling frameworks for subprogram calls.
  • Parameter Management: Enables proper handling of parameter passing and return value processing within explicitly defined call scopes.
  • Resource Cleanup: Supports sophisticated resource management by clearly defining the scope of subprogram invocation operations.
  • Code Readability Enhancement: Improves code structure and readability by providing explicit termination points for modular operations.
  • Call Stack Optimization: Enables better compiler analysis and optimization by providing clear block boundaries for subprogram invocations.

Modular Programming Patterns

END-CALL enables the implementation of sophisticated modular programming patterns that are essential for modern enterprise applications. These patterns include service-oriented architectures with comprehensive error handling, batch processing with modular components and failure recovery, and complex multi-tier applications that require precise control over subprogram interactions and resource management.

The use of END-CALL in conjunction with conditional phrases creates powerful modular processing frameworks that can handle various call failure conditions, parameter validation scenarios, and resource allocation issues while maintaining application stability and providing meaningful feedback about subprogram execution results. This capability is particularly valuable in applications that must integrate multiple subsystems or external services.

Modern enterprise applications often implement layered modular architectures where END-CALL statements work in conjunction with service frameworks, parameter validation systems, and error handling engines to create comprehensive modular solutions that meet the complex requirements of contemporary business systems while maintaining code reusability and system maintainability.

END-CALL Syntax and Implementation

Basic END-CALL Usage

The basic implementation of END-CALL follows a consistent pattern where it serves as the explicit terminator for CALL statement blocks. This pattern is particularly important when CALL statements include conditional processing or when they are nested within other constructs.

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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
IDENTIFICATION DIVISION.
PROGRAM-ID. END-CALL-BASIC.
 
DATA DIVISION.
WORKING-STORAGE SECTION.
01  EMPLOYEE-PROCESSING.
    05  EMPLOYEE-ID             PIC X(10).
    05  EMPLOYEE-NAME           PIC X(30).
    05  EMPLOYEE-SALARY         PIC 9(7)V99.
    05  EMPLOYEE-DEPARTMENT     PIC X(10).
 
01  CALCULATION-RESULTS.
    05  GROSS-PAY               PIC 9(9)V99.
    05  NET-PAY                 PIC 9(9)V99.
    05  TAX-AMOUNT              PIC 9(7)V99.
    05  DEDUCTION-AMOUNT        PIC 9(7)V99.
 
01  CALL-STATUS-FLAGS.
    05  CALL-SUCCESSFUL-FLAG    PIC X VALUE 'N'.
        88  CALL-SUCCESSFUL     VALUE 'Y'.
        88  CALL-FAILED         VALUE 'N'.
    05  VALIDATION-FLAG         PIC X VALUE 'N'.
        88  VALIDATION-PASSED   VALUE 'Y'.
        88  VALIDATION-FAILED   VALUE 'N'.
 
01  ERROR-HANDLING.
    05  ERROR-MESSAGE           PIC X(80).
    05  ERROR-CODE              PIC 9(4).
    05  RETRY-COUNT             PIC 9(2) VALUE 0.
    05  MAX-RETRIES             PIC 9(2) VALUE 3.
 
01  SUBPROGRAM-PARAMETERS.
    05  CALC-EMPLOYEE-ID        PIC X(10).
    05  CALC-SALARY             PIC 9(7)V99.
    05  CALC-GROSS-PAY          PIC 9(9)V99.
    05  CALC-NET-PAY            PIC 9(9)V99.
    05  CALC-RETURN-CODE        PIC 9(2).
 
PROCEDURE DIVISION.
MAIN-PROCESSING.
    PERFORM INITIALIZE-PROGRAM
    PERFORM PROCESS-EMPLOYEE-PAYROLL
    PERFORM DISPLAY-RESULTS
    STOP RUN.
 
INITIALIZE-PROGRAM.
    MOVE 'EMP001' TO EMPLOYEE-ID
    MOVE 'JOHN SMITH' TO EMPLOYEE-NAME
    MOVE 5000.00 TO EMPLOYEE-SALARY
    MOVE 'FINANCE' TO EMPLOYEE-DEPARTMENT
    MOVE 'N' TO CALL-SUCCESSFUL-FLAG
    MOVE 'N' TO VALIDATION-FLAG
    MOVE SPACES TO ERROR-MESSAGE
    MOVE 0 TO ERROR-CODE, RETRY-COUNT.
 
PROCESS-EMPLOYEE-PAYROLL.
    PERFORM VALIDATE-EMPLOYEE-DATA
    IF VALIDATION-PASSED
        PERFORM CALCULATE-PAYROLL
        PERFORM VALIDATE-CALCULATIONS
    ELSE
        DISPLAY 'Employee data validation failed'
    END-IF.
 
VALIDATE-EMPLOYEE-DATA.
    *> Call validation subprogram with error handling
    MOVE EMPLOYEE-ID TO CALC-EMPLOYEE-ID
    MOVE EMPLOYEE-SALARY TO CALC-SALARY
    
    CALL 'VALIDATE-EMPLOYEE'
        USING CALC-EMPLOYEE-ID, CALC-SALARY, CALC-RETURN-CODE
    ON EXCEPTION
        MOVE 'Error calling validation subprogram' TO ERROR-MESSAGE
        MOVE 1001 TO ERROR-CODE
        SET CALL-FAILED TO TRUE
        DISPLAY ERROR-MESSAGE
    NOT ON EXCEPTION
        IF CALC-RETURN-CODE = 0
            SET VALIDATION-PASSED TO TRUE
            SET CALL-SUCCESSFUL TO TRUE
            DISPLAY 'Employee validation successful'
        ELSE
            SET VALIDATION-FAILED TO TRUE
            DISPLAY 'Employee validation failed with code: ' CALC-RETURN-CODE
        END-IF
    END-CALL.
 
CALCULATE-PAYROLL.
    *> Call payroll calculation subprogram
    MOVE EMPLOYEE-ID TO CALC-EMPLOYEE-ID
    MOVE EMPLOYEE-SALARY TO CALC-SALARY
    
    CALL 'CALCULATE-PAYROLL'
        USING CALC-EMPLOYEE-ID, CALC-SALARY, CALC-GROSS-PAY, 
              CALC-NET-PAY, CALC-RETURN-CODE
    ON EXCEPTION
        MOVE 'Error calling payroll calculation subprogram' TO ERROR-MESSAGE
        MOVE 1002 TO ERROR-CODE
        SET CALL-FAILED TO TRUE
        DISPLAY ERROR-MESSAGE
    NOT ON EXCEPTION
        IF CALC-RETURN-CODE = 0
            MOVE CALC-GROSS-PAY TO GROSS-PAY
            MOVE CALC-NET-PAY TO NET-PAY
            SET CALL-SUCCESSFUL TO TRUE
            DISPLAY 'Payroll calculation successful'
        ELSE
            DISPLAY 'Payroll calculation failed with code: ' CALC-RETURN-CODE
        END-IF
    END-CALL.
 
VALIDATE-CALCULATIONS.
    *> Call calculation validation subprogram
    CALL 'VALIDATE-CALCULATIONS'
        USING GROSS-PAY, NET-PAY, CALC-RETURN-CODE
    ON EXCEPTION
        MOVE 'Error calling calculation validation subprogram' TO ERROR-MESSAGE
        MOVE 1003 TO ERROR-CODE
        SET CALL-FAILED TO TRUE
        DISPLAY ERROR-MESSAGE
    NOT ON EXCEPTION
        IF CALC-RETURN-CODE = 0
            DISPLAY 'Calculation validation successful'
        ELSE
            DISPLAY 'Calculation validation failed with code: ' CALC-RETURN-CODE
        END-IF
    END-CALL.
 
DISPLAY-RESULTS.
    IF CALL-SUCCESSFUL AND VALIDATION-PASSED
        DISPLAY 'Employee Processing Results:'
        DISPLAY 'Employee ID: ' EMPLOYEE-ID
        DISPLAY 'Employee Name: ' EMPLOYEE-NAME
        DISPLAY 'Base Salary: ' EMPLOYEE-SALARY
        DISPLAY 'Gross Pay: ' GROSS-PAY
        DISPLAY 'Net Pay: ' NET-PAY
    ELSE
        DISPLAY 'Processing failed - Error: ' ERROR-MESSAGE
        DISPLAY 'Error Code: ' ERROR-CODE
    END-IF.

Advanced END-CALL Patterns

Advanced END-CALL patterns involve complex nested structures, sophisticated error handling, and integration with other COBOL constructs to create comprehensive modular processing solutions.

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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
IDENTIFICATION DIVISION.
PROGRAM-ID. ADVANCED-END-CALL.
 
DATA DIVISION.
WORKING-STORAGE SECTION.
01  TRANSACTION-PROCESSING.
    05  TRANSACTION-ID          PIC X(15).
    05  TRANSACTION-TYPE        PIC X(10).
    05  TRANSACTION-AMOUNT      PIC 9(11)V99.
    05  ACCOUNT-NUMBER          PIC X(20).
    05  CUSTOMER-ID             PIC X(15).
 
01  PROCESSING-CONTROLS.
    05  TRANSACTION-COUNT       PIC 9(7).
    05  CURRENT-TRANSACTION     PIC 9(7).
    05  SUCCESSFUL-COUNT        PIC 9(7).
    05  ERROR-COUNT             PIC 9(7).
 
01  CALL-MANAGEMENT.
    05  ACTIVE-CALLS            PIC 9(3).
    05  MAX-CONCURRENT-CALLS    PIC 9(3) VALUE 10.
    05  CALL-TIMEOUT            PIC 9(5) VALUE 30.
    05  RETRY-ATTEMPTS          PIC 9(2).
    05  MAX-RETRY-ATTEMPTS      PIC 9(2) VALUE 3.
 
01  SUBPROGRAM-INTERFACES.
    05  VALIDATION-INTERFACE.
        10  VAL-TRANSACTION-ID   PIC X(15).
        10  VAL-ACCOUNT-NUMBER   PIC X(20).
        10  VAL-CUSTOMER-ID      PIC X(15).
        10  VAL-RETURN-CODE      PIC 9(2).
        10  VAL-ERROR-MESSAGE    PIC X(80).
    
    05  PROCESSING-INTERFACE.
        10  PROC-TRANSACTION-ID  PIC X(15).
        10  PROC-TRANSACTION-TYPE PIC X(10).
        10  PROC-AMOUNT          PIC 9(11)V99.
        10  PROC-ACCOUNT-NUMBER  PIC X(20).
        10  PROC-RETURN-CODE     PIC 9(2).
        10  PROC-ERROR-MESSAGE   PIC X(80).
    
    05  AUDIT-INTERFACE.
        10  AUDIT-TRANSACTION-ID PIC X(15).
        10  AUDIT-USER-ID        PIC X(10).
        10  AUDIT-TIMESTAMP      PIC X(26).
        10  AUDIT-ACTION         PIC X(20).
        10  AUDIT-RETURN-CODE    PIC 9(2).
 
01  ERROR-MANAGEMENT.
    05  CRITICAL-ERROR-FLAG     PIC X VALUE 'N'.
        88  CRITICAL-ERROR      VALUE 'Y'.
    05  RECOVERABLE-ERROR-FLAG  PIC X VALUE 'N'.
        88  RECOVERABLE-ERROR   VALUE 'Y'.
    05  SYSTEM-ERROR-FLAG       PIC X VALUE 'N'.
        88  SYSTEM-ERROR        VALUE 'Y'.
 
PROCEDURE DIVISION.
MAIN-PROCESSING.
    PERFORM INITIALIZE-TRANSACTION-SYSTEM
    PERFORM PROCESS-TRANSACTION-BATCH
    PERFORM FINALIZE-TRANSACTION-SYSTEM
    STOP RUN.
 
INITIALIZE-TRANSACTION-SYSTEM.
    MOVE 1000 TO TRANSACTION-COUNT
    MOVE 0 TO CURRENT-TRANSACTION, SUCCESSFUL-COUNT, ERROR-COUNT
    MOVE 0 TO ACTIVE-CALLS, RETRY-ATTEMPTS
    MOVE 'N' TO CRITICAL-ERROR-FLAG, RECOVERABLE-ERROR-FLAG, SYSTEM-ERROR-FLAG
    
    *> Initialize system components
    CALL 'INIT-TRANSACTION-SYSTEM'
        USING TRANSACTION-COUNT, MAX-CONCURRENT-CALLS, CALL-TIMEOUT
    ON EXCEPTION
        DISPLAY 'Critical error initializing transaction system'
        SET CRITICAL-ERROR TO TRUE
        PERFORM EMERGENCY-SHUTDOWN
    NOT ON EXCEPTION
        DISPLAY 'Transaction system initialized successfully'
    END-CALL.
 
PROCESS-TRANSACTION-BATCH.
    PERFORM VARYING CURRENT-TRANSACTION FROM 1 BY 1
            UNTIL CURRENT-TRANSACTION > TRANSACTION-COUNT
            OR CRITICAL-ERROR
        
        PERFORM GENERATE-TRANSACTION-DATA
        PERFORM VALIDATE-TRANSACTION
        
        IF NOT CRITICAL-ERROR AND NOT SYSTEM-ERROR
            PERFORM PROCESS-INDIVIDUAL-TRANSACTION
            PERFORM AUDIT-TRANSACTION
        END-IF
        
        PERFORM HANDLE-TRANSACTION-ERRORS
    END-PERFORM.
 
GENERATE-TRANSACTION-DATA.
    *> Generate test transaction data
    STRING 'TXN' DELIMITED BY SIZE
           CURRENT-TRANSACTION DELIMITED BY SIZE
           INTO TRANSACTION-ID
    END-STRING
    
    EVALUATE FUNCTION MOD(CURRENT-TRANSACTION, 4)
        WHEN 0
            MOVE 'DEPOSIT' TO TRANSACTION-TYPE
            MOVE 1000.00 TO TRANSACTION-AMOUNT
        WHEN 1
            MOVE 'WITHDRAWAL' TO TRANSACTION-TYPE
            MOVE 500.00 TO TRANSACTION-AMOUNT
        WHEN 2
            MOVE 'TRANSFER' TO TRANSACTION-TYPE
            MOVE 750.00 TO TRANSACTION-AMOUNT
        WHEN 3
            MOVE 'PAYMENT' TO TRANSACTION-TYPE
            MOVE 250.00 TO TRANSACTION-AMOUNT
    END-EVALUATE
    
    STRING 'ACCT' DELIMITED BY SIZE
           CURRENT-TRANSACTION DELIMITED BY SIZE
           INTO ACCOUNT-NUMBER
    END-STRING
    
    STRING 'CUST' DELIMITED BY SIZE
           CURRENT-TRANSACTION DELIMITED BY SIZE
           INTO CUSTOMER-ID
    END-STRING.
 
VALIDATE-TRANSACTION.
    MOVE TRANSACTION-ID TO VAL-TRANSACTION-ID
    MOVE ACCOUNT-NUMBER TO VAL-ACCOUNT-NUMBER
    MOVE CUSTOMER-ID TO VAL-CUSTOMER-ID
    
    PERFORM UNTIL VAL-RETURN-CODE = 0 OR RETRY-ATTEMPTS >= MAX-RETRY-ATTEMPTS
        CALL 'VALIDATE-TRANSACTION'
            USING VALIDATION-INTERFACE
        ON EXCEPTION
            ADD 1 TO RETRY-ATTEMPTS
            IF RETRY-ATTEMPTS >= MAX-RETRY-ATTEMPTS
                DISPLAY 'Validation service unavailable for transaction: ' 
                        TRANSACTION-ID
                SET SYSTEM-ERROR TO TRUE
                ADD 1 TO ERROR-COUNT
            ELSE
                DISPLAY 'Retrying validation for transaction: ' TRANSACTION-ID
                PERFORM WAIT-AND-RETRY
            END-IF
        NOT ON EXCEPTION
            EVALUATE VAL-RETURN-CODE
                WHEN 0
                    DISPLAY 'Transaction validation successful: ' TRANSACTION-ID
                WHEN 1
                    DISPLAY 'Invalid account number: ' ACCOUNT-NUMBER
                    SET RECOVERABLE-ERROR TO TRUE
                    ADD 1 TO ERROR-COUNT
                WHEN 2
                    DISPLAY 'Invalid customer ID: ' CUSTOMER-ID
                    SET RECOVERABLE-ERROR TO TRUE
                    ADD 1 TO ERROR-COUNT
                WHEN 3
                    DISPLAY 'Transaction ID format error: ' TRANSACTION-ID
                    SET RECOVERABLE-ERROR TO TRUE
                    ADD 1 TO ERROR-COUNT
                WHEN OTHER
                    DISPLAY 'Unknown validation error: ' VAL-ERROR-MESSAGE
                    SET SYSTEM-ERROR TO TRUE
                    ADD 1 TO ERROR-COUNT
            END-EVALUATE
        END-CALL
    END-PERFORM
    
    MOVE 0 TO RETRY-ATTEMPTS.
 
PROCESS-INDIVIDUAL-TRANSACTION.
    IF VAL-RETURN-CODE = 0
        MOVE TRANSACTION-ID TO PROC-TRANSACTION-ID
        MOVE TRANSACTION-TYPE TO PROC-TRANSACTION-TYPE
        MOVE TRANSACTION-AMOUNT TO PROC-AMOUNT
        MOVE ACCOUNT-NUMBER TO PROC-ACCOUNT-NUMBER
        
        CALL 'PROCESS-TRANSACTION'
            USING PROCESSING-INTERFACE
        ON EXCEPTION
            DISPLAY 'Processing service unavailable for transaction: ' 
                    TRANSACTION-ID
            SET SYSTEM-ERROR TO TRUE
            ADD 1 TO ERROR-COUNT
        NOT ON EXCEPTION
            EVALUATE PROC-RETURN-CODE
                WHEN 0
                    ADD 1 TO SUCCESSFUL-COUNT
                    DISPLAY 'Transaction processed successfully: ' TRANSACTION-ID
                WHEN 1
                    DISPLAY 'Insufficient funds: ' TRANSACTION-ID
                    SET RECOVERABLE-ERROR TO TRUE
                    ADD 1 TO ERROR-COUNT
                WHEN 2
                    DISPLAY 'Account locked: ' TRANSACTION-ID
                    SET RECOVERABLE-ERROR TO TRUE
                    ADD 1 TO ERROR-COUNT
                WHEN 3
                    DISPLAY 'Daily limit exceeded: ' TRANSACTION-ID
                    SET RECOVERABLE-ERROR TO TRUE
                    ADD 1 TO ERROR-COUNT
                WHEN OTHER
                    DISPLAY 'Processing error: ' PROC-ERROR-MESSAGE
                    SET SYSTEM-ERROR TO TRUE
                    ADD 1 TO ERROR-COUNT
            END-EVALUATE
        END-CALL
    END-IF.
 
AUDIT-TRANSACTION.
    MOVE TRANSACTION-ID TO AUDIT-TRANSACTION-ID
    MOVE 'SYSTEM' TO AUDIT-USER-ID
    MOVE FUNCTION CURRENT-DATE TO AUDIT-TIMESTAMP
    
    IF PROC-RETURN-CODE = 0
        MOVE 'TRANSACTION-PROCESSED' TO AUDIT-ACTION
    ELSE
        MOVE 'TRANSACTION-FAILED' TO AUDIT-ACTION
    END-IF
    
    CALL 'AUDIT-TRANSACTION'
        USING AUDIT-INTERFACE
    ON EXCEPTION
        DISPLAY 'Audit service unavailable - continuing processing'
        *> Audit failures are not critical for transaction processing
    NOT ON EXCEPTION
        IF AUDIT-RETURN-CODE = 0
            DISPLAY 'Transaction audited: ' TRANSACTION-ID
        ELSE
            DISPLAY 'Audit failed for transaction: ' TRANSACTION-ID
        END-IF
    END-CALL.
 
HANDLE-TRANSACTION-ERRORS.
    IF CRITICAL-ERROR
        DISPLAY 'Critical error detected - stopping processing'
        PERFORM EMERGENCY-SHUTDOWN
    ELSE
        IF SYSTEM-ERROR
            DISPLAY 'System error detected - attempting recovery'
            PERFORM ATTEMPT-SYSTEM-RECOVERY
        END-IF
        
        IF RECOVERABLE-ERROR
            DISPLAY 'Recoverable error - continuing with next transaction'
            MOVE 'N' TO RECOVERABLE-ERROR-FLAG
        END-IF
    END-IF.
 
WAIT-AND-RETRY.
    *> Simple delay mechanism
    COMPUTE RETRY-ATTEMPTS = RETRY-ATTEMPTS + 1
    DISPLAY 'Waiting before retry attempt: ' RETRY-ATTEMPTS.
 
ATTEMPT-SYSTEM-RECOVERY.
    CALL 'SYSTEM-RECOVERY'
    ON EXCEPTION
        DISPLAY 'System recovery failed - setting critical error'
        SET CRITICAL-ERROR TO TRUE
    NOT ON EXCEPTION
        DISPLAY 'System recovery successful'
        MOVE 'N' TO SYSTEM-ERROR-FLAG
    END-CALL.
 
EMERGENCY-SHUTDOWN.
    CALL 'EMERGENCY-SHUTDOWN'
    ON EXCEPTION
        DISPLAY 'Emergency shutdown failed'
    NOT ON EXCEPTION
        DISPLAY 'Emergency shutdown completed'
    END-CALL.
 
FINALIZE-TRANSACTION-SYSTEM.
    CALL 'FINALIZE-TRANSACTION-SYSTEM'
        USING SUCCESSFUL-COUNT, ERROR-COUNT
    ON EXCEPTION
        DISPLAY 'Error finalizing transaction system'
    NOT ON EXCEPTION
        DISPLAY 'Transaction system finalized successfully'
    END-CALL
    
    DISPLAY 'Processing Summary:'
    DISPLAY 'Total Transactions: ' TRANSACTION-COUNT
    DISPLAY 'Successful: ' SUCCESSFUL-COUNT
    DISPLAY 'Errors: ' ERROR-COUNT.

END-CALL Best Practices

Recommended Practices
  • ✓
    Always use END-CALL with exception handling
  • ✓
    Implement comprehensive error recovery
  • ✓
    Use consistent parameter passing patterns
  • ✓
    Validate return codes from subprograms
Common Mistakes
  • ✗
    Omitting END-CALL in nested structures
  • ✗
    Not handling ON EXCEPTION conditions
  • ✗
    Poor parameter validation
  • ✗
    Ignoring subprogram return codes

Interactive Tutorial

Hands-On END-CALL Practice
Practice implementing END-CALL in various modular programming scenarios

Exercise 1: Basic Subprogram Call with Error Handling

Complete the following code with proper END-CALL statements:

cobol
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
CALL 'CALCULATE-TAX'
    USING GROSS-PAY, TAX-RATE, TAX-AMOUNT, RETURN-CODE
ON EXCEPTION
    DISPLAY 'Error calling tax calculation subprogram'
    MOVE 'Y' TO ERROR-FLAG
NOT ON EXCEPTION
    IF RETURN-CODE = 0
        DISPLAY 'Tax calculated successfully: ' TAX-AMOUNT
    ELSE
        DISPLAY 'Tax calculation failed with code: ' RETURN-CODE
    END-IF
*> Add END-CALL here
 
CALL 'VALIDATE-EMPLOYEE'
    USING EMPLOYEE-ID, EMPLOYEE-DATA, VALIDATION-RESULT
ON EXCEPTION
    DISPLAY 'Validation service unavailable'
    MOVE 'Y' TO ERROR-FLAG
NOT ON EXCEPTION
    DISPLAY 'Employee validation completed'
*> Add END-CALL here

Exercise 2: Nested Subprogram Calls

Add appropriate END-CALL statements to this nested structure:

cobol
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
PERFORM VARYING COUNTER FROM 1 BY 1 UNTIL COUNTER > 10
    CALL 'PROCESS-RECORD'
        USING RECORD-ID(COUNTER), PROCESS-FLAG
    ON EXCEPTION
        DISPLAY 'Error processing record: ' COUNTER
        ADD 1 TO ERROR-COUNT
    NOT ON EXCEPTION
        IF PROCESS-FLAG = 'Y'
            CALL 'AUDIT-RECORD'
                USING RECORD-ID(COUNTER), AUDIT-RESULT
            ON EXCEPTION
                DISPLAY 'Audit failed for record: ' COUNTER
            NOT ON EXCEPTION
                ADD 1 TO PROCESSED-COUNT
            *> Add END-CALL here
        END-IF
    *> Add END-CALL here
END-PERFORM

Knowledge Check Quiz

Test Your Understanding

Frequently Asked Questions