MainframeMaster

COBOL Tutorial

COBOL DELIMITER

The DELIMITER clause in COBOL is used to capture the actual delimiter characters encountered during string parsing operations, providing detailed information about how data was separated.

DELIMITER Syntax

The DELIMITER IN clause is used with UNSTRING to capture the delimiter characters that were found during parsing.

cobol
1
2
3
4
5
6
7
8
UNSTRING source-string
    DELIMITED BY delimiter-1 [OR delimiter-2 OR delimiter-3...]
    INTO receiving-field-1, receiving-field-2, receiving-field-3
    DELIMITER IN delimiter-field-1, delimiter-field-2, delimiter-field-3
    [TALLYING IN count-field]
    [WITH POINTER pointer-field]
    [ON OVERFLOW imperative-statement]
END-UNSTRING

Basic DELIMITER Capture

Single Delimiter Capture

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
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-INPUT-DATA            PIC X(100).
01 WS-PARSED-FIELDS.
   05 WS-FIELD-1            PIC X(20).
   05 WS-FIELD-2            PIC X(20).
   05 WS-FIELD-3            PIC X(20).
   05 WS-FIELD-4            PIC X(20).
 
01 WS-DELIMITER-FIELDS.
   05 WS-DELIM-1            PIC X(5).
   05 WS-DELIM-2            PIC X(5).
   05 WS-DELIM-3            PIC X(5).
   05 WS-DELIM-4            PIC X(5).
 
01 WS-COUNTERS.
   05 WS-FIELD-COUNT        PIC 9(2).
 
PROCEDURE DIVISION.
SINGLE-DELIMITER-DEMO.
    DISPLAY "=== Single Delimiter Capture ==="
    
    *> Example with comma delimiter
    MOVE "Apple,Orange,Banana,Grape" TO WS-INPUT-DATA
    
    UNSTRING WS-INPUT-DATA
        DELIMITED BY ","
        INTO WS-FIELD-1, WS-FIELD-2, WS-FIELD-3, WS-FIELD-4
        DELIMITER IN WS-DELIM-1, WS-DELIM-2, WS-DELIM-3, WS-DELIM-4
        TALLYING IN WS-FIELD-COUNT
    END-UNSTRING
    
    DISPLAY "Input: '" WS-INPUT-DATA "'"
    DISPLAY "Results:"
    
    PERFORM VARYING WS-INDEX FROM 1 BY 1
            UNTIL WS-INDEX > WS-FIELD-COUNT
        EVALUATE WS-INDEX
            WHEN 1
                DISPLAY "Field 1: '" WS-FIELD-1 "'"
                DISPLAY "Delimiter 1: '" WS-DELIM-1 "'"
            WHEN 2
                DISPLAY "Field 2: '" WS-FIELD-2 "'"
                DISPLAY "Delimiter 2: '" WS-DELIM-2 "'"
            WHEN 3
                DISPLAY "Field 3: '" WS-FIELD-3 "'"
                DISPLAY "Delimiter 3: '" WS-DELIM-3 "'"
            WHEN 4
                DISPLAY "Field 4: '" WS-FIELD-4 "'"
                DISPLAY "Delimiter 4: '" WS-DELIM-4 "'"
        END-EVALUATE
    END-PERFORM
    
    DISPLAY "Total fields parsed: " WS-FIELD-COUNT.

Multiple Delimiter Capture

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
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-MIXED-INPUT           PIC X(200).
01 WS-EXTRACTED-DATA.
   05 WS-DATA-ITEM          OCCURS 8 TIMES PIC X(25).
01 WS-CAPTURED-DELIMITERS.
   05 WS-DELIMITER-FOUND    OCCURS 8 TIMES PIC X(5).
 
01 WS-PROCESSING-INFO.
   05 WS-ITEM-COUNT         PIC 9(2).
   05 WS-DELIMITER-STATS.
      10 WS-COMMA-COUNT     PIC 9(2) VALUE 0.
      10 WS-SEMICOLON-COUNT PIC 9(2) VALUE 0.
      10 WS-PIPE-COUNT      PIC 9(2) VALUE 0.
      10 WS-SPACE-COUNT     PIC 9(2) VALUE 0.
 
PROCEDURE DIVISION.
MULTIPLE-DELIMITER-DEMO.
    DISPLAY "=== Multiple Delimiter Capture ==="
    
    *> Example with mixed delimiters
    MOVE "Apple,Orange;Banana|Grape Cherry,Mango;Peach|Kiwi" TO WS-MIXED-INPUT
    
    UNSTRING WS-MIXED-INPUT
        DELIMITED BY "," OR ";" OR "|" OR SPACE
        INTO WS-DATA-ITEM(1), WS-DATA-ITEM(2), WS-DATA-ITEM(3),
             WS-DATA-ITEM(4), WS-DATA-ITEM(5), WS-DATA-ITEM(6),
             WS-DATA-ITEM(7), WS-DATA-ITEM(8)
        DELIMITER IN WS-DELIMITER-FOUND(1), WS-DELIMITER-FOUND(2),
                     WS-DELIMITER-FOUND(3), WS-DELIMITER-FOUND(4),
                     WS-DELIMITER-FOUND(5), WS-DELIMITER-FOUND(6),
                     WS-DELIMITER-FOUND(7), WS-DELIMITER-FOUND(8)
        TALLYING IN WS-ITEM-COUNT
    END-UNSTRING
    
    DISPLAY "Input: '" WS-MIXED-INPUT "'"
    DISPLAY " "
    DISPLAY "Parsing Results:"
    
    PERFORM VARYING WS-INDEX FROM 1 BY 1
            UNTIL WS-INDEX > WS-ITEM-COUNT
        DISPLAY "Item " WS-INDEX ": '" WS-DATA-ITEM(WS-INDEX) "'"
        IF WS-INDEX < WS-ITEM-COUNT
            DISPLAY "  Delimiter: '" WS-DELIMITER-FOUND(WS-INDEX) "'"
            PERFORM COUNT-DELIMITER-TYPES
        END-IF
    END-PERFORM
    
    PERFORM DISPLAY-DELIMITER-STATISTICS.
 
COUNT-DELIMITER-TYPES.
    EVALUATE WS-DELIMITER-FOUND(WS-INDEX)
        WHEN ","
            ADD 1 TO WS-COMMA-COUNT
        WHEN ";"
            ADD 1 TO WS-SEMICOLON-COUNT
        WHEN "|"
            ADD 1 TO WS-PIPE-COUNT
        WHEN " "
            ADD 1 TO WS-SPACE-COUNT
    END-EVALUATE.
 
DISPLAY-DELIMITER-STATISTICS.
    DISPLAY " "
    DISPLAY "Delimiter Statistics:"
    DISPLAY "Commas found: " WS-COMMA-COUNT
    DISPLAY "Semicolons found: " WS-SEMICOLON-COUNT
    DISPLAY "Pipes found: " WS-PIPE-COUNT
    DISPLAY "Spaces found: " WS-SPACE-COUNT
    DISPLAY "Total items: " WS-ITEM-COUNT.

Advanced DELIMITER Processing

Multi-Character Delimiters

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
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-COMPLEX-INPUT         PIC X(300).
01 WS-PARSED-SEGMENTS.
   05 WS-SEGMENT            OCCURS 6 TIMES PIC X(40).
01 WS-MULTI-DELIMITERS.
   05 WS-FOUND-DELIMITER    OCCURS 6 TIMES PIC X(10).
 
01 WS-SEGMENT-INFO.
   05 WS-SEGMENT-COUNT      PIC 9(1).
   05 WS-DELIMITER-TYPES.
      10 WS-DOUBLE-PIPE     PIC 9(1) VALUE 0.
      10 WS-ARROW           PIC 9(1) VALUE 0.
      10 WS-DOUBLE-DASH     PIC 9(1) VALUE 0.
 
PROCEDURE DIVISION.
MULTI-CHAR-DELIMITER-DEMO.
    DISPLAY "=== Multi-Character Delimiter Demo ==="
    
    *> Example with multi-character delimiters
    MOVE "Section1||Section2->Section3--Section4||Section5->Section6"
         TO WS-COMPLEX-INPUT
    
    UNSTRING WS-COMPLEX-INPUT
        DELIMITED BY "||" OR "->" OR "--"
        INTO WS-SEGMENT(1), WS-SEGMENT(2), WS-SEGMENT(3),
             WS-SEGMENT(4), WS-SEGMENT(5), WS-SEGMENT(6)
        DELIMITER IN WS-FOUND-DELIMITER(1), WS-FOUND-DELIMITER(2),
                     WS-FOUND-DELIMITER(3), WS-FOUND-DELIMITER(4),
                     WS-FOUND-DELIMITER(5), WS-FOUND-DELIMITER(6)
        TALLYING IN WS-SEGMENT-COUNT
    END-UNSTRING
    
    DISPLAY "Input: '" WS-COMPLEX-INPUT "'"
    DISPLAY " "
    DISPLAY "Multi-Character Delimiter Results:"
    
    PERFORM VARYING WS-INDEX FROM 1 BY 1
            UNTIL WS-INDEX > WS-SEGMENT-COUNT
        DISPLAY "Segment " WS-INDEX ": '" WS-SEGMENT(WS-INDEX) "'"
        IF WS-INDEX < WS-SEGMENT-COUNT
            DISPLAY "  Delimiter: '" WS-FOUND-DELIMITER(WS-INDEX) "'"
            PERFORM ANALYZE-MULTI-DELIMITER
        END-IF
    END-PERFORM
    
    PERFORM DISPLAY-MULTI-DELIMITER-ANALYSIS.
 
ANALYZE-MULTI-DELIMITER.
    EVALUATE WS-FOUND-DELIMITER(WS-INDEX)
        WHEN "||"
            ADD 1 TO WS-DOUBLE-PIPE
            DISPLAY "    Type: Double Pipe"
        WHEN "->"
            ADD 1 TO WS-ARROW
            DISPLAY "    Type: Arrow"
        WHEN "--"
            ADD 1 TO WS-DOUBLE-DASH
            DISPLAY "    Type: Double Dash"
        WHEN OTHER
            DISPLAY "    Type: Unknown"
    END-EVALUATE.
 
DISPLAY-MULTI-DELIMITER-ANALYSIS.
    DISPLAY " "
    DISPLAY "Multi-Character Delimiter Analysis:"
    DISPLAY "Double Pipes (||): " WS-DOUBLE-PIPE
    DISPLAY "Arrows (->): " WS-ARROW
    DISPLAY "Double Dashes (--): " WS-DOUBLE-DASH
    DISPLAY "Total segments: " WS-SEGMENT-COUNT.

Delimiter Validation and Processing

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
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-VALIDATION-INPUT      PIC X(400).
01 WS-VALIDATED-FIELDS.
   05 WS-VALID-FIELD        OCCURS 12 TIMES PIC X(30).
01 WS-VALIDATION-DELIMITERS.
   05 WS-VALID-DELIMITER    OCCURS 12 TIMES PIC X(5).
 
01 WS-VALIDATION-CONTROLS.
   05 WS-VALID-COUNT        PIC 9(2).
   05 WS-EXPECTED-DELIMITER PIC X(1) VALUE ",".
   05 WS-VALIDATION-ERRORS  PIC 9(2) VALUE 0.
   05 WS-ERROR-MESSAGES     OCCURS 10 TIMES PIC X(80).
 
01 WS-VALIDATION-STATS.
   05 WS-CORRECT-DELIMITERS PIC 9(2) VALUE 0.
   05 WS-WRONG-DELIMITERS   PIC 9(2) VALUE 0.
   05 WS-MISSING-DELIMITERS PIC 9(2) VALUE 0.
 
PROCEDURE DIVISION.
DELIMITER-VALIDATION-DEMO.
    DISPLAY "=== Delimiter Validation Demo ==="
    
    *> Example with mixed correct and incorrect delimiters
    MOVE "Field1,Field2;Field3,Field4|Field5,Field6,Field7;Field8"
         TO WS-VALIDATION-INPUT
    
    PERFORM PARSE-AND-VALIDATE
    PERFORM DISPLAY-VALIDATION-RESULTS.
 
PARSE-AND-VALIDATE.
    UNSTRING WS-VALIDATION-INPUT
        DELIMITED BY "," OR ";" OR "|"
        INTO WS-VALID-FIELD(1), WS-VALID-FIELD(2), WS-VALID-FIELD(3),
             WS-VALID-FIELD(4), WS-VALID-FIELD(5), WS-VALID-FIELD(6),
             WS-VALID-FIELD(7), WS-VALID-FIELD(8), WS-VALID-FIELD(9),
             WS-VALID-FIELD(10), WS-VALID-FIELD(11), WS-VALID-FIELD(12)
        DELIMITER IN WS-VALID-DELIMITER(1), WS-VALID-DELIMITER(2),
                     WS-VALID-DELIMITER(3), WS-VALID-DELIMITER(4),
                     WS-VALID-DELIMITER(5), WS-VALID-DELIMITER(6),
                     WS-VALID-DELIMITER(7), WS-VALID-DELIMITER(8),
                     WS-VALID-DELIMITER(9), WS-VALID-DELIMITER(10),
                     WS-VALID-DELIMITER(11), WS-VALID-DELIMITER(12)
        TALLYING IN WS-VALID-COUNT
    END-UNSTRING
    
    PERFORM VALIDATE-DELIMITERS.
 
VALIDATE-DELIMITERS.
    MOVE 0 TO WS-VALIDATION-ERRORS
    
    PERFORM VARYING WS-INDEX FROM 1 BY 1
            UNTIL WS-INDEX >= WS-VALID-COUNT
        
        IF WS-VALID-DELIMITER(WS-INDEX) = WS-EXPECTED-DELIMITER
            ADD 1 TO WS-CORRECT-DELIMITERS
        ELSE IF WS-VALID-DELIMITER(WS-INDEX) = SPACES
            ADD 1 TO WS-MISSING-DELIMITERS
            ADD 1 TO WS-VALIDATION-ERRORS
            STRING "Missing delimiter after field " DELIMITED BY SIZE
                   WS-INDEX DELIMITED BY SIZE
                   INTO WS-ERROR-MESSAGES(WS-VALIDATION-ERRORS)
            END-STRING
        ELSE
            ADD 1 TO WS-WRONG-DELIMITERS
            ADD 1 TO WS-VALIDATION-ERRORS
            STRING "Wrong delimiter '" DELIMITED BY SIZE
                   WS-VALID-DELIMITER(WS-INDEX) DELIMITED BY SPACE
                   "' after field " DELIMITED BY SIZE
                   WS-INDEX DELIMITED BY SIZE
                   " (expected '" DELIMITED BY SIZE
                   WS-EXPECTED-DELIMITER DELIMITED BY SIZE
                   "')" DELIMITED BY SIZE
                   INTO WS-ERROR-MESSAGES(WS-VALIDATION-ERRORS)
            END-STRING
        END-IF
    END-PERFORM.
 
DISPLAY-VALIDATION-RESULTS.
    DISPLAY "Input: '" WS-VALIDATION-INPUT "'"
    DISPLAY "Expected delimiter: '" WS-EXPECTED-DELIMITER "'"
    DISPLAY " "
    
    DISPLAY "Parsed Fields and Delimiters:"
    PERFORM VARYING WS-INDEX FROM 1 BY 1
            UNTIL WS-INDEX > WS-VALID-COUNT
        DISPLAY "Field " WS-INDEX ": '" WS-VALID-FIELD(WS-INDEX) "'"
        IF WS-INDEX < WS-VALID-COUNT
            IF WS-VALID-DELIMITER(WS-INDEX) = WS-EXPECTED-DELIMITER
                DISPLAY "  Delimiter: '" WS-VALID-DELIMITER(WS-INDEX) "' (CORRECT)"
            ELSE IF WS-VALID-DELIMITER(WS-INDEX) = SPACES
                DISPLAY "  Delimiter: (MISSING)"
            ELSE
                DISPLAY "  Delimiter: '" WS-VALID-DELIMITER(WS-INDEX) "' (WRONG)"
            END-IF
        END-IF
    END-PERFORM
    
    DISPLAY " "
    DISPLAY "Validation Summary:"
    DISPLAY "Correct delimiters: " WS-CORRECT-DELIMITERS
    DISPLAY "Wrong delimiters: " WS-WRONG-DELIMITERS
    DISPLAY "Missing delimiters: " WS-MISSING-DELIMITERS
    DISPLAY "Total validation errors: " WS-VALIDATION-ERRORS
    
    IF WS-VALIDATION-ERRORS > 0
        DISPLAY " "
        DISPLAY "Error Details:"
        PERFORM VARYING WS-INDEX FROM 1 BY 1
                UNTIL WS-INDEX > WS-VALIDATION-ERRORS
            DISPLAY "  " WS-ERROR-MESSAGES(WS-INDEX)
        END-PERFORM
    END-IF.

Practical DELIMITER Applications

CSV Processing with Delimiter Analysis

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
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-CSV-RECORD            PIC X(500).
01 WS-CSV-FIELDS.
   05 WS-FIELD-DATA         OCCURS 15 TIMES PIC X(50).
01 WS-CSV-DELIMITERS.
   05 WS-FIELD-DELIMITER    OCCURS 15 TIMES PIC X(3).
 
01 WS-CSV-PROCESSING.
   05 WS-RECORD-NUMBER      PIC 9(5) VALUE 0.
   05 WS-FIELD-COUNT        PIC 9(2).
   05 WS-EXPECTED-FIELDS    PIC 9(2) VALUE 5.
   05 WS-DELIMITER-ISSUES   PIC 9(3) VALUE 0.
 
01 WS-DELIMITER-ANALYSIS.
   05 WS-COMMA-DELIMITERS   PIC 9(2) VALUE 0.
   05 WS-SEMICOLON-DELIMS   PIC 9(2) VALUE 0.
   05 WS-TAB-DELIMITERS     PIC 9(2) VALUE 0.
   05 WS-OTHER-DELIMITERS   PIC 9(2) VALUE 0.
 
PROCEDURE DIVISION.
CSV-DELIMITER-ANALYSIS.
    DISPLAY "=== CSV Delimiter Analysis ==="
    
    *> Simulate processing multiple CSV records
    PERFORM PROCESS-CSV-RECORD-1
    PERFORM PROCESS-CSV-RECORD-2
    PERFORM PROCESS-CSV-RECORD-3
    
    PERFORM DISPLAY-OVERALL-ANALYSIS.
 
PROCESS-CSV-RECORD-1.
    ADD 1 TO WS-RECORD-NUMBER
    MOVE "John,Doe,30,Engineer,New York" TO WS-CSV-RECORD
    PERFORM ANALYZE-CSV-RECORD.
 
PROCESS-CSV-RECORD-2.
    ADD 1 TO WS-RECORD-NUMBER
    MOVE "Jane;Smith;25;Designer;Los Angeles" TO WS-CSV-RECORD
    PERFORM ANALYZE-CSV-RECORD.
 
PROCESS-CSV-RECORD-3.
    ADD 1 TO WS-RECORD-NUMBER
    STRING "Bob" DELIMITED BY SIZE
           X"09" DELIMITED BY SIZE  *> Tab character
           "Johnson" DELIMITED BY SIZE
           X"09" DELIMITED BY SIZE
           "35" DELIMITED BY SIZE
           X"09" DELIMITED BY SIZE
           "Manager" DELIMITED BY SIZE
           X"09" DELIMITED BY SIZE
           "Chicago" DELIMITED BY SIZE
           INTO WS-CSV-RECORD
    END-STRING
    PERFORM ANALYZE-CSV-RECORD.
 
ANALYZE-CSV-RECORD.
    INITIALIZE WS-CSV-FIELDS
    INITIALIZE WS-CSV-DELIMITERS
    
    UNSTRING WS-CSV-RECORD
        DELIMITED BY "," OR ";" OR X"09"  *> Tab
        INTO WS-FIELD-DATA(1), WS-FIELD-DATA(2), WS-FIELD-DATA(3),
             WS-FIELD-DATA(4), WS-FIELD-DATA(5), WS-FIELD-DATA(6),
             WS-FIELD-DATA(7), WS-FIELD-DATA(8), WS-FIELD-DATA(9),
             WS-FIELD-DATA(10)
        DELIMITER IN WS-FIELD-DELIMITER(1), WS-FIELD-DELIMITER(2),
                     WS-FIELD-DELIMITER(3), WS-FIELD-DELIMITER(4),
                     WS-FIELD-DELIMITER(5), WS-FIELD-DELIMITER(6),
                     WS-FIELD-DELIMITER(7), WS-FIELD-DELIMITER(8),
                     WS-FIELD-DELIMITER(9), WS-FIELD-DELIMITER(10)
        TALLYING IN WS-FIELD-COUNT
    END-UNSTRING
    
    PERFORM ANALYZE-RECORD-DELIMITERS
    PERFORM DISPLAY-RECORD-ANALYSIS.
 
ANALYZE-RECORD-DELIMITERS.
    PERFORM VARYING WS-INDEX FROM 1 BY 1
            UNTIL WS-INDEX >= WS-FIELD-COUNT
        
        EVALUATE WS-FIELD-DELIMITER(WS-INDEX)
            WHEN ","
                ADD 1 TO WS-COMMA-DELIMITERS
            WHEN ";"
                ADD 1 TO WS-SEMICOLON-DELIMS
            WHEN X"09"
                ADD 1 TO WS-TAB-DELIMITERS
            WHEN OTHER
                ADD 1 TO WS-OTHER-DELIMITERS
        END-EVALUATE
    END-PERFORM
    
    *> Check for field count issues
    IF WS-FIELD-COUNT NOT = WS-EXPECTED-FIELDS
        ADD 1 TO WS-DELIMITER-ISSUES
    END-IF.
 
DISPLAY-RECORD-ANALYSIS.
    DISPLAY " "
    DISPLAY "Record " WS-RECORD-NUMBER ":"
    DISPLAY "Data: '" WS-CSV-RECORD "'"
    DISPLAY "Fields found: " WS-FIELD-COUNT " (Expected: " WS-EXPECTED-FIELDS ")"
    
    PERFORM VARYING WS-INDEX FROM 1 BY 1
            UNTIL WS-INDEX > WS-FIELD-COUNT
        DISPLAY "  Field " WS-INDEX ": '" WS-FIELD-DATA(WS-INDEX) "'"
        IF WS-INDEX < WS-FIELD-COUNT
            EVALUATE WS-FIELD-DELIMITER(WS-INDEX)
                WHEN ","
                    DISPLAY "    Delimiter: Comma"
                WHEN ";"
                    DISPLAY "    Delimiter: Semicolon"
                WHEN X"09"
                    DISPLAY "    Delimiter: Tab"
                WHEN OTHER
                    DISPLAY "    Delimiter: Other ('" WS-FIELD-DELIMITER(WS-INDEX) "')"
            END-EVALUATE
        END-IF
    END-PERFORM.
 
DISPLAY-OVERALL-ANALYSIS.
    DISPLAY " "
    DISPLAY "=== Overall Delimiter Analysis ==="
    DISPLAY "Records processed: " WS-RECORD-NUMBER
    DISPLAY "Records with field count issues: " WS-DELIMITER-ISSUES
    DISPLAY " "
    DISPLAY "Delimiter Usage Summary:"
    DISPLAY "Comma delimiters: " WS-COMMA-DELIMITERS
    DISPLAY "Semicolon delimiters: " WS-SEMICOLON-DELIMS
    DISPLAY "Tab delimiters: " WS-TAB-DELIMITERS
    DISPLAY "Other delimiters: " WS-OTHER-DELIMITERS.

Delimiter-Based Data Reconstruction

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
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-ORIGINAL-DATA         PIC X(300).
01 WS-RECONSTRUCTED-DATA    PIC X(300).
 
01 WS-PARSED-COMPONENTS.
   05 WS-COMPONENT          OCCURS 10 TIMES PIC X(40).
01 WS-CAPTURED-DELIMITERS.
   05 WS-ORIGINAL-DELIMITER OCCURS 10 TIMES PIC X(5).
 
01 WS-RECONSTRUCTION-CONTROLS.
   05 WS-COMPONENT-COUNT    PIC 9(2).
   05 WS-OUTPUT-POINTER     PIC 9(3).
   05 WS-PRESERVE-ORIGINAL  PIC X(1) VALUE 'Y'.
 
PROCEDURE DIVISION.
DELIMITER-RECONSTRUCTION-DEMO.
    DISPLAY "=== Delimiter Reconstruction Demo ==="
    
    *> Original data with mixed delimiters
    MOVE "Part1||Part2->Part3--Part4||Part5->Part6"
         TO WS-ORIGINAL-DATA
    
    PERFORM PARSE-ORIGINAL-DATA
    PERFORM RECONSTRUCT-DATA
    PERFORM DISPLAY-RECONSTRUCTION-RESULTS.
 
PARSE-ORIGINAL-DATA.
    UNSTRING WS-ORIGINAL-DATA
        DELIMITED BY "||" OR "->" OR "--"
        INTO WS-COMPONENT(1), WS-COMPONENT(2), WS-COMPONENT(3),
             WS-COMPONENT(4), WS-COMPONENT(5), WS-COMPONENT(6),
             WS-COMPONENT(7), WS-COMPONENT(8), WS-COMPONENT(9),
             WS-COMPONENT(10)
        DELIMITER IN WS-ORIGINAL-DELIMITER(1), WS-ORIGINAL-DELIMITER(2),
                     WS-ORIGINAL-DELIMITER(3), WS-ORIGINAL-DELIMITER(4),
                     WS-ORIGINAL-DELIMITER(5), WS-ORIGINAL-DELIMITER(6),
                     WS-ORIGINAL-DELIMITER(7), WS-ORIGINAL-DELIMITER(8),
                     WS-ORIGINAL-DELIMITER(9), WS-ORIGINAL-DELIMITER(10)
        TALLYING IN WS-COMPONENT-COUNT
    END-UNSTRING.
 
RECONSTRUCT-DATA.
    MOVE SPACES TO WS-RECONSTRUCTED-DATA
    MOVE 1 TO WS-OUTPUT-POINTER
    
    PERFORM VARYING WS-INDEX FROM 1 BY 1
            UNTIL WS-INDEX > WS-COMPONENT-COUNT
        
        *> Add the component
        STRING WS-COMPONENT(WS-INDEX) DELIMITED BY SPACE
               INTO WS-RECONSTRUCTED-DATA
               WITH POINTER WS-OUTPUT-POINTER
        END-STRING
        
        *> Add the original delimiter if not the last component
        IF WS-INDEX < WS-COMPONENT-COUNT
            IF WS-PRESERVE-ORIGINAL = 'Y'
                STRING WS-ORIGINAL-DELIMITER(WS-INDEX) DELIMITED BY SPACE
                       INTO WS-RECONSTRUCTED-DATA
                       WITH POINTER WS-OUTPUT-POINTER
                END-STRING
            ELSE
                *> Use standardized delimiter
                STRING "," DELIMITED BY SIZE
                       INTO WS-RECONSTRUCTED-DATA
                       WITH POINTER WS-OUTPUT-POINTER
                END-STRING
            END-IF
        END-IF
    END-PERFORM.
 
DISPLAY-RECONSTRUCTION-RESULTS.
    DISPLAY "Original Data:"
    DISPLAY "'" WS-ORIGINAL-DATA "'"
    DISPLAY " "
    
    DISPLAY "Parsed Components and Delimiters:"
    PERFORM VARYING WS-INDEX FROM 1 BY 1
            UNTIL WS-INDEX > WS-COMPONENT-COUNT
        DISPLAY "Component " WS-INDEX ": '" WS-COMPONENT(WS-INDEX) "'"
        IF WS-INDEX < WS-COMPONENT-COUNT
            DISPLAY "  Original Delimiter: '" WS-ORIGINAL-DELIMITER(WS-INDEX) "'"
        END-IF
    END-PERFORM
    
    DISPLAY " "
    DISPLAY "Reconstructed Data:"
    DISPLAY "'" WS-RECONSTRUCTED-DATA "'"
    
    *> Demonstrate standardized reconstruction
    MOVE 'N' TO WS-PRESERVE-ORIGINAL
    PERFORM RECONSTRUCT-DATA
    DISPLAY " "
    DISPLAY "Standardized Reconstruction (commas only):"
    DISPLAY "'" WS-RECONSTRUCTED-DATA "'".

Best Practices and Guidelines

DELIMITER Best Practices

  • Always define delimiter fields large enough to hold multi-character delimiters
  • Initialize delimiter fields before UNSTRING operations
  • Check delimiter fields for validation and error detection
  • Use delimiter information for data quality analysis
  • Consider preserving original delimiters for data reconstruction
  • Handle edge cases where delimiters may be missing or unexpected
  • Document expected delimiter patterns for maintenance

Common DELIMITER 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
*> Basic delimiter capture
UNSTRING input-string
    DELIMITED BY "," OR ";" OR "|"
    INTO field-1, field-2, field-3
    DELIMITER IN delim-1, delim-2, delim-3
    TALLYING IN field-count
END-UNSTRING
 
*> Delimiter validation pattern
PERFORM VARYING index FROM 1 BY 1
        UNTIL index >= field-count
    IF delimiter-field(index) NOT = expected-delimiter
        PERFORM HANDLE-DELIMITER-ERROR
    END-IF
END-PERFORM
 
*> Delimiter preservation pattern
PERFORM VARYING index FROM 1 BY 1
        UNTIL index > field-count
    STRING data-field(index) DELIMITED BY SPACE
           original-delimiter(index) DELIMITED BY SPACE
           INTO reconstructed-string
           WITH POINTER string-pointer
    END-STRING
END-PERFORM

Related Concepts

String Processing

Complete guide to string manipulation and parsing techniques

Data Parsing

Methods for parsing and extracting data from formatted strings

Text Processing

Advanced text processing and manipulation strategies

Character Handling

Working with individual characters and character sets

Frequently Asked Questions