COBOL Tutorial

COBOL ALL Clause

The ALL clause represents one of COBOL's most versatile and powerful pattern matching mechanisms, serving as a universal qualifier that enables comprehensive string operations, character replacement, and pattern recognition across multiple COBOL statements. Far more than a simple literal qualifier, the ALL clause embodies COBOL's sophisticated approach to text processing by providing precise control over pattern matching, character manipulation, string transformation, and comprehensive text analysis that enable applications to handle complex string processing requirements while maintaining the efficiency and reliability characteristics that make COBOL ideal for enterprise text processing environments requiring advanced string manipulation capabilities.

In enterprise computing environments, the ALL clause serves as a critical foundation for advanced text processing, enabling developers to create sophisticated business applications that handle complex string manipulation requirements, pattern recognition tasks, data transformation workflows, and text validation processes. Its capabilities extend far beyond simple character replacement to encompass sophisticated pattern analysis, dynamic string generation, conditional text processing, and integration with modern data validation systems that are essential for applications requiring comprehensive text processing and string manipulation coordination capabilities.

ALL Clause Usage Patterns

ALL with INSPECT Statement

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
*> Replace all occurrences of a character
INSPECT INPUT-FIELD REPLACING ALL "A" BY "X".
 
*> Count all occurrences of a pattern
INSPECT INPUT-FIELD TALLYING WS-COUNT FOR ALL "ABC".
 
*> Replace all spaces with underscores
INSPECT INPUT-FIELD REPLACING ALL SPACES BY "_".
 
*> Complex pattern replacement
INSPECT INPUT-FIELD REPLACING 
    ALL "OLD" BY "NEW" 
    ALL "BAD" BY "GOOD".

ALL with INSPECT enables comprehensive character and pattern replacement operations.

ALL with STRING Statement

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
*> Fill field with repeating pattern
STRING ALL "*" DELIMITED BY SIZE INTO OUTPUT-FIELD.
 
*> Create separator line
STRING ALL "-" DELIMITED BY SIZE INTO SEPARATOR-LINE.
 
*> Fill with specific character
STRING ALL "X" DELIMITED BY SIZE INTO MASK-FIELD.
 
*> Create padding
STRING INPUT-DATA DELIMITED BY SPACE
       ALL " " DELIMITED BY SIZE
       INTO PADDED-FIELD.

ALL with STRING creates repeating patterns and fills fields with specific characters.

ALL with UNSTRING Statement

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
*> Use ALL to specify multiple delimiters
UNSTRING INPUT-STRING 
    DELIMITED BY ALL "," OR ALL ";" OR ALL ":"
    INTO FIELD-1, FIELD-2, FIELD-3.
 
*> Parse with whitespace delimiters
UNSTRING INPUT-STRING 
    DELIMITED BY ALL SPACES OR ALL LOW-VALUES
    INTO OUTPUT-FIELDS(1), OUTPUT-FIELDS(2).
 
*> Complex delimiter handling
UNSTRING COMPLEX-STRING
    DELIMITED BY ALL "||" OR ALL "::" 
    INTO PART-1, PART-2, PART-3
    WITH POINTER WS-POINTER.

ALL with UNSTRING handles multiple delimiter patterns for complex string parsing.

Comprehensive 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
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
IDENTIFICATION DIVISION.
PROGRAM-ID. ALL-CLAUSE-DEMO.
 
DATA DIVISION.
WORKING-STORAGE SECTION.
 
01  INPUT-DATA.
    05  CUSTOMER-NAME         PIC X(30) VALUE "JOHN A. SMITH".
    05  PHONE-NUMBER          PIC X(15) VALUE "123-456-7890".
    05  ADDRESS-LINE          PIC X(50) VALUE "123 MAIN ST, ANYTOWN, NY".
    05  COMMENT-FIELD         PIC X(100) VALUE "SPECIAL||CUSTOMER::HIGH||PRIORITY".
 
01  OUTPUT-FIELDS.
    05  FORMATTED-NAME        PIC X(30).
    05  CLEAN-PHONE           PIC X(15).
    05  MASKED-ADDRESS        PIC X(50).
    05  SEPARATOR-LINE        PIC X(50).
 
01  PARSING-FIELDS.
    05  COMMENT-PARTS OCCURS 10 TIMES PIC X(20).
    05  ADDRESS-PARTS OCCURS 5 TIMES PIC X(15).
 
01  COUNTERS.
    05  SPACE-COUNT           PIC 9(3) VALUE 0.
    05  DASH-COUNT            PIC 9(3) VALUE 0.
    05  VOWEL-COUNT           PIC 9(3) VALUE 0.
 
PROCEDURE DIVISION.
MAIN-PROCESSING.
    DISPLAY "=== ALL Clause Demonstration ===".
    DISPLAY " ".
    
    PERFORM DEMONSTRATE-INSPECT-ALL
    PERFORM DEMONSTRATE-STRING-ALL
    PERFORM DEMONSTRATE-UNSTRING-ALL
    PERFORM DEMONSTRATE-ADVANCED-PATTERNS
    
    DISPLAY " ".
    DISPLAY "ALL clause demonstration completed".
    STOP RUN.
 
DEMONSTRATE-INSPECT-ALL.
    DISPLAY "1. INSPECT with ALL Operations:".
    DISPLAY "   ============================".
    
    *> Count operations
    INSPECT CUSTOMER-NAME TALLYING SPACE-COUNT FOR ALL SPACES.
    DISPLAY "   Spaces in name: " SPACE-COUNT.
    
    INSPECT PHONE-NUMBER TALLYING DASH-COUNT FOR ALL "-".
    DISPLAY "   Dashes in phone: " DASH-COUNT.
    
    INSPECT CUSTOMER-NAME TALLYING VOWEL-COUNT 
        FOR ALL "A" ALL "E" ALL "I" ALL "O" ALL "U".
    DISPLAY "   Vowels in name: " VOWEL-COUNT.
    
    *> Character replacement
    MOVE CUSTOMER-NAME TO FORMATTED-NAME.
    INSPECT FORMATTED-NAME REPLACING ALL "." BY " ".
    INSPECT FORMATTED-NAME REPLACING ALL "  " BY " ".
    DISPLAY "   Original name: " CUSTOMER-NAME.
    DISPLAY "   Formatted name: " FORMATTED-NAME.
    
    *> Phone number cleaning
    MOVE PHONE-NUMBER TO CLEAN-PHONE.
    INSPECT CLEAN-PHONE REPLACING ALL "-" BY " ".
    DISPLAY "   Original phone: " PHONE-NUMBER.
    DISPLAY "   Clean phone: " CLEAN-PHONE.
    
    DISPLAY " ".
 
DEMONSTRATE-STRING-ALL.
    DISPLAY "2. STRING with ALL Operations:".
    DISPLAY "   ============================".
    
    *> Create separator line
    STRING ALL "=" DELIMITED BY SIZE INTO SEPARATOR-LINE.
    DISPLAY "   Separator: " SEPARATOR-LINE.
    
    *> Create masked address
    MOVE SPACES TO MASKED-ADDRESS.
    STRING ALL "*" DELIMITED BY SIZE INTO MASKED-ADDRESS.
    DISPLAY "   Masked field: " MASKED-ADDRESS(1:20) "...".
    
    *> Pattern creation
    MOVE SPACES TO FORMATTED-NAME.
    STRING ">>>" DELIMITED BY SIZE
           ALL "-" DELIMITED BY SIZE
           "<<<" DELIMITED BY SIZE
           INTO FORMATTED-NAME.
    DISPLAY "   Pattern: " FORMATTED-NAME(1:25).
    
    DISPLAY " ".
 
DEMONSTRATE-UNSTRING-ALL.
    DISPLAY "3. UNSTRING with ALL Delimiters:".
    DISPLAY "   ==============================".
    
    *> Parse comment field with multiple delimiters
    UNSTRING COMMENT-FIELD 
        DELIMITED BY ALL "::" OR ALL "||"
        INTO COMMENT-PARTS(1), COMMENT-PARTS(2), 
             COMMENT-PARTS(3), COMMENT-PARTS(4).
    
    DISPLAY "   Original comment: " COMMENT-FIELD(1:40) "...".
    DISPLAY "   Part 1: " COMMENT-PARTS(1).
    DISPLAY "   Part 2: " COMMENT-PARTS(2).
    DISPLAY "   Part 3: " COMMENT-PARTS(3).
    DISPLAY "   Part 4: " COMMENT-PARTS(4).
    
    *> Parse address with comma delimiter
    UNSTRING ADDRESS-LINE
        DELIMITED BY ALL ", "
        INTO ADDRESS-PARTS(1), ADDRESS-PARTS(2), ADDRESS-PARTS(3).
    
    DISPLAY "   Original address: " ADDRESS-LINE.
    DISPLAY "   Street: " ADDRESS-PARTS(1).
    DISPLAY "   City: " ADDRESS-PARTS(2).
    DISPLAY "   State: " ADDRESS-PARTS(3).
    
    DISPLAY " ".
 
DEMONSTRATE-ADVANCED-PATTERNS.
    DISPLAY "4. Advanced ALL Patterns:".
    DISPLAY "   =======================".
    
    *> Complex text processing
    MOVE "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG" TO FORMATTED-NAME.
    
    *> Replace multiple patterns
    INSPECT FORMATTED-NAME REPLACING 
        ALL "THE" BY "***"
        ALL "FOX" BY "CAT"
        ALL "DOG" BY "MOUSE".
    
    DISPLAY "   Processed text: " FORMATTED-NAME.
    
    *> Create formatted output
    MOVE SPACES TO MASKED-ADDRESS.
    STRING "DATA: " DELIMITED BY SIZE
           ALL "X" DELIMITED BY SIZE
           " :END" DELIMITED BY SIZE
           INTO MASKED-ADDRESS.
    
    DISPLAY "   Formatted output: " MASKED-ADDRESS(1:30).
    
    DISPLAY " ".

Best Practices and Guidelines

Recommended Practices

Use ALL for comprehensive pattern matching and replacement
Combine ALL with INSPECT for efficient character operations
Leverage ALL in STRING for creating repeating patterns
Apply ALL with UNSTRING for flexible delimiter handling
Test ALL operations with various input data patterns
Document the purpose of ALL operations in complex logic
Use meaningful variable names for pattern operations
Consider performance implications of extensive ALL usage

Common Pitfalls

Overlooking case sensitivity in ALL pattern matching
Not considering overlapping patterns in replacements
Inadequate testing with edge cases and empty fields
Poor performance from excessive ALL operations on large strings
Incorrect delimiter specification in UNSTRING operations
Not handling the order of multiple ALL replacements
Forgetting to initialize counters before tallying operations
Missing validation of pattern matching results

Related COBOL Concepts

INSPECT - Character examination and replacement operations
STRING - String concatenation and formation operations
UNSTRING - String parsing and field extraction
TALLYING - Character and pattern counting operations
REPLACING - Character and pattern replacement
DELIMITED BY - Field boundary specification
BEFORE/AFTER - Positional qualifiers for pattern operations
LEADING/TRAILING - Positional pattern specifications