MainframeMaster

COBOL Tutorial

COBOL LINKAGE SECTION

The LINKAGE SECTION represents sophisticated parameter passing and data sharing mechanisms within COBOL modular programming environments, providing comprehensive inter-program communication capabilities, efficient data exchange protocols, and advanced memory management that enable seamless program integration, reliable parameter transmission, and optimized resource utilization. This section embodies advanced programming principles by supporting dynamic data referencing, enabling sophisticated program collaboration, and facilitating comprehensive modular architecture requirements while maintaining data integrity, ensuring efficient memory usage, and enabling complex application scenarios across enterprise environments requiring detailed program communication, automated parameter management, and reliable data sharing with optimized performance characteristics and consistent interface standards throughout the application ecosystem.

LINKAGE SECTION Syntax

Basic LINKAGE 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
27
28
29
30
31
DATA DIVISION.
LINKAGE SECTION.
01 parameter-name-1 PIC clause.
01 parameter-name-2.
   05 field-1 PIC clause.
   05 field-2 PIC clause.
 
*> Called program structure
PROCEDURE DIVISION USING parameter-name-1 parameter-name-2.
 
*> Calling program
CALL 'SUBPROGRAM' USING data-item-1 data-item-2.
 
*> Complete example:
DATA DIVISION.
LINKAGE SECTION.
01 LK-EMPLOYEE-ID           PIC 9(6).
01 LK-EMPLOYEE-RECORD.
   05 LK-EMP-NAME           PIC X(30).
   05 LK-EMP-SALARY         PIC 9(7)V99.
   05 LK-EMP-STATUS         PIC X(10).
01 LK-RETURN-CODE           PIC 9(2).
 
PROCEDURE DIVISION USING LK-EMPLOYEE-ID
                        LK-EMPLOYEE-RECORD
                        LK-RETURN-CODE.
 
*> Alternative with BY REFERENCE/CONTENT
PROCEDURE DIVISION USING BY REFERENCE LK-EMPLOYEE-ID
                        BY CONTENT    LK-EMPLOYEE-RECORD
                        BY REFERENCE  LK-RETURN-CODE.
Parameter Passing
Data Sharing
Modular Programming

Comprehensive LINKAGE Examples

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
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
*> MAIN CALLING PROGRAM
IDENTIFICATION DIVISION.
PROGRAM-ID. LINKAGE-CALLER.
 
DATA DIVISION.
WORKING-STORAGE SECTION.
*> Data to be passed to subprograms
01 WS-EMPLOYEE-DATA.
   05 WS-EMP-ID             PIC 9(6) VALUE 123456.
   05 WS-EMP-RECORD.
      10 WS-EMP-NAME        PIC X(30) VALUE "JOHN SMITH".
      10 WS-EMP-DEPT        PIC X(15) VALUE "SALES".
      10 WS-EMP-SALARY      PIC 9(7)V99 VALUE 65000.50.
      10 WS-EMP-STATUS      PIC X(10) VALUE "ACTIVE".
   05 WS-EMP-ADDRESS.
      10 WS-STREET          PIC X(30) VALUE "123 MAIN ST".
      10 WS-CITY            PIC X(20) VALUE "ANYTOWN".
      10 WS-STATE           PIC X(2) VALUE "NY".
      10 WS-ZIP             PIC 9(5) VALUE 12345.
 
*> Communication variables
01 WS-OPERATION-TYPE        PIC X(10).
01 WS-RETURN-CODE           PIC 9(2).
01 WS-ERROR-MESSAGE         PIC X(80).
 
*> Calculation results
01 WS-CALCULATION-RESULTS.
   05 WS-ANNUAL-SALARY      PIC 9(8)V99.
   05 WS-TAX-AMOUNT         PIC 9(7)V99.
   05 WS-NET-SALARY         PIC 9(8)V99.
 
PROCEDURE DIVISION.
MAIN-PROCESSING.
    DISPLAY "=== LINKAGE SECTION DEMONSTRATION ==="
    DISPLAY SPACES
    
    PERFORM DEMONSTRATE-EMPLOYEE-PROCESSING
    PERFORM DEMONSTRATE-CALCULATION-CALLS
    PERFORM DEMONSTRATE-VALIDATION-CALLS
    PERFORM DEMONSTRATE-UTILITY-CALLS
    
    DISPLAY "=== LINKAGE DEMO COMPLETE ==="
    STOP RUN.
 
DEMONSTRATE-EMPLOYEE-PROCESSING.
    DISPLAY "=== EMPLOYEE PROCESSING WITH LINKAGE ==="
    
    *> Call employee validation
    MOVE "VALIDATE" TO WS-OPERATION-TYPE
    CALL 'EMP-VALIDATE' USING WS-EMP-ID
                             WS-EMP-RECORD
                             WS-OPERATION-TYPE
                             WS-RETURN-CODE
                             WS-ERROR-MESSAGE
    
    IF WS-RETURN-CODE = 0
       DISPLAY "Employee validation successful"
       PERFORM CALL-EMPLOYEE-UPDATE
    ELSE
       DISPLAY "Employee validation failed: " WS-ERROR-MESSAGE
    END-IF
    DISPLAY SPACES.
 
CALL-EMPLOYEE-UPDATE.
    MOVE "UPDATE" TO WS-OPERATION-TYPE
    CALL 'EMP-UPDATE' USING WS-EMP-ID
                           WS-EMP-RECORD
                           WS-EMP-ADDRESS
                           WS-OPERATION-TYPE
                           WS-RETURN-CODE
    
    IF WS-RETURN-CODE = 0
       DISPLAY "Employee update successful"
    ELSE
       DISPLAY "Employee update failed with code: " WS-RETURN-CODE
    END-IF.
 
DEMONSTRATE-CALCULATION-CALLS.
    DISPLAY "=== CALCULATION CALLS WITH LINKAGE ==="
    
    *> Call salary calculation
    CALL 'SALARY-CALC' USING WS-EMP-SALARY
                            WS-ANNUAL-SALARY
                            WS-TAX-AMOUNT
                            WS-NET-SALARY
                            WS-RETURN-CODE
    
    IF WS-RETURN-CODE = 0
       DISPLAY "Salary calculations:"
       DISPLAY "  Annual: $" WS-ANNUAL-SALARY
       DISPLAY "  Tax: $" WS-TAX-AMOUNT
       DISPLAY "  Net: $" WS-NET-SALARY
    ELSE
       DISPLAY "Calculation failed with code: " WS-RETURN-CODE
    END-IF
    DISPLAY SPACES.
 
DEMONSTRATE-VALIDATION-CALLS.
    DISPLAY "=== VALIDATION CALLS WITH LINKAGE ==="
    
    *> Call address validation
    CALL 'ADDR-VALIDATE' USING WS-EMP-ADDRESS
                              WS-RETURN-CODE
                              WS-ERROR-MESSAGE
    
    EVALUATE WS-RETURN-CODE
        WHEN 0
            DISPLAY "Address validation passed"
        WHEN 1
            DISPLAY "Address warning: " WS-ERROR-MESSAGE
        WHEN OTHER
            DISPLAY "Address validation failed: " WS-ERROR-MESSAGE
    END-EVALUATE
    DISPLAY SPACES.
 
DEMONSTRATE-UTILITY-CALLS.
    DISPLAY "=== UTILITY CALLS WITH LINKAGE ==="
    
    *> Call string utilities
    CALL 'STRING-UTIL' USING WS-EMP-NAME
                            WS-OPERATION-TYPE
                            WS-RETURN-CODE
    
    DISPLAY "String utility completed with code: " WS-RETURN-CODE
    DISPLAY SPACES.
 
*> ==================================================
*> EMPLOYEE VALIDATION SUBPROGRAM
*> ==================================================
IDENTIFICATION DIVISION.
PROGRAM-ID. EMP-VALIDATE.
 
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-VALIDATION-RULES.
   05 WS-MIN-ID             PIC 9(6) VALUE 100000.
   05 WS-MAX-ID             PIC 9(6) VALUE 999999.
   05 WS-MIN-SALARY         PIC 9(7)V99 VALUE 20000.00.
   05 WS-MAX-SALARY         PIC 9(7)V99 VALUE 200000.00.
 
01 WS-VALIDATION-FLAGS.
   05 WS-ID-VALID           PIC X VALUE 'Y'.
   05 WS-NAME-VALID         PIC X VALUE 'Y'.
   05 WS-SALARY-VALID       PIC X VALUE 'Y'.
   05 WS-STATUS-VALID       PIC X VALUE 'Y'.
 
LINKAGE SECTION.
01 LK-EMPLOYEE-ID           PIC 9(6).
01 LK-EMPLOYEE-RECORD.
   05 LK-EMP-NAME           PIC X(30).
   05 LK-EMP-DEPT           PIC X(15).
   05 LK-EMP-SALARY         PIC 9(7)V99.
   05 LK-EMP-STATUS         PIC X(10).
01 LK-OPERATION             PIC X(10).
01 LK-RETURN-CODE           PIC 9(2).
01 LK-ERROR-MESSAGE         PIC X(80).
 
PROCEDURE DIVISION USING LK-EMPLOYEE-ID
                        LK-EMPLOYEE-RECORD
                        LK-OPERATION
                        LK-RETURN-CODE
                        LK-ERROR-MESSAGE.
 
VALIDATION-MAIN.
    MOVE 0 TO LK-RETURN-CODE
    MOVE SPACES TO LK-ERROR-MESSAGE
    
    EVALUATE LK-OPERATION
        WHEN "VALIDATE"
            PERFORM VALIDATE-EMPLOYEE-DATA
        WHEN "QUICK"
            PERFORM QUICK-VALIDATION
        WHEN OTHER
            MOVE 99 TO LK-RETURN-CODE
            MOVE "INVALID OPERATION" TO LK-ERROR-MESSAGE
    END-EVALUATE
    
    GOBACK.
 
VALIDATE-EMPLOYEE-DATA.
    PERFORM VALIDATE-EMPLOYEE-ID
    PERFORM VALIDATE-EMPLOYEE-NAME
    PERFORM VALIDATE-EMPLOYEE-SALARY
    PERFORM VALIDATE-EMPLOYEE-STATUS
    
    IF WS-ID-VALID = 'N' OR WS-NAME-VALID = 'N' OR 
       WS-SALARY-VALID = 'N' OR WS-STATUS-VALID = 'N'
       MOVE 1 TO LK-RETURN-CODE
       MOVE "VALIDATION FAILED" TO LK-ERROR-MESSAGE
    END-IF.
 
VALIDATE-EMPLOYEE-ID.
    IF LK-EMPLOYEE-ID < WS-MIN-ID OR LK-EMPLOYEE-ID > WS-MAX-ID
       MOVE 'N' TO WS-ID-VALID
       MOVE "INVALID EMPLOYEE ID RANGE" TO LK-ERROR-MESSAGE
       MOVE 2 TO LK-RETURN-CODE
    END-IF.
 
VALIDATE-EMPLOYEE-NAME.
    IF LK-EMP-NAME = SPACES
       MOVE 'N' TO WS-NAME-VALID
       MOVE "EMPLOYEE NAME REQUIRED" TO LK-ERROR-MESSAGE
       MOVE 3 TO LK-RETURN-CODE
    END-IF.
 
VALIDATE-EMPLOYEE-SALARY.
    IF LK-EMP-SALARY < WS-MIN-SALARY OR LK-EMP-SALARY > WS-MAX-SALARY
       MOVE 'N' TO WS-SALARY-VALID
       MOVE "SALARY OUT OF VALID RANGE" TO LK-ERROR-MESSAGE
       MOVE 4 TO LK-RETURN-CODE
    END-IF.
 
VALIDATE-EMPLOYEE-STATUS.
    IF LK-EMP-STATUS NOT = "ACTIVE" AND LK-EMP-STATUS NOT = "INACTIVE"
       MOVE 'N' TO WS-STATUS-VALID
       MOVE "INVALID EMPLOYEE STATUS" TO LK-ERROR-MESSAGE
       MOVE 5 TO LK-RETURN-CODE
    END-IF.
 
QUICK-VALIDATION.
    IF LK-EMPLOYEE-ID > 0 AND LK-EMP-NAME NOT = SPACES
       MOVE 0 TO LK-RETURN-CODE
    ELSE
       MOVE 1 TO LK-RETURN-CODE
       MOVE "QUICK VALIDATION FAILED" TO LK-ERROR-MESSAGE
    END-IF.
 
*> ==================================================
*> SALARY CALCULATION SUBPROGRAM
*> ==================================================
IDENTIFICATION DIVISION.
PROGRAM-ID. SALARY-CALC.
 
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-TAX-RATES.
   05 WS-FEDERAL-RATE       PIC 9V9999 VALUE 0.2200.
   05 WS-STATE-RATE         PIC 9V9999 VALUE 0.0650.
   05 WS-FICA-RATE          PIC 9V9999 VALUE 0.0765.
 
01 WS-CALCULATION-WORK.
   05 WS-FEDERAL-TAX        PIC 9(7)V99.
   05 WS-STATE-TAX          PIC 9(6)V99.
   05 WS-FICA-TAX           PIC 9(6)V99.
   05 WS-TOTAL-TAX          PIC 9(7)V99.
 
LINKAGE SECTION.
01 LK-MONTHLY-SALARY        PIC 9(7)V99.
01 LK-ANNUAL-SALARY         PIC 9(8)V99.
01 LK-TAX-AMOUNT            PIC 9(7)V99.
01 LK-NET-SALARY            PIC 9(8)V99.
01 LK-RETURN-CODE           PIC 9(2).
 
PROCEDURE DIVISION USING LK-MONTHLY-SALARY
                        LK-ANNUAL-SALARY
                        LK-TAX-AMOUNT
                        LK-NET-SALARY
                        LK-RETURN-CODE.
 
CALCULATION-MAIN.
    MOVE 0 TO LK-RETURN-CODE
    
    IF LK-MONTHLY-SALARY <= 0
       MOVE 1 TO LK-RETURN-CODE
       GOBACK
    END-IF
    
    PERFORM CALCULATE-ANNUAL-SALARY
    PERFORM CALCULATE-TAXES
    PERFORM CALCULATE-NET-SALARY
    
    GOBACK.
 
CALCULATE-ANNUAL-SALARY.
    MULTIPLY LK-MONTHLY-SALARY BY 12 GIVING LK-ANNUAL-SALARY.
 
CALCULATE-TAXES.
    COMPUTE WS-FEDERAL-TAX = LK-ANNUAL-SALARY * WS-FEDERAL-RATE
    COMPUTE WS-STATE-TAX = LK-ANNUAL-SALARY * WS-STATE-RATE
    COMPUTE WS-FICA-TAX = LK-ANNUAL-SALARY * WS-FICA-RATE
    
    ADD WS-FEDERAL-TAX WS-STATE-TAX WS-FICA-TAX GIVING LK-TAX-AMOUNT.
 
CALCULATE-NET-SALARY.
    SUBTRACT LK-TAX-AMOUNT FROM LK-ANNUAL-SALARY GIVING LK-NET-SALARY.
 
*> ==================================================
*> ADDRESS VALIDATION SUBPROGRAM
*> ==================================================
IDENTIFICATION DIVISION.
PROGRAM-ID. ADDR-VALIDATE.
 
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-VALID-STATES.
   05 WS-STATE-TABLE.
      10 FILLER PIC X(2) VALUE "AL".
      10 FILLER PIC X(2) VALUE "AK".
      10 FILLER PIC X(2) VALUE "AZ".
      10 FILLER PIC X(2) VALUE "CA".
      10 FILLER PIC X(2) VALUE "NY".
      10 FILLER PIC X(2) VALUE "TX".
   05 WS-STATE-ENTRY REDEFINES WS-STATE-TABLE
      OCCURS 6 TIMES PIC X(2).
 
01 WS-VALIDATION-WORK.
   05 WS-STATE-INDEX        PIC 9(2).
   05 WS-STATE-FOUND        PIC X VALUE 'N'.
 
LINKAGE SECTION.
01 LK-ADDRESS.
   05 LK-STREET             PIC X(30).
   05 LK-CITY               PIC X(20).
   05 LK-STATE              PIC X(2).
   05 LK-ZIP                PIC 9(5).
01 LK-RETURN-CODE           PIC 9(2).
01 LK-ERROR-MESSAGE         PIC X(80).
 
PROCEDURE DIVISION USING LK-ADDRESS
                        LK-RETURN-CODE
                        LK-ERROR-MESSAGE.
 
ADDRESS-VALIDATION-MAIN.
    MOVE 0 TO LK-RETURN-CODE
    MOVE SPACES TO LK-ERROR-MESSAGE
    
    PERFORM VALIDATE-STREET
    PERFORM VALIDATE-CITY
    PERFORM VALIDATE-STATE
    PERFORM VALIDATE-ZIP
    
    GOBACK.
 
VALIDATE-STREET.
    IF LK-STREET = SPACES
       MOVE 1 TO LK-RETURN-CODE
       MOVE "STREET ADDRESS REQUIRED" TO LK-ERROR-MESSAGE
    END-IF.
 
VALIDATE-CITY.
    IF LK-CITY = SPACES
       MOVE 2 TO LK-RETURN-CODE
       MOVE "CITY REQUIRED" TO LK-ERROR-MESSAGE
    END-IF.
 
VALIDATE-STATE.
    MOVE 'N' TO WS-STATE-FOUND
    PERFORM VARYING WS-STATE-INDEX FROM 1 BY 1 
            UNTIL WS-STATE-INDEX > 6 OR WS-STATE-FOUND = 'Y'
        IF LK-STATE = WS-STATE-ENTRY(WS-STATE-INDEX)
           MOVE 'Y' TO WS-STATE-FOUND
        END-IF
    END-PERFORM
    
    IF WS-STATE-FOUND = 'N'
       MOVE 3 TO LK-RETURN-CODE
       MOVE "INVALID STATE CODE" TO LK-ERROR-MESSAGE
    END-IF.
 
VALIDATE-ZIP.
    IF LK-ZIP = 0
       MOVE 4 TO LK-RETURN-CODE
       MOVE "ZIP CODE REQUIRED" TO LK-ERROR-MESSAGE
    END-IF.
 
*> ==================================================
*> STRING UTILITY SUBPROGRAM
*> ==================================================
IDENTIFICATION DIVISION.
PROGRAM-ID. STRING-UTIL.
 
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-STRING-WORK.
   05 WS-WORK-STRING        PIC X(100).
   05 WS-STRING-LENGTH      PIC 9(3).
   05 WS-CHAR-INDEX         PIC 9(3).
 
LINKAGE SECTION.
01 LK-INPUT-STRING          PIC X(30).
01 LK-OPERATION             PIC X(10).
01 LK-RETURN-CODE           PIC 9(2).
 
PROCEDURE DIVISION USING LK-INPUT-STRING
                        LK-OPERATION
                        LK-RETURN-CODE.
 
STRING-UTILITY-MAIN.
    MOVE 0 TO LK-RETURN-CODE
    
    EVALUATE LK-OPERATION
        WHEN "UPPERCASE"
            PERFORM CONVERT-TO-UPPERCASE
        WHEN "LOWERCASE"
            PERFORM CONVERT-TO-LOWERCASE
        WHEN "TRIM"
            PERFORM TRIM-SPACES
        WHEN OTHER
            MOVE 1 TO LK-RETURN-CODE
    END-EVALUATE
    
    GOBACK.
 
CONVERT-TO-UPPERCASE.
    INSPECT LK-INPUT-STRING CONVERTING
        "abcdefghijklmnopqrstuvwxyz" TO "ABCDEFGHIJKLMNOPQRSTUVWXYZ".
 
CONVERT-TO-LOWERCASE.
    INSPECT LK-INPUT-STRING CONVERTING
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ" TO "abcdefghijklmnopqrstuvwxyz".
 
TRIM-SPACES.
    MOVE FUNCTION TRIM(LK-INPUT-STRING) TO LK-INPUT-STRING.

LINKAGE Features

Parameter Passing
  • • BY REFERENCE (default)
  • • BY CONTENT (copy)
  • • Multiple parameter support
  • • Bi-directional communication
Memory Management
  • • No storage allocation
  • • References external data
  • • Efficient memory usage
  • • Dynamic addressing

Interactive Tutorial

Hands-On Exercise: Building Modular Programs
Practice creating programs with LINKAGE SECTION for parameter passing

Exercise 1: Simple Parameter Passing

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
*> Main Program
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-NUMBER-1      PIC 9(5) VALUE 100.
01 WS-NUMBER-2      PIC 9(5) VALUE 50.
01 WS-RESULT        PIC 9(6).
 
PROCEDURE DIVISION.
MAIN-PROGRAM.
    CALL 'CALCULATOR' USING WS-NUMBER-1
                           WS-NUMBER-2
                           WS-RESULT
    
    DISPLAY "Result: " WS-RESULT
    STOP RUN.
 
*> Called Program - CALCULATOR
IDENTIFICATION DIVISION.
PROGRAM-ID. CALCULATOR.
 
DATA DIVISION.
LINKAGE SECTION.
01 LK-NUM-1         PIC 9(5).
01 LK-NUM-2         PIC 9(5).
01 LK-RESULT        PIC 9(6).
 
PROCEDURE DIVISION USING LK-NUM-1 LK-NUM-2 LK-RESULT.
CALCULATE-SUM.
    ADD LK-NUM-1 TO LK-NUM-2 GIVING LK-RESULT
    GOBACK.

Exercise 2: Complex Data Structures

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
*> Main Program
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-CUSTOMER-DATA.
   05 WS-CUST-ID    PIC 9(6) VALUE 123456.
   05 WS-CUST-NAME  PIC X(30) VALUE "JANE DOE".
   05 WS-BALANCE    PIC 9(8)V99 VALUE 1500.75.
01 WS-STATUS-CODE   PIC 9(2).
 
PROCEDURE DIVISION.
MAIN-PROGRAM.
    CALL 'CUST-PROCESS' USING WS-CUSTOMER-DATA
                             WS-STATUS-CODE
    
    IF WS-STATUS-CODE = 0
       DISPLAY "Customer processing successful"
    ELSE
       DISPLAY "Processing failed: " WS-STATUS-CODE
    END-IF
    STOP RUN.
 
*> Called Program - CUST-PROCESS
IDENTIFICATION DIVISION.
PROGRAM-ID. CUST-PROCESS.
 
DATA DIVISION.
LINKAGE SECTION.
01 LK-CUSTOMER.
   05 LK-CUST-ID    PIC 9(6).
   05 LK-CUST-NAME  PIC X(30).
   05 LK-BALANCE    PIC 9(8)V99.
01 LK-STATUS        PIC 9(2).
 
PROCEDURE DIVISION USING LK-CUSTOMER LK-STATUS.
PROCESS-CUSTOMER.
    MOVE 0 TO LK-STATUS
    
    IF LK-CUST-ID = 0
       MOVE 1 TO LK-STATUS
       GOBACK
    END-IF
    
    IF LK-BALANCE < 0
       MOVE 2 TO LK-STATUS
    END-IF
    
    GOBACK.

Best Practices

Knowledge Check

Test Your Understanding

Question 1: Storage Allocation

How does storage work for LINKAGE SECTION items?

Answer: LINKAGE SECTION items don't have their own storage allocation. They reference storage allocated in the calling program, enabling efficient parameter passing without data copying (when using BY REFERENCE).

Question 2: Parameter Passing Methods

What's the difference between BY REFERENCE and BY CONTENT?

Answer: BY REFERENCE (default) passes the address of the data, allowing modifications to affect the calling program. BY CONTENT passes a copy of the data, so modifications don't affect the original.

Question 3: Practical Applications

What are common uses for LINKAGE SECTION in business applications?

Answer: Common uses include: validation routines, calculation modules, database access routines, utility functions, error handling procedures, and any reusable business logic that needs to operate on calling program data.

Related Concepts

Parameter Passing

Data exchange between calling and called programs

Modular Programming

Program structure and subroutine organization

Program Communication

Inter-program data sharing and control flow