MainframeMaster

COBOL Character Handling Concepts

Character handling in COBOL encompasses all operations related to processing, manipulating, and managing character data. This includes string operations, text parsing, character validation, formatting, and conversion operations. Understanding character handling concepts is essential for building robust COBOL applications that process text data, user input, and formatted output effectively.

Understanding Character Handling

Character handling in COBOL involves working with alphanumeric data types (PIC X), performing string operations, and managing text data throughout the application lifecycle. COBOL provides powerful tools for string manipulation including MOVE operations, STRING/UNSTRING statements, INSPECT operations, and intrinsic functions that enable sophisticated text processing capabilities.

String Operations Fundamentals

1. Basic String Manipulation

Basic string manipulation in COBOL involves moving data between character fields, concatenating strings, and performing simple text operations. The MOVE statement is fundamental for string operations, while STRING and UNSTRING provide more advanced concatenation and parsing capabilities.

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
       IDENTIFICATION DIVISION.
       PROGRAM-ID. CHARACTER-HANDLING-BASICS.
       *> This program demonstrates basic character handling concepts
       
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       *> Basic character data structures
       01 STRING-DATA.
           05 FIRST-NAME         PIC X(20) VALUE 'John'.
           05 LAST-NAME          PIC X(20) VALUE 'Doe'.
           05 FULL-NAME          PIC X(50).
           05 INITIALS           PIC X(5).
           05 GREETING           PIC X(30).
       
       01 TEXT-MANIPULATION.
           05 SOURCE-TEXT        PIC X(50) VALUE 'Hello World'.
           05 TARGET-TEXT        PIC X(50).
           05 UPPER-TEXT         PIC X(50).
           05 LOWER-TEXT         PIC X(50).
           05 TRIMMED-TEXT       PIC X(50).
       
       01 STRING-CONTROLS.
           05 STRING-LENGTH      PIC 9(2).
           05 POSITION-COUNTER   PIC 9(2).
           05 CHARACTER-COUNT    PIC 9(2).
       
       PROCEDURE DIVISION.
       CHARACTER-HANDLING-MAIN.
           DISPLAY 'Character Handling Concepts Demonstration'
           DISPLAY '======================================='
           
       *> Demonstrate basic string operations
           PERFORM DEMONSTRATE-BASIC-STRING-OPS
           
       *> Demonstrate string concatenation
           PERFORM DEMONSTRATE-STRING-CONCATENATION
           
       *> Demonstrate string parsing
           PERFORM DEMONSTRATE-STRING-PARSING
           
       *> Demonstrate character counting
           PERFORM DEMONSTRATE-CHARACTER-COUNTING
           
           STOP RUN.
       
       DEMONSTRATE-BASIC-STRING-OPS.
       *> Demonstrate basic string operations
           DISPLAY 'Basic String Operations:'
           DISPLAY 'First Name: ' FIRST-NAME
           DISPLAY 'Last Name: ' LAST-NAME
           DISPLAY ' '
           
       *> Basic MOVE operation
           MOVE FIRST-NAME TO TARGET-TEXT
           DISPLAY 'MOVE operation: ' TARGET-TEXT
           
       *> String length calculation
           MOVE FUNCTION LENGTH(FIRST-NAME) TO STRING-LENGTH
           DISPLAY 'Length of first name: ' STRING-LENGTH
           
       *> Character extraction
           MOVE FIRST-NAME(1:1) TO INITIALS(1:1)
           MOVE LAST-NAME(1:1) TO INITIALS(3:1)
           DISPLAY 'Initials: ' INITIALS
           DISPLAY ' '.
       
       DEMONSTRATE-STRING-CONCATENATION.
       *> Demonstrate string concatenation using STRING statement
           DISPLAY 'String Concatenation:'
           
       *> Concatenate first and last name
           STRING FIRST-NAME DELIMITED BY SPACE
                  ' ' DELIMITED BY SIZE
                  LAST-NAME DELIMITED BY SPACE
                  INTO FULL-NAME
           END-STRING
           DISPLAY 'Full name: ' FULL-NAME
           
       *> Create greeting message
           STRING 'Hello, ' DELIMITED BY SIZE
                  FIRST-NAME DELIMITED BY SPACE
                  '!' DELIMITED BY SIZE
                  INTO GREETING
           END-STRING
           DISPLAY 'Greeting: ' GREETING
           
       *> Concatenate with delimiters
           STRING FIRST-NAME DELIMITED BY SPACE
                  ', ' DELIMITED BY SIZE
                  LAST-NAME DELIMITED BY SPACE
                  INTO TARGET-TEXT
           END-STRING
           DISPLAY 'Formatted name: ' TARGET-TEXT
           DISPLAY ' '.
       
       DEMONSTRATE-STRING-PARSING.
       *> Demonstrate string parsing using UNSTRING statement
           DISPLAY 'String Parsing:'
           DISPLAY 'Source text: ' SOURCE-TEXT
           
       *> Parse space-delimited text
           UNSTRING SOURCE-TEXT DELIMITED BY SPACE
               INTO FIRST-NAME LAST-NAME
           END-UNSTRING
           DISPLAY 'Parsed first name: ' FIRST-NAME
           DISPLAY 'Parsed last name: ' LAST-NAME
           
       *> Parse comma-delimited text
           MOVE 'Smith,John,Mr' TO SOURCE-TEXT
           UNSTRING SOURCE-TEXT DELIMITED BY ','
               INTO LAST-NAME FIRST-NAME GREETING
           END-UNSTRING
           DISPLAY 'Comma-delimited parsing:'
           DISPLAY '  Last: ' LAST-NAME
           DISPLAY '  First: ' FIRST-NAME
           DISPLAY '  Title: ' GREETING
           DISPLAY ' '.
       
       DEMONSTRATE-CHARACTER-COUNTING.
       *> Demonstrate character counting using INSPECT
           DISPLAY 'Character Counting:'
           DISPLAY 'Source text: ' SOURCE-TEXT
           
       *> Count specific characters
           MOVE 0 TO CHARACTER-COUNT
           INSPECT SOURCE-TEXT TALLYING CHARACTER-COUNT FOR ALL 'l'
           DISPLAY 'Count of letter l: ' CHARACTER-COUNT
           
           MOVE 0 TO CHARACTER-COUNT
           INSPECT SOURCE-TEXT TALLYING CHARACTER-COUNT FOR ALL 'o'
           DISPLAY 'Count of letter o: ' CHARACTER-COUNT
           
       *> Count spaces
           MOVE 0 TO CHARACTER-COUNT
           INSPECT SOURCE-TEXT TALLYING CHARACTER-COUNT FOR ALL SPACE
           DISPLAY 'Count of spaces: ' CHARACTER-COUNT
           
       *> Count uppercase letters
           MOVE 0 TO CHARACTER-COUNT
           INSPECT SOURCE-TEXT TALLYING CHARACTER-COUNT FOR ALL 'A' THROUGH 'Z'
           DISPLAY 'Count of uppercase letters: ' CHARACTER-COUNT.

This example demonstrates fundamental character handling concepts including basic string operations, concatenation using STRING statements, parsing using UNSTRING statements, and character counting using INSPECT operations. The program shows how to manipulate character data, extract information from strings, and perform basic text processing operations that form the foundation of character handling in COBOL.

2. Advanced String Processing

Advanced string processing involves complex text manipulation, pattern matching, character replacement, and sophisticated parsing operations. COBOL provides powerful tools like INSPECT with various options, intrinsic functions, and reference modification for advanced character handling scenarios.

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
       IDENTIFICATION DIVISION.
       PROGRAM-ID. ADVANCED-STRING-PROCESSING.
       *> This program demonstrates advanced string processing concepts
       
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       *> Advanced string processing data
       01 PROCESSING-DATA.
           05 INPUT-TEXT         PIC X(100) VALUE 'Hello World! This is a test.'.
           05 PROCESSED-TEXT     PIC X(100).
           05 SEARCH-PATTERN     PIC X(20) VALUE 'World'.
           05 REPLACEMENT-TEXT  PIC X(20) VALUE 'Universe'.
           05 RESULT-TEXT        PIC X(100).
       
       01 CHARACTER-ANALYSIS.
           05 TOTAL-CHARACTERS   PIC 9(3).
           05 UPPERCASE-COUNT    PIC 9(3).
           05 LOWERCASE-COUNT    PIC 9(3).
           05 DIGIT-COUNT        PIC 9(3).
           05 SPACE-COUNT        PIC 9(3).
           05 PUNCTUATION-COUNT  PIC 9(3).
       
       01 TEXT-TRANSFORMATION.
           05 ORIGINAL-TEXT      PIC X(50) VALUE '  Mixed Case Text  '.
           05 UPPERCASE-TEXT     PIC X(50).
           05 LOWER CASE-TEXT     PIC X(50).
           05 TRIMMED-TEXT       PIC X(50).
           05 REVERSED-TEXT      PIC X(50).
       
       01 PATTERN-MATCHING.
           05 EMAIL-TEXT         PIC X(100) VALUE 'Contact: john.doe@example.com or jane@test.org'.
           05 PHONE-TEXT         PIC X(100) VALUE 'Call: (555) 123-4567 or 555-987-6543'.
           05 EXTRACTED-EMAIL    PIC X(50).
           05 EXTRACTED-PHONE    PIC X(20).
       
       PROCEDURE DIVISION.
       ADVANCED-STRING-MAIN.
           DISPLAY 'Advanced String Processing Demonstration'
           DISPLAY '======================================'
           
       *> Demonstrate character analysis
           PERFORM DEMONSTRATE-CHARACTER-ANALYSIS
           
       *> Demonstrate text transformation
           PERFORM DEMONSTRATE-TEXT-TRANSFORMATION
           
       *> Demonstrate pattern matching
           PERFORM DEMONSTRATE-PATTERN-MATCHING
           
       *> Demonstrate character replacement
           PERFORM DEMONSTRATE-CHARACTER-REPLACEMENT
           
           STOP RUN.
       
       DEMONSTRATE-CHARACTER-ANALYSIS.
       *> Demonstrate comprehensive character analysis
           DISPLAY 'Character Analysis:'
           DISPLAY 'Input text: ' INPUT-TEXT
           DISPLAY ' '
           
       *> Count total characters
           MOVE FUNCTION LENGTH(INPUT-TEXT) TO TOTAL-CHARACTERS
           DISPLAY 'Total characters: ' TOTAL-CHARACTERS
           
       *> Count uppercase letters
           MOVE 0 TO UPPERCASE-COUNT
           INSPECT INPUT-TEXT TALLYING UPPERCASE-COUNT FOR ALL 'A' THROUGH 'Z'
           DISPLAY 'Uppercase letters: ' UPPERCASE-COUNT
           
       *> Count lowercase letters
           MOVE 0 TO LOWERCASE-COUNT
           INSPECT INPUT-TEXT TALLYING LOWERCASE-COUNT FOR ALL 'a' THROUGH 'z'
           DISPLAY 'Lowercase letters: ' LOWERCASE-COUNT
           
       *> Count digits
           MOVE 0 TO DIGIT-COUNT
           INSPECT INPUT-TEXT TALLYING DIGIT-COUNT FOR ALL '0' THROUGH '9'
           DISPLAY 'Digits: ' DIGIT-COUNT
           
       *> Count spaces
           MOVE 0 TO SPACE-COUNT
           INSPECT INPUT-TEXT TALLYING SPACE-COUNT FOR ALL SPACE
           DISPLAY 'Spaces: ' SPACE-COUNT
           
       *> Count punctuation
           MOVE 0 TO PUNCTUATION-COUNT
           INSPECT INPUT-TEXT TALLYING PUNCTUATION-COUNT FOR ALL '!' '.' ',' '?' ';' ':'
           DISPLAY 'Punctuation: ' PUNCTUATION-COUNT
           DISPLAY ' '.
       
       DEMONSTRATE-TEXT-TRANSFORMATION.
       *> Demonstrate text transformation operations
           DISPLAY 'Text Transformation:'
           DISPLAY 'Original text: "' ORIGINAL-TEXT '"'
           
       *> Convert to uppercase
           MOVE FUNCTION UPPER-CASE(ORIGINAL-TEXT) TO UPPERCASE-TEXT
           DISPLAY 'Uppercase: "' UPPERCASE-TEXT '"'
           
       *> Convert to lowercase
           MOVE FUNCTION LOWER-CASE(ORIGINAL-TEXT) TO LOWER-CASE-TEXT
           DISPLAY 'Lowercase: "' LOWER-CASE-TEXT '"'
           
       *> Trim leading and trailing spaces
           MOVE FUNCTION TRIM(ORIGINAL-TEXT) TO TRIMMED-TEXT
           DISPLAY 'Trimmed: "' TRIMMED-TEXT '"'
           
       *> Reverse text (simulated)
           PERFORM REVERSE-TEXT
           DISPLAY 'Reversed: "' REVERSED-TEXT '"'
           DISPLAY ' '.
       
       REVERSE-TEXT.
       *> Reverse text using reference modification
           MOVE SPACES TO REVERSED-TEXT
           MOVE FUNCTION LENGTH(TRIMMED-TEXT) TO TOTAL-CHARACTERS
           
           PERFORM VARYING POSITION-COUNTER FROM 1 BY 1
               UNTIL POSITION-COUNTER > TOTAL-CHARACTERS
               MOVE TRIMMED-TEXT(POSITION-COUNTER:1) TO 
                    REVERSED-TEXT(TOTAL-CHARACTERS - POSITION-COUNTER + 1:1)
           END-PERFORM.
       
       DEMONSTRATE-PATTERN-MATCHING.
       *> Demonstrate pattern matching and extraction
           DISPLAY 'Pattern Matching:'
           DISPLAY 'Email text: ' EMAIL-TEXT
           DISPLAY 'Phone text: ' PHONE-TEXT
           
       *> Extract email addresses (simplified)
           PERFORM EXTRACT-EMAIL-ADDRESS
           DISPLAY 'Extracted email: ' EXTRACTED-EMAIL
           
       *> Extract phone numbers (simplified)
           PERFORM EXTRACT-PHONE-NUMBER
           DISPLAY 'Extracted phone: ' EXTRACTED-PHONE
           DISPLAY ' '.
       
       EXTRACT-EMAIL-ADDRESS.
       *> Extract email address from text
           MOVE SPACES TO EXTRACTED-EMAIL
           
       *> Find @ symbol position
           PERFORM VARYING POSITION-COUNTER FROM 1 BY 1
               UNTIL POSITION-COUNTER > FUNCTION LENGTH(EMAIL-TEXT)
               IF EMAIL-TEXT(POSITION-COUNTER:1) = '@'
                   MOVE EMAIL-TEXT(1:POSITION-COUNTER - 1) TO EXTRACTED-EMAIL
                   EXIT PERFORM
               END-IF
           END-PERFORM.
       
       EXTRACT-PHONE-NUMBER.
       *> Extract phone number from text
           MOVE SPACES TO EXTRACTED-PHONE
           
       *> Find first digit
           PERFORM VARYING POSITION-COUNTER FROM 1 BY 1
               UNTIL POSITION-COUNTER > FUNCTION LENGTH(PHONE-TEXT)
               IF PHONE-TEXT(POSITION-COUNTER:1) >= '0' AND 
                  PHONE-TEXT(POSITION-COUNTER:1) <= '9'
                   MOVE PHONE-TEXT(POSITION-COUNTER:14) TO EXTRACTED-PHONE
                   EXIT PERFORM
               END-IF
           END-PERFORM.
       
       DEMONSTRATE-CHARACTER-REPLACEMENT.
       *> Demonstrate character replacement operations
           DISPLAY 'Character Replacement:'
           DISPLAY 'Original: ' INPUT-TEXT
           
       *> Replace specific characters
           MOVE INPUT-TEXT TO PROCESSED-TEXT
           INSPECT PROCESSED-TEXT REPLACING ALL 'l' BY 'L'
           DISPLAY 'Replace l with L: ' PROCESSED-TEXT
           
       *> Replace multiple characters
           MOVE INPUT-TEXT TO PROCESSED-TEXT
           INSPECT PROCESSED-TEXT REPLACING ALL 'o' BY '0'
           DISPLAY 'Replace o with 0: ' PROCESSED-TEXT
           
       *> Replace spaces with underscores
           MOVE INPUT-TEXT TO PROCESSED-TEXT
           INSPECT PROCESSED-TEXT REPLACING ALL SPACE BY '_'
           DISPLAY 'Replace spaces with _: ' PROCESSED-TEXT
           
       *> Replace word pattern
           MOVE INPUT-TEXT TO RESULT-TEXT
           INSPECT RESULT-TEXT REPLACING ALL 'World' BY 'Universe'
           DISPLAY 'Replace World with Universe: ' RESULT-TEXT.

This example demonstrates advanced string processing concepts including comprehensive character analysis, text transformation operations, pattern matching, and character replacement. The program shows how to analyze text content, transform text formats, extract specific patterns like email addresses and phone numbers, and perform sophisticated character replacement operations using INSPECT statements.

String Validation and Error Handling

1. Input Validation

String validation involves checking character data for correctness, format compliance, and business rule adherence. This includes validating data types, checking for required characters, verifying format patterns, and handling invalid input gracefully. Proper validation ensures data integrity and prevents processing errors in COBOL applications.

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
       IDENTIFICATION DIVISION.
       PROGRAM-ID. STRING-VALIDATION-DEMO.
       *> This program demonstrates string validation and error handling
       
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       *> Validation data structures
       01 VALIDATION-DATA.
           05 INPUT-STRING       PIC X(50).
           05 VALIDATION-STATUS  PIC X(1).
               88 VALIDATION-PASSED VALUE 'P'.
               88 VALIDATION-FAILED VALUE 'F'.
           05 ERROR-MESSAGE      PIC X(100).
           05 ERROR-COUNT        PIC 9(2) VALUE 0.
       
       01 VALIDATION-RULES.
           05 MIN-LENGTH         PIC 9(2) VALUE 5.
           05 MAX-LENGTH         PIC 9(2) VALUE 30.
           05 REQUIRED-CHARS     PIC X(10) VALUE 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.
           05 FORBIDDEN-CHARS    PIC X(10) VALUE '!@#$%^&*()'.
       
       01 TEST-STRINGS.
           05 TEST-STRING-1      PIC X(20) VALUE 'ValidString123'.
           05 TEST-STRING-2      PIC X(20) VALUE 'Short'.
           05 TEST-STRING-3      PIC X(20) VALUE 'ThisStringIsTooLongForValidation'.
           05 TEST-STRING-4      PIC X(20) VALUE 'Invalid@String!'.
           05 TEST-STRING-5      PIC X(20) VALUE '123456789'.
       
       01 VALIDATION-RESULTS.
           05 LENGTH-VALID       PIC X(1).
               88 LENGTH-OK       VALUE 'Y'.
               88 LENGTH-NOT-OK   VALUE 'N'.
           05 CHARACTER-VALID    PIC X(1).
               88 CHARACTER-OK    VALUE 'Y'.
               88 CHARACTER-NOT-OK VALUE 'N'.
           05 FORMAT-VALID       PIC X(1).
               88 FORMAT-OK        VALUE 'Y'.
               88 FORMAT-NOT-OK    VALUE 'N'.
       
       PROCEDURE DIVISION.
       STRING-VALIDATION-MAIN.
           DISPLAY 'String Validation Demonstration'
           DISPLAY '=============================='
           
       *> Test various validation scenarios
           PERFORM VALIDATE-TEST-STRING-1
           PERFORM VALIDATE-TEST-STRING-2
           PERFORM VALIDATE-TEST-STRING-3
           PERFORM VALIDATE-TEST-STRING-4
           PERFORM VALIDATE-TEST-STRING-5
           
       *> Display validation summary
           PERFORM DISPLAY-VALIDATION-SUMMARY
           
           STOP RUN.
       
       VALIDATE-TEST-STRING-1.
       *> Validate first test string
           DISPLAY 'Validating: ' TEST-STRING-1
           MOVE TEST-STRING-1 TO INPUT-STRING
           PERFORM COMPREHENSIVE-VALIDATION
           
           IF VALIDATION-PASSED
               DISPLAY '  Result: VALID'
           ELSE
               DISPLAY '  Result: INVALID - ' ERROR-MESSAGE
               ADD 1 TO ERROR-COUNT
           END-IF
           DISPLAY ' '.
       
       VALIDATE-TEST-STRING-2.
       *> Validate second test string (too short)
           DISPLAY 'Validating: ' TEST-STRING-2
           MOVE TEST-STRING-2 TO INPUT-STRING
           PERFORM COMPREHENSIVE-VALIDATION
           
           IF VALIDATION-PASSED
               DISPLAY '  Result: VALID'
           ELSE
               DISPLAY '  Result: INVALID - ' ERROR-MESSAGE
               ADD 1 TO ERROR-COUNT
           END-IF
           DISPLAY ' '.
       
       VALIDATE-TEST-STRING-3.
       *> Validate third test string (too long)
           DISPLAY 'Validating: ' TEST-STRING-3
           MOVE TEST-STRING-3 TO INPUT-STRING
           PERFORM COMPREHENSIVE-VALIDATION
           
           IF VALIDATION-PASSED
               DISPLAY '  Result: VALID'
           ELSE
               DISPLAY '  Result: INVALID - ' ERROR-MESSAGE
               ADD 1 TO ERROR-COUNT
           END-IF
           DISPLAY ' '.
       
       VALIDATE-TEST-STRING-4.
       *> Validate fourth test string (forbidden characters)
           DISPLAY 'Validating: ' TEST-STRING-4
           MOVE TEST-STRING-4 TO INPUT-STRING
           PERFORM COMPREHENSIVE-VALIDATION
           
           IF VALIDATION-PASSED
               DISPLAY '  Result: VALID'
           ELSE
               DISPLAY '  Result: INVALID - ' ERROR-MESSAGE
               ADD 1 TO ERROR-COUNT
           END-IF
           DISPLAY ' '.
       
       VALIDATE-TEST-STRING-5.
       *> Validate fifth test string (no letters)
           DISPLAY 'Validating: ' TEST-STRING-5
           MOVE TEST-STRING-5 TO INPUT-STRING
           PERFORM COMPREHENSIVE-VALIDATION
           
           IF VALIDATION-PASSED
               DISPLAY '  Result: VALID'
           ELSE
               DISPLAY '  Result: INVALID - ' ERROR-MESSAGE
               ADD 1 TO ERROR-COUNT
           END-IF
           DISPLAY ' '.
       
       COMPREHENSIVE-VALIDATION.
       *> Perform comprehensive string validation
           SET VALIDATION-PASSED TO TRUE
           MOVE SPACES TO ERROR-MESSAGE
           
       *> Validate length
           PERFORM VALIDATE-LENGTH
           
       *> Validate characters
           PERFORM VALIDATE-CHARACTERS
           
       *> Validate format
           PERFORM VALIDATE-FORMAT
           
       *> Check overall validation status
           IF LENGTH-NOT-OK OR CHARACTER-NOT-OK OR FORMAT-NOT-OK
               SET VALIDATION-FAILED TO TRUE
           END-IF.
       
       VALIDATE-LENGTH.
       *> Validate string length
           IF FUNCTION LENGTH(FUNCTION TRIM(INPUT-STRING)) < MIN-LENGTH
               SET LENGTH-NOT-OK TO TRUE
               SET VALIDATION-FAILED TO TRUE
               MOVE 'String too short' TO ERROR-MESSAGE
           ELSE
               IF FUNCTION LENGTH(FUNCTION TRIM(INPUT-STRING)) > MAX-LENGTH
                   SET LENGTH-NOT-OK TO TRUE
                   SET VALIDATION-FAILED TO TRUE
                   MOVE 'String too long' TO ERROR-MESSAGE
               ELSE
                   SET LENGTH-OK TO TRUE
               END-IF
           END-IF.
       
       VALIDATE-CHARACTERS.
       *> Validate character content
           SET CHARACTER-OK TO TRUE
           
       *> Check for forbidden characters
           PERFORM VARYING POSITION-COUNTER FROM 1 BY 1
               UNTIL POSITION-COUNTER > FUNCTION LENGTH(INPUT-STRING)
               IF INPUT-STRING(POSITION-COUNTER:1) = '!' OR
                  INPUT-STRING(POSITION-COUNTER:1) = '@' OR
                  INPUT-STRING(POSITION-COUNTER:1) = '#' OR
                  INPUT-STRING(POSITION-COUNTER:1) = '$' OR
                  INPUT-STRING(POSITION-COUNTER:1) = '%'
                   SET CHARACTER-NOT-OK TO TRUE
                   SET VALIDATION-FAILED TO TRUE
                   MOVE 'Contains forbidden characters' TO ERROR-MESSAGE
                   EXIT PERFORM
               END-IF
           END-PERFORM.
       
       VALIDATE-FORMAT.
       *> Validate string format
           SET FORMAT-OK TO TRUE
           
       *> Check if string contains at least one letter
           MOVE 0 TO CHARACTER-COUNT
           INSPECT INPUT-STRING TALLYING CHARACTER-COUNT FOR ALL 'A' THROUGH 'Z'
           INSPECT INPUT-STRING TALLYING CHARACTER-COUNT FOR ALL 'a' THROUGH 'z'
           
           IF CHARACTER-COUNT = 0
               SET FORMAT-NOT-OK TO TRUE
               SET VALIDATION-FAILED TO TRUE
               MOVE 'Must contain at least one letter' TO ERROR-MESSAGE
           END-IF.
       
       DISPLAY-VALIDATION-SUMMARY.
       *> Display validation summary
           DISPLAY 'Validation Summary:'
           DISPLAY '  Total strings tested: 5'
           DISPLAY '  Validation errors: ' ERROR-COUNT
           DISPLAY '  Success rate: ' (5 - ERROR-COUNT) ' out of 5'.

This example demonstrates comprehensive string validation and error handling in COBOL. The program validates strings against multiple criteria including length requirements, character content validation, and format compliance. It shows how to implement robust validation logic, handle validation errors gracefully, and provide meaningful error messages. The validation process includes checking for forbidden characters, ensuring minimum and maximum length requirements, and verifying format patterns.

Best Practices for Character Handling

Common Character Handling Patterns

String Processing

Learn string processing techniques

String Functions

Master string functions

Text Processing

Learn text processing

Character Sets

Understand character sets

Data Validation

Master validation techniques

String Manipulation

Learn string manipulation