MainframeMaster

COBOL Tutorial

COBOL DEPENDING ON

The DEPENDING ON clause in COBOL enables the creation of variable-length tables and arrays, providing flexible data structures that can adapt their size based on runtime conditions.

DEPENDING ON Syntax

DEPENDING ON is used with the OCCURS clause to create tables with variable numbers of elements based on a control field value.

cobol
1
2
3
4
5
6
7
8
9
10
11
12
level-number data-name OCCURS minimum-value TO maximum-value TIMES
    DEPENDING ON control-field-name
    [ASCENDING/DESCENDING KEY key-field-name]
    [INDEXED BY index-name]
 
*> Examples:
05 TABLE-ENTRY OCCURS 0 TO 100 TIMES DEPENDING ON ENTRY-COUNT
   PIC X(20).
 
05 MONTHLY-DATA OCCURS 1 TO 12 TIMES DEPENDING ON MONTHS-ACTIVE
   10 MONTH-NAME    PIC X(9).
   10 MONTH-AMOUNT  PIC 9(8)V99.

Basic DEPENDING ON Usage

Simple Variable-Length Table

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
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-STUDENT-DATA.
   05 WS-STUDENT-COUNT      PIC 9(3) VALUE 0.
   05 WS-STUDENT-RECORD     OCCURS 0 TO 50 TIMES
                            DEPENDING ON WS-STUDENT-COUNT.
      10 WS-STUDENT-ID      PIC X(8).
      10 WS-STUDENT-NAME    PIC X(25).
      10 WS-STUDENT-GRADE   PIC X(2).
      10 WS-STUDENT-SCORE   PIC 9(3).
 
01 WS-PROCESSING-CONTROLS.
   05 WS-INPUT-CHOICE       PIC X(1).
   05 WS-CURRENT-INDEX      PIC 9(3).
 
PROCEDURE DIVISION.
VARIABLE-TABLE-DEMO.
    DISPLAY "=== Variable-Length Table Demo ==="
    
    PERFORM ADD-SAMPLE-STUDENTS
    PERFORM DISPLAY-ALL-STUDENTS
    PERFORM INTERACTIVE-PROCESSING.
 
ADD-SAMPLE-STUDENTS.
    *> Add first student
    ADD 1 TO WS-STUDENT-COUNT
    MOVE "STU001" TO WS-STUDENT-ID(WS-STUDENT-COUNT)
    MOVE "John Smith" TO WS-STUDENT-NAME(WS-STUDENT-COUNT)
    MOVE "A" TO WS-STUDENT-GRADE(WS-STUDENT-COUNT)
    MOVE 95 TO WS-STUDENT-SCORE(WS-STUDENT-COUNT)
    
    *> Add second student
    ADD 1 TO WS-STUDENT-COUNT
    MOVE "STU002" TO WS-STUDENT-ID(WS-STUDENT-COUNT)
    MOVE "Jane Doe" TO WS-STUDENT-NAME(WS-STUDENT-COUNT)
    MOVE "B" TO WS-STUDENT-GRADE(WS-STUDENT-COUNT)
    MOVE 87 TO WS-STUDENT-SCORE(WS-STUDENT-COUNT)
    
    *> Add third student
    ADD 1 TO WS-STUDENT-COUNT
    MOVE "STU003" TO WS-STUDENT-ID(WS-STUDENT-COUNT)
    MOVE "Bob Johnson" TO WS-STUDENT-NAME(WS-STUDENT-COUNT)
    MOVE "A" TO WS-STUDENT-GRADE(WS-STUDENT-COUNT)
    MOVE 92 TO WS-STUDENT-SCORE(WS-STUDENT-COUNT)
    
    DISPLAY "Added " WS-STUDENT-COUNT " students to table".
 
DISPLAY-ALL-STUDENTS.
    DISPLAY " "
    DISPLAY "Current Student Records (Count: " WS-STUDENT-COUNT "):"
    DISPLAY "ID       Name                     Grade Score"
    DISPLAY "-------- ------------------------ ----- -----"
    
    PERFORM VARYING WS-CURRENT-INDEX FROM 1 BY 1
            UNTIL WS-CURRENT-INDEX > WS-STUDENT-COUNT
        DISPLAY WS-STUDENT-ID(WS-CURRENT-INDEX) " "
                WS-STUDENT-NAME(WS-CURRENT-INDEX) " "
                WS-STUDENT-GRADE(WS-CURRENT-INDEX) "     "
                WS-STUDENT-SCORE(WS-CURRENT-INDEX)
    END-PERFORM.
 
INTERACTIVE-PROCESSING.
    DISPLAY " "
    DISPLAY "Options: (A)dd student, (R)emove last, (Q)uit"
    ACCEPT WS-INPUT-CHOICE
    
    EVALUATE WS-INPUT-CHOICE
        WHEN 'A' OR 'a'
            PERFORM ADD-NEW-STUDENT
            PERFORM DISPLAY-ALL-STUDENTS
            PERFORM INTERACTIVE-PROCESSING
        WHEN 'R' OR 'r'
            PERFORM REMOVE-LAST-STUDENT
            PERFORM DISPLAY-ALL-STUDENTS
            PERFORM INTERACTIVE-PROCESSING
        WHEN 'Q' OR 'q'
            DISPLAY "Exiting..."
        WHEN OTHER
            DISPLAY "Invalid choice. Try again."
            PERFORM INTERACTIVE-PROCESSING
    END-EVALUATE.
 
ADD-NEW-STUDENT.
    IF WS-STUDENT-COUNT < 50
        ADD 1 TO WS-STUDENT-COUNT
        DISPLAY "Enter student ID: "
        ACCEPT WS-STUDENT-ID(WS-STUDENT-COUNT)
        DISPLAY "Enter student name: "
        ACCEPT WS-STUDENT-NAME(WS-STUDENT-COUNT)
        DISPLAY "Enter grade (A-F): "
        ACCEPT WS-STUDENT-GRADE(WS-STUDENT-COUNT)
        DISPLAY "Enter score (0-100): "
        ACCEPT WS-STUDENT-SCORE(WS-STUDENT-COUNT)
        DISPLAY "Student added. Total count: " WS-STUDENT-COUNT
    ELSE
        DISPLAY "Cannot add more students. Table is full (50 max)."
    END-IF.
 
REMOVE-LAST-STUDENT.
    IF WS-STUDENT-COUNT > 0
        DISPLAY "Removing student: " WS-STUDENT-NAME(WS-STUDENT-COUNT)
        SUBTRACT 1 FROM WS-STUDENT-COUNT
        DISPLAY "Student removed. Total count: " WS-STUDENT-COUNT
    ELSE
        DISPLAY "No students to remove. Table is empty."
    END-IF.

Dynamic Resizing 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
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
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-DYNAMIC-ARRAY.
   05 WS-ARRAY-SIZE         PIC 9(3) VALUE 0.
   05 WS-ARRAY-ELEMENT      OCCURS 0 TO 999 TIMES
                            DEPENDING ON WS-ARRAY-SIZE
                            PIC 9(6)V99.
 
01 WS-ARRAY-OPERATIONS.
   05 WS-TOTAL-SUM          PIC 9(8)V99 VALUE 0.
   05 WS-AVERAGE            PIC 9(6)V99 VALUE 0.
   05 WS-MAX-VALUE          PIC 9(6)V99 VALUE 0.
   05 WS-MIN-VALUE          PIC 9(6)V99 VALUE 999999.99.
 
01 WS-CONTROLS.
   05 WS-OPERATION-CHOICE   PIC X(1).
   05 WS-NEW-VALUE          PIC 9(6)V99.
   05 WS-INDEX              PIC 9(3).
 
PROCEDURE DIVISION.
DYNAMIC-ARRAY-DEMO.
    DISPLAY "=== Dynamic Array Resizing Demo ==="
    
    PERFORM INITIALIZE-ARRAY
    PERFORM ARRAY-MENU.
 
INITIALIZE-ARRAY.
    *> Start with some initial values
    MOVE 5 TO WS-ARRAY-SIZE
    MOVE 100.50 TO WS-ARRAY-ELEMENT(1)
    MOVE 250.75 TO WS-ARRAY-ELEMENT(2)
    MOVE 175.25 TO WS-ARRAY-ELEMENT(3)
    MOVE 300.00 TO WS-ARRAY-ELEMENT(4)
    MOVE 125.80 TO WS-ARRAY-ELEMENT(5)
    
    DISPLAY "Initialized array with " WS-ARRAY-SIZE " elements".
 
ARRAY-MENU.
    PERFORM DISPLAY-ARRAY-STATUS
    DISPLAY " "
    DISPLAY "Array Operations:"
    DISPLAY "(A)dd element, (R)emove last, (C)alculate stats, (Q)uit"
    ACCEPT WS-OPERATION-CHOICE
    
    EVALUATE WS-OPERATION-CHOICE
        WHEN 'A' OR 'a'
            PERFORM ADD-ARRAY-ELEMENT
        WHEN 'R' OR 'r'
            PERFORM REMOVE-ARRAY-ELEMENT
        WHEN 'C' OR 'c'
            PERFORM CALCULATE-ARRAY-STATS
        WHEN 'Q' OR 'q'
            DISPLAY "Goodbye!"
            STOP RUN
        WHEN OTHER
            DISPLAY "Invalid choice"
    END-EVALUATE
    
    PERFORM ARRAY-MENU.
 
DISPLAY-ARRAY-STATUS.
    DISPLAY " "
    DISPLAY "Current Array Status:"
    DISPLAY "Size: " WS-ARRAY-SIZE " elements"
    DISPLAY "Values: "
    
    PERFORM VARYING WS-INDEX FROM 1 BY 1
            UNTIL WS-INDEX > WS-ARRAY-SIZE
        DISPLAY "  [" WS-INDEX "] = " WS-ARRAY-ELEMENT(WS-INDEX)
    END-PERFORM.
 
ADD-ARRAY-ELEMENT.
    IF WS-ARRAY-SIZE < 999
        DISPLAY "Enter new value: "
        ACCEPT WS-NEW-VALUE
        ADD 1 TO WS-ARRAY-SIZE
        MOVE WS-NEW-VALUE TO WS-ARRAY-ELEMENT(WS-ARRAY-SIZE)
        DISPLAY "Added element. New size: " WS-ARRAY-SIZE
    ELSE
        DISPLAY "Array is full (999 elements maximum)"
    END-IF.
 
REMOVE-ARRAY-ELEMENT.
    IF WS-ARRAY-SIZE > 0
        DISPLAY "Removing element " WS-ARRAY-SIZE 
                " (value: " WS-ARRAY-ELEMENT(WS-ARRAY-SIZE) ")"
        SUBTRACT 1 FROM WS-ARRAY-SIZE
        DISPLAY "Removed element. New size: " WS-ARRAY-SIZE
    ELSE
        DISPLAY "Array is empty - nothing to remove"
    END-IF.
 
CALCULATE-ARRAY-STATS.
    IF WS-ARRAY-SIZE > 0
        MOVE 0 TO WS-TOTAL-SUM
        MOVE 0 TO WS-MAX-VALUE
        MOVE 999999.99 TO WS-MIN-VALUE
        
        PERFORM VARYING WS-INDEX FROM 1 BY 1
                UNTIL WS-INDEX > WS-ARRAY-SIZE
            ADD WS-ARRAY-ELEMENT(WS-INDEX) TO WS-TOTAL-SUM
            
            IF WS-ARRAY-ELEMENT(WS-INDEX) > WS-MAX-VALUE
                MOVE WS-ARRAY-ELEMENT(WS-INDEX) TO WS-MAX-VALUE
            END-IF
            
            IF WS-ARRAY-ELEMENT(WS-INDEX) < WS-MIN-VALUE
                MOVE WS-ARRAY-ELEMENT(WS-INDEX) TO WS-MIN-VALUE
            END-IF
        END-PERFORM
        
        COMPUTE WS-AVERAGE = WS-TOTAL-SUM / WS-ARRAY-SIZE
        
        DISPLAY " "
        DISPLAY "Array Statistics:"
        DISPLAY "Total Sum: " WS-TOTAL-SUM
        DISPLAY "Average: " WS-AVERAGE
        DISPLAY "Maximum: " WS-MAX-VALUE
        DISPLAY "Minimum: " WS-MIN-VALUE
    ELSE
        DISPLAY "Cannot calculate statistics - array is empty"
    END-IF.

Advanced DEPENDING ON Techniques

Multi-Level Variable Tables

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
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-COMPANY-DATA.
   05 WS-DEPARTMENT-COUNT   PIC 9(2) VALUE 0.
   05 WS-DEPARTMENT         OCCURS 1 TO 20 TIMES
                            DEPENDING ON WS-DEPARTMENT-COUNT.
      10 WS-DEPT-NAME       PIC X(20).
      10 WS-DEPT-BUDGET     PIC 9(8)V99.
      10 WS-EMPLOYEE-COUNT  PIC 9(3) VALUE 0.
      10 WS-EMPLOYEE        OCCURS 0 TO 100 TIMES
                            DEPENDING ON WS-EMPLOYEE-COUNT.
         15 WS-EMP-ID       PIC X(6).
         15 WS-EMP-NAME     PIC X(25).
         15 WS-EMP-SALARY   PIC 9(6)V99.
         15 WS-EMP-POSITION PIC X(15).
 
01 WS-PROCESSING-VARIABLES.
   05 WS-DEPT-INDEX         PIC 9(2).
   05 WS-EMP-INDEX          PIC 9(3).
   05 WS-TOTAL-EMPLOYEES    PIC 9(4) VALUE 0.
   05 WS-TOTAL-PAYROLL      PIC 9(10)V99 VALUE 0.
 
PROCEDURE DIVISION.
MULTI-LEVEL-DEMO.
    DISPLAY "=== Multi-Level Variable Tables Demo ==="
    
    PERFORM SETUP-COMPANY-DATA
    PERFORM DISPLAY-COMPANY-STRUCTURE
    PERFORM CALCULATE-COMPANY-TOTALS.
 
SETUP-COMPANY-DATA.
    *> Setup IT Department
    ADD 1 TO WS-DEPARTMENT-COUNT
    MOVE "Information Technology" TO WS-DEPT-NAME(WS-DEPARTMENT-COUNT)
    MOVE 500000.00 TO WS-DEPT-BUDGET(WS-DEPARTMENT-COUNT)
    
    *> Add IT employees
    MOVE 3 TO WS-EMPLOYEE-COUNT(WS-DEPARTMENT-COUNT)
    
    MOVE "IT001" TO WS-EMP-ID(WS-DEPARTMENT-COUNT, 1)
    MOVE "Alice Johnson" TO WS-EMP-NAME(WS-DEPARTMENT-COUNT, 1)
    MOVE 75000.00 TO WS-EMP-SALARY(WS-DEPARTMENT-COUNT, 1)
    MOVE "Developer" TO WS-EMP-POSITION(WS-DEPARTMENT-COUNT, 1)
    
    MOVE "IT002" TO WS-EMP-ID(WS-DEPARTMENT-COUNT, 2)
    MOVE "Bob Smith" TO WS-EMP-NAME(WS-DEPARTMENT-COUNT, 2)
    MOVE 85000.00 TO WS-EMP-SALARY(WS-DEPARTMENT-COUNT, 2)
    MOVE "Senior Developer" TO WS-EMP-POSITION(WS-DEPARTMENT-COUNT, 2)
    
    MOVE "IT003" TO WS-EMP-ID(WS-DEPARTMENT-COUNT, 3)
    MOVE "Carol Wilson" TO WS-EMP-NAME(WS-DEPARTMENT-COUNT, 3)
    MOVE 95000.00 TO WS-EMP-SALARY(WS-DEPARTMENT-COUNT, 3)
    MOVE "Team Lead" TO WS-EMP-POSITION(WS-DEPARTMENT-COUNT, 3)
    
    *> Setup HR Department
    ADD 1 TO WS-DEPARTMENT-COUNT
    MOVE "Human Resources" TO WS-DEPT-NAME(WS-DEPARTMENT-COUNT)
    MOVE 200000.00 TO WS-DEPT-BUDGET(WS-DEPARTMENT-COUNT)
    
    *> Add HR employees
    MOVE 2 TO WS-EMPLOYEE-COUNT(WS-DEPARTMENT-COUNT)
    
    MOVE "HR001" TO WS-EMP-ID(WS-DEPARTMENT-COUNT, 1)
    MOVE "David Brown" TO WS-EMP-NAME(WS-DEPARTMENT-COUNT, 1)
    MOVE 60000.00 TO WS-EMP-SALARY(WS-DEPARTMENT-COUNT, 1)
    MOVE "HR Specialist" TO WS-EMP-POSITION(WS-DEPARTMENT-COUNT, 1)
    
    MOVE "HR002" TO WS-EMP-ID(WS-DEPARTMENT-COUNT, 2)
    MOVE "Eva Davis" TO WS-EMP-NAME(WS-DEPARTMENT-COUNT, 2)
    MOVE 70000.00 TO WS-EMP-SALARY(WS-DEPARTMENT-COUNT, 2)
    MOVE "HR Manager" TO WS-EMP-POSITION(WS-DEPARTMENT-COUNT, 2)
    
    DISPLAY "Setup complete: " WS-DEPARTMENT-COUNT " departments".
 
DISPLAY-COMPANY-STRUCTURE.
    DISPLAY " "
    DISPLAY "Company Organization Structure:"
    DISPLAY "=============================="
    
    PERFORM VARYING WS-DEPT-INDEX FROM 1 BY 1
            UNTIL WS-DEPT-INDEX > WS-DEPARTMENT-COUNT
        
        DISPLAY " "
        DISPLAY "Department: " WS-DEPT-NAME(WS-DEPT-INDEX)
        DISPLAY "Budget: $" WS-DEPT-BUDGET(WS-DEPT-INDEX)
        DISPLAY "Employees (" WS-EMPLOYEE-COUNT(WS-DEPT-INDEX) "):"
        
        PERFORM VARYING WS-EMP-INDEX FROM 1 BY 1
                UNTIL WS-EMP-INDEX > WS-EMPLOYEE-COUNT(WS-DEPT-INDEX)
            
            DISPLAY "  " WS-EMP-ID(WS-DEPT-INDEX, WS-EMP-INDEX) " - "
                    WS-EMP-NAME(WS-DEPT-INDEX, WS-EMP-INDEX)
            DISPLAY "    Position: " WS-EMP-POSITION(WS-DEPT-INDEX, WS-EMP-INDEX)
            DISPLAY "    Salary: $" WS-EMP-SALARY(WS-DEPT-INDEX, WS-EMP-INDEX)
        END-PERFORM
    END-PERFORM.
 
CALCULATE-COMPANY-TOTALS.
    MOVE 0 TO WS-TOTAL-EMPLOYEES
    MOVE 0 TO WS-TOTAL-PAYROLL
    
    PERFORM VARYING WS-DEPT-INDEX FROM 1 BY 1
            UNTIL WS-DEPT-INDEX > WS-DEPARTMENT-COUNT
        
        ADD WS-EMPLOYEE-COUNT(WS-DEPT-INDEX) TO WS-TOTAL-EMPLOYEES
        
        PERFORM VARYING WS-EMP-INDEX FROM 1 BY 1
                UNTIL WS-EMP-INDEX > WS-EMPLOYEE-COUNT(WS-DEPT-INDEX)
            ADD WS-EMP-SALARY(WS-DEPT-INDEX, WS-EMP-INDEX) TO WS-TOTAL-PAYROLL
        END-PERFORM
    END-PERFORM
    
    DISPLAY " "
    DISPLAY "Company Totals:"
    DISPLAY "==============="
    DISPLAY "Total Departments: " WS-DEPARTMENT-COUNT
    DISPLAY "Total Employees: " WS-TOTAL-EMPLOYEES
    DISPLAY "Total Payroll: $" WS-TOTAL-PAYROLL.

Variable Table with Search and Sort

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
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-PRODUCT-INVENTORY.
   05 WS-PRODUCT-COUNT      PIC 9(3) VALUE 0.
   05 WS-PRODUCT-ITEM       OCCURS 0 TO 500 TIMES
                            DEPENDING ON WS-PRODUCT-COUNT
                            ASCENDING KEY WS-PROD-CODE
                            INDEXED BY PROD-INDEX.
      10 WS-PROD-CODE       PIC X(8).
      10 WS-PROD-NAME       PIC X(30).
      10 WS-PROD-PRICE      PIC 9(6)V99.
      10 WS-PROD-QUANTITY   PIC 9(5).
      10 WS-PROD-CATEGORY   PIC X(15).
 
01 WS-SEARCH-CONTROLS.
   05 WS-SEARCH-CODE        PIC X(8).
   05 WS-SEARCH-RESULT      PIC 9(3).
   05 WS-FOUND-FLAG         PIC X(1).
 
01 WS-SORT-CONTROLS.
   05 WS-SORT-KEY           PIC X(1).
   05 WS-TEMP-PRODUCT.
      10 WS-TEMP-CODE       PIC X(8).
      10 WS-TEMP-NAME       PIC X(30).
      10 WS-TEMP-PRICE      PIC 9(6)V99.
      10 WS-TEMP-QUANTITY   PIC 9(5).
      10 WS-TEMP-CATEGORY   PIC X(15).
 
PROCEDURE DIVISION.
VARIABLE-SEARCH-SORT-DEMO.
    DISPLAY "=== Variable Table Search and Sort Demo ==="
    
    PERFORM LOAD-SAMPLE-PRODUCTS
    PERFORM DEMONSTRATE-SEARCH
    PERFORM DEMONSTRATE-SORT.
 
LOAD-SAMPLE-PRODUCTS.
    *> Load sample product data
    PERFORM ADD-PRODUCT-ITEM("PROD001", "Laptop Computer", 1299.99, 25, "Electronics")
    PERFORM ADD-PRODUCT-ITEM("PROD003", "Office Chair", 249.50, 50, "Furniture")
    PERFORM ADD-PRODUCT-ITEM("PROD002", "Wireless Mouse", 29.99, 100, "Electronics")
    PERFORM ADD-PRODUCT-ITEM("PROD005", "Desk Lamp", 45.00, 30, "Furniture")
    PERFORM ADD-PRODUCT-ITEM("PROD004", "Keyboard", 79.99, 75, "Electronics")
    
    DISPLAY "Loaded " WS-PRODUCT-COUNT " products into inventory".
 
ADD-PRODUCT-ITEM.
    *> This would be a called paragraph with parameters in real code
    *> For demo purposes, we'll add them directly
    CONTINUE.
 
DEMONSTRATE-SEARCH.
    DISPLAY " "
    DISPLAY "=== Search Demonstration ==="
    
    *> Search for specific product
    MOVE "PROD003" TO WS-SEARCH-CODE
    PERFORM SEARCH-PRODUCT
    
    IF WS-FOUND-FLAG = 'Y'
        DISPLAY "Found product: " WS-SEARCH-CODE
        DISPLAY "  Name: " WS-PROD-NAME(WS-SEARCH-RESULT)
        DISPLAY "  Price: $" WS-PROD-PRICE(WS-SEARCH-RESULT)
        DISPLAY "  Quantity: " WS-PROD-QUANTITY(WS-SEARCH-RESULT)
        DISPLAY "  Category: " WS-PROD-CATEGORY(WS-SEARCH-RESULT)
    ELSE
        DISPLAY "Product " WS-SEARCH-CODE " not found"
    END-IF
    
    *> Search for non-existent product
    MOVE "PROD999" TO WS-SEARCH-CODE
    PERFORM SEARCH-PRODUCT
    
    IF WS-FOUND-FLAG = 'Y'
        DISPLAY "Found product: " WS-SEARCH-CODE
    ELSE
        DISPLAY "Product " WS-SEARCH-CODE " not found (as expected)"
    END-IF.
 
SEARCH-PRODUCT.
    MOVE 'N' TO WS-FOUND-FLAG
    SET PROD-INDEX TO 1
    
    SEARCH WS-PRODUCT-ITEM
        AT END
            MOVE 'N' TO WS-FOUND-FLAG
        WHEN WS-PROD-CODE(PROD-INDEX) = WS-SEARCH-CODE
            MOVE PROD-INDEX TO WS-SEARCH-RESULT
            MOVE 'Y' TO WS-FOUND-FLAG
    END-SEARCH.
 
DEMONSTRATE-SORT.
    DISPLAY " "
    DISPLAY "=== Sort Demonstration ==="
    
    DISPLAY "Products before sorting by price:"
    PERFORM DISPLAY-PRODUCT-LIST
    
    PERFORM SORT-BY-PRICE
    
    DISPLAY " "
    DISPLAY "Products after sorting by price (ascending):"
    PERFORM DISPLAY-PRODUCT-LIST.
 
DISPLAY-PRODUCT-LIST.
    DISPLAY "Code     Name                           Price    Qty Category"
    DISPLAY "-------- ------------------------------ -------- --- ---------------"
    
    PERFORM VARYING WS-SEARCH-RESULT FROM 1 BY 1
            UNTIL WS-SEARCH-RESULT > WS-PRODUCT-COUNT
        DISPLAY WS-PROD-CODE(WS-SEARCH-RESULT) " "
                WS-PROD-NAME(WS-SEARCH-RESULT) " "
                WS-PROD-PRICE(WS-SEARCH-RESULT) " "
                WS-PROD-QUANTITY(WS-SEARCH-RESULT) " "
                WS-PROD-CATEGORY(WS-SEARCH-RESULT)
    END-PERFORM.
 
SORT-BY-PRICE.
    *> Simple bubble sort by price
    PERFORM VARYING WS-SEARCH-RESULT FROM 1 BY 1
            UNTIL WS-SEARCH-RESULT >= WS-PRODUCT-COUNT
        
        PERFORM VARYING WS-FOUND-FLAG FROM WS-SEARCH-RESULT BY 1
                UNTIL WS-FOUND-FLAG > WS-PRODUCT-COUNT
            
            IF WS-PROD-PRICE(WS-SEARCH-RESULT) > WS-PROD-PRICE(WS-FOUND-FLAG)
                *> Swap products
                MOVE WS-PRODUCT-ITEM(WS-SEARCH-RESULT) TO WS-TEMP-PRODUCT
                MOVE WS-PRODUCT-ITEM(WS-FOUND-FLAG) TO WS-PRODUCT-ITEM(WS-SEARCH-RESULT)
                MOVE WS-TEMP-PRODUCT TO WS-PRODUCT-ITEM(WS-FOUND-FLAG)
            END-IF
        END-PERFORM
    END-PERFORM.

File Processing with DEPENDING ON

Variable-Length Records

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
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
    SELECT VARIABLE-FILE ASSIGN TO "VARDATA.DAT"
        ORGANIZATION IS SEQUENTIAL
        FILE STATUS IS FILE-STATUS-VAR.
 
DATA DIVISION.
FILE SECTION.
FD VARIABLE-FILE
   RECORD IS VARYING IN SIZE FROM 50 TO 500 CHARACTERS
   DEPENDING ON RECORD-LENGTH.
01 VARIABLE-RECORD.
   05 REC-TYPE              PIC X(2).
   05 REC-LENGTH            PIC 9(3).
   05 REC-DATA              PIC X(495).
 
WORKING-STORAGE SECTION.
01 FILE-STATUS-VAR          PIC X(2).
01 WS-RECORD-PROCESSING.
   05 WS-RECORDS-READ       PIC 9(5) VALUE 0.
   05 WS-TOTAL-BYTES        PIC 9(8) VALUE 0.
   05 WS-EOF-FLAG           PIC X(1) VALUE 'N'.
 
*> Variable-length data structures
01 WS-CUSTOMER-RECORD.
   05 WS-CUST-HEADER.
      10 WS-CUST-ID         PIC X(8).
      10 WS-CUST-NAME       PIC X(30).
      10 WS-ORDER-COUNT     PIC 9(3).
   05 WS-ORDER-LIST         OCCURS 0 TO 50 TIMES
                            DEPENDING ON WS-ORDER-COUNT.
      10 WS-ORDER-ID        PIC X(10).
      10 WS-ORDER-DATE      PIC X(8).
      10 WS-ORDER-AMOUNT    PIC 9(8)V99.
 
01 WS-PRODUCT-RECORD.
   05 WS-PROD-HEADER.
      10 WS-PROD-ID         PIC X(8).
      10 WS-PROD-NAME       PIC X(40).
      10 WS-FEATURE-COUNT   PIC 9(2).
   05 WS-FEATURE-LIST       OCCURS 0 TO 20 TIMES
                            DEPENDING ON WS-FEATURE-COUNT.
      10 WS-FEATURE-NAME    PIC X(25).
      10 WS-FEATURE-VALUE   PIC X(50).
 
PROCEDURE DIVISION.
VARIABLE-FILE-DEMO.
    DISPLAY "=== Variable-Length File Processing ==="
    
    OPEN INPUT VARIABLE-FILE
    
    PERFORM READ-AND-PROCESS UNTIL WS-EOF-FLAG = 'Y'
    
    CLOSE VARIABLE-FILE
    
    PERFORM DISPLAY-PROCESSING-SUMMARY.
 
READ-AND-PROCESS.
    READ VARIABLE-FILE
        AT END
            MOVE 'Y' TO WS-EOF-FLAG
        NOT AT END
            ADD 1 TO WS-RECORDS-READ
            ADD RECORD-LENGTH TO WS-TOTAL-BYTES
            PERFORM PROCESS-VARIABLE-RECORD
    END-READ.
 
PROCESS-VARIABLE-RECORD.
    EVALUATE REC-TYPE
        WHEN "CU"  *> Customer record
            PERFORM PROCESS-CUSTOMER-RECORD
        WHEN "PR"  *> Product record
            PERFORM PROCESS-PRODUCT-RECORD
        WHEN OTHER
            DISPLAY "Unknown record type: " REC-TYPE
    END-EVALUATE.
 
PROCESS-CUSTOMER-RECORD.
    *> Move variable record data to structured format
    UNSTRING REC-DATA DELIMITED BY "|"
        INTO WS-CUST-ID, WS-CUST-NAME, WS-ORDER-COUNT
    END-UNSTRING
    
    DISPLAY "Customer: " WS-CUST-ID " - " WS-CUST-NAME
    DISPLAY "Orders: " WS-ORDER-COUNT
    
    *> Process each order (simplified for demo)
    IF WS-ORDER-COUNT > 0
        DISPLAY "  Processing " WS-ORDER-COUNT " orders..."
        *> In real application, would parse order details
    END-IF.
 
PROCESS-PRODUCT-RECORD.
    *> Move variable record data to structured format
    UNSTRING REC-DATA DELIMITED BY "|"
        INTO WS-PROD-ID, WS-PROD-NAME, WS-FEATURE-COUNT
    END-UNSTRING
    
    DISPLAY "Product: " WS-PROD-ID " - " WS-PROD-NAME
    DISPLAY "Features: " WS-FEATURE-COUNT
    
    *> Process each feature (simplified for demo)
    IF WS-FEATURE-COUNT > 0
        DISPLAY "  Processing " WS-FEATURE-COUNT " features..."
        *> In real application, would parse feature details
    END-IF.
 
DISPLAY-PROCESSING-SUMMARY.
    DISPLAY " "
    DISPLAY "Processing Summary:"
    DISPLAY "Records read: " WS-RECORDS-READ
    DISPLAY "Total bytes processed: " WS-TOTAL-BYTES
    
    IF WS-RECORDS-READ > 0
        COMPUTE WS-AVERAGE-SIZE = WS-TOTAL-BYTES / WS-RECORDS-READ
        DISPLAY "Average record size: " WS-AVERAGE-SIZE " bytes"
    END-IF.

Best Practices and Guidelines

DEPENDING ON Best Practices

  • Always validate that the control field value is within the defined min-max range
  • Initialize the control field before using the variable table
  • Use meaningful minimum values (0 or 1) based on your business logic
  • Be careful when modifying the control field during processing
  • Consider memory implications when setting maximum values
  • Use appropriate data types for control fields to prevent overflow
  • Document the relationship between control fields and table sizes

Common DEPENDING ON Patterns

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
*> Basic variable table pattern
01 table-data.
   05 item-count            PIC 9(3) VALUE 0.
   05 table-item            OCCURS 0 TO 100 TIMES
                            DEPENDING ON item-count.
      10 item-field         PIC X(20).
 
*> Adding items pattern
IF item-count < 100
    ADD 1 TO item-count
    MOVE new-value TO item-field(item-count)
ELSE
    DISPLAY "Table is full"
END-IF
 
*> Processing all items pattern
PERFORM VARYING index FROM 1 BY 1
        UNTIL index > item-count
    PERFORM process-item
END-PERFORM
 
*> Removing last item pattern
IF item-count > 0
    SUBTRACT 1 FROM item-count
ELSE
    DISPLAY "Table is empty"
END-IF

Related Concepts

Table Handling

Complete guide to table operations and array processing

Dynamic Data Structures

Working with variable-length and flexible data structures

Memory Management

Understanding memory allocation and variable-length records

Data Organization

Organizing and structuring complex data efficiently

Frequently Asked Questions