What is PARSE functionality in COBOL?

PARSE in COBOL refers to data parsing capabilities, primarily for XML and JSON processing, string analysis, and structured data extraction. It enables programs to process complex data formats and extract meaningful information from structured documents.

How does COBOL handle XML parsing?

COBOL handles XML parsing through XML PARSE statements that process XML documents event-by-event, allowing programs to extract data, validate structure, and transform XML content into COBOL data structures for business processing.

What are the benefits of using PARSE operations?

PARSE operations provide structured data processing, format validation, data extraction capabilities, integration with modern systems, and enable COBOL programs to work with XML, JSON, and other structured data formats efficiently.

MainframeMaster

COBOL Tutorial

COBOL PARSE

PARSE operations in COBOL represent sophisticated data processing and comprehensive structured document analysis capabilities within modern enterprise integration environments, providing advanced parsing mechanisms for XML and JSON processing, enhanced string analysis features for data extraction, and intelligent document processing patterns that enable efficient structured data handling, optimal format conversion workflows, and systematic data transformation requirements while maintaining data integrity, ensuring parsing accuracy, and enabling scalable integration architectures across business applications requiring modern data format processing, structured document analysis, and reliable data extraction throughout sophisticated integration scenarios.

Basic PARSE Operations

Fundamental String Parsing

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
*> Basic string parsing with UNSTRING
01 WS-PARSING-AREAS.
   05 WS-INPUT-STRING       PIC X(200).
   05 WS-PARSED-FIELDS.
      10 WS-FIELD-1         PIC X(30).
      10 WS-FIELD-2         PIC X(30).
      10 WS-FIELD-3         PIC X(30).
      10 WS-FIELD-4         PIC X(30).
   05 WS-FIELD-COUNT        PIC 9(2).
   05 WS-DELIMITERS         PIC X(10) VALUE ",;:|".
 
*> CSV data parsing
01 WS-CSV-PROCESSING.
   05 WS-CSV-RECORD         PIC X(500).
   05 WS-CSV-FIELDS OCCURS 20 TIMES.
      10 WS-CSV-FIELD       PIC X(50).
   05 WS-CSV-FIELD-COUNT    PIC 99.
 
*> Structured data parsing
01 WS-STRUCTURED-DATA.
   05 WS-EMPLOYEE-DATA      PIC X(300).
   05 WS-PARSED-EMPLOYEE.
      10 WS-EMP-ID          PIC X(8).
      10 WS-EMP-NAME        PIC X(30).
      10 WS-EMP-DEPT        PIC X(20).
      10 WS-EMP-SALARY      PIC 9(8)V99.
      10 WS-EMP-HIRE-DATE   PIC X(10).
 
PROCEDURE DIVISION.
BASIC-PARSING-DEMO.
    *> Parse comma-separated values
    MOVE "John,Doe,Manager,75000,2020-01-15" TO WS-INPUT-STRING
    
    UNSTRING WS-INPUT-STRING
        DELIMITED BY ","
        INTO WS-FIELD-1, WS-FIELD-2, WS-FIELD-3, 
             WS-FIELD-4, WS-FIELD-5
        COUNT IN WS-FIELD-COUNT
    END-UNSTRING
    
    DISPLAY "Parsed fields:"
    DISPLAY "  Name: " WS-FIELD-1 " " WS-FIELD-2
    DISPLAY "  Title: " WS-FIELD-3
    DISPLAY "  Salary: " WS-FIELD-4
    DISPLAY "  Hire Date: " WS-FIELD-5
 
*> Parse with multiple delimiters
PARSE-COMPLEX-STRING.
    MOVE "ID:12345|NAME:Jane Smith|DEPT:Finance|SAL:85000" 
         TO WS-INPUT-STRING
    
    UNSTRING WS-INPUT-STRING
        DELIMITED BY "|"
        INTO WS-FIELD-1, WS-FIELD-2, WS-FIELD-3, WS-FIELD-4
    END-UNSTRING
    
    *> Further parse each field
    PERFORM PARSE-KEY-VALUE-PAIR VARYING WS-INDEX FROM 1 BY 1
        UNTIL WS-INDEX > 4
 
PARSE-KEY-VALUE-PAIR.
    UNSTRING WS-FIELD(WS-INDEX)
        DELIMITED BY ":"
        INTO WS-KEY, WS-VALUE
    END-UNSTRING
    
    EVALUATE WS-KEY
        WHEN "ID"
            MOVE WS-VALUE TO WS-EMP-ID
        WHEN "NAME"
            MOVE WS-VALUE TO WS-EMP-NAME
        WHEN "DEPT"
            MOVE WS-VALUE TO WS-EMP-DEPT
        WHEN "SAL"
            MOVE WS-VALUE TO WS-EMP-SALARY
    END-EVALUATE

String Analysis

Data Extraction

Format Processing

XML Parsing Operations

XML Document 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
114
115
116
117
118
119
120
121
122
123
124
125
*> XML parsing data structures
01 WS-XML-PROCESSING.
   05 WS-XML-DOCUMENT       PIC X(5000).
   05 WS-XML-EVENT          PIC X(20).
   05 WS-XML-TAG            PIC X(50).
   05 WS-XML-CONTENT        PIC X(500).
   05 WS-XML-NAMESPACE      PIC X(100).
 
*> Parsed XML data
01 WS-CUSTOMER-DATA.
   05 WS-CUSTOMER-ID        PIC X(10).
   05 WS-CUSTOMER-NAME      PIC X(50).
   05 WS-CUSTOMER-ADDRESS.
      10 WS-STREET          PIC X(50).
      10 WS-CITY            PIC X(30).
      10 WS-STATE           PIC X(2).
      10 WS-ZIP             PIC X(10).
   05 WS-CUSTOMER-PHONE     PIC X(15).
   05 WS-CUSTOMER-EMAIL     PIC X(50).
 
*> XML parsing control
01 WS-XML-CONTROL.
   05 WS-PARSING-LEVEL      PIC 99.
   05 WS-CURRENT-ELEMENT    PIC X(50).
   05 WS-PARSING-STATUS     PIC X.
   05 WS-ERROR-MESSAGE      PIC X(100).
 
*> Sample XML document
01 WS-SAMPLE-XML.
   05 FILLER PIC X(1000) VALUE
   ''
   ''
   'CUST001'
   'Acme Corporation'
   ''
   '123 Business Ave'
   'Commerce City'
   'CA'
   '90210'
   ''
   '555-123-4567'
   'contact@acme.com'
   ''.
 
PROCEDURE DIVISION.
XML-PARSING-DEMO.
    MOVE WS-SAMPLE-XML TO WS-XML-DOCUMENT
    PERFORM PARSE-XML-DOCUMENT
    PERFORM DISPLAY-PARSED-DATA.
 
PARSE-XML-DOCUMENT.
    XML PARSE WS-XML-DOCUMENT
        PROCESSING PROCEDURE XML-EVENT-HANDLER
        ON EXCEPTION
            MOVE "XML parsing failed" TO WS-ERROR-MESSAGE
            DISPLAY WS-ERROR-MESSAGE
    END-XML
 
XML-EVENT-HANDLER.
    EVALUATE XML-EVENT
        WHEN 'START-OF-ELEMENT'
            PERFORM HANDLE-START-ELEMENT
        WHEN 'CONTENT-CHARACTERS'
            PERFORM HANDLE-ELEMENT-CONTENT
        WHEN 'END-OF-ELEMENT'
            PERFORM HANDLE-END-ELEMENT
        WHEN 'START-OF-DOCUMENT'
            PERFORM INITIALIZE-XML-PARSING
        WHEN 'END-OF-DOCUMENT'
            PERFORM FINALIZE-XML-PARSING
    END-EVALUATE
 
HANDLE-START-ELEMENT.
    MOVE XML-TAG TO WS-CURRENT-ELEMENT
    ADD 1 TO WS-PARSING-LEVEL
    
    EVALUATE WS-CURRENT-ELEMENT
        WHEN 'customer'
            DISPLAY "Starting customer record processing"
        WHEN 'address'
            DISPLAY "Processing address information"
    END-EVALUATE
 
HANDLE-ELEMENT-CONTENT.
    MOVE XML-TEXT TO WS-XML-CONTENT
    
    EVALUATE WS-CURRENT-ELEMENT
        WHEN 'id'
            MOVE WS-XML-CONTENT TO WS-CUSTOMER-ID
        WHEN 'name'
            MOVE WS-XML-CONTENT TO WS-CUSTOMER-NAME
        WHEN 'street'
            MOVE WS-XML-CONTENT TO WS-STREET
        WHEN 'city'
            MOVE WS-XML-CONTENT TO WS-CITY
        WHEN 'state'
            MOVE WS-XML-CONTENT TO WS-STATE
        WHEN 'zip'
            MOVE WS-XML-CONTENT TO WS-ZIP
        WHEN 'phone'
            MOVE WS-XML-CONTENT TO WS-CUSTOMER-PHONE
        WHEN 'email'
            MOVE WS-XML-CONTENT TO WS-CUSTOMER-EMAIL
    END-EVALUATE
 
HANDLE-END-ELEMENT.
    SUBTRACT 1 FROM WS-PARSING-LEVEL
    
    EVALUATE XML-TAG
        WHEN 'customer'
            DISPLAY "Customer record processing complete"
        WHEN 'address'
            DISPLAY "Address processing complete"
    END-EVALUATE
 
DISPLAY-PARSED-DATA.
    DISPLAY " "
    DISPLAY "=== PARSED XML DATA ==="
    DISPLAY "Customer ID: " WS-CUSTOMER-ID
    DISPLAY "Name: " WS-CUSTOMER-NAME
    DISPLAY "Address:"
    DISPLAY "  " WS-STREET
    DISPLAY "  " WS-CITY ", " WS-STATE " " WS-ZIP
    DISPLAY "Phone: " WS-CUSTOMER-PHONE
    DISPLAY "Email: " WS-CUSTOMER-EMAIL

Complete PARSE System Implementation

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
IDENTIFICATION DIVISION.
PROGRAM-ID. PARSE-DEMO.
 
DATA DIVISION.
WORKING-STORAGE SECTION.
*> Multi-format data parsing system
01 WS-PARSING-SYSTEM.
   05 WS-INPUT-FORMAT       PIC X(10).
   05 WS-PARSE-STATUS       PIC X.
   05 WS-RECORDS-PARSED     PIC 9(6) VALUE 0.
   05 WS-PARSING-ERRORS     PIC 9(4) VALUE 0.
 
*> CSV order processing
01 WS-CSV-ORDER-PROCESSING.
   05 WS-CSV-INPUT          PIC X(1000).
   05 WS-ORDER-FIELDS OCCURS 15 TIMES.
      10 WS-ORDER-FIELD     PIC X(50).
   05 WS-PARSED-ORDER.
      10 WS-ORDER-NUMBER    PIC X(12).
      10 WS-CUSTOMER-CODE   PIC X(8).
      10 WS-PRODUCT-CODE    PIC X(10).
      10 WS-QUANTITY        PIC 9(6).
      10 WS-UNIT-PRICE      PIC 9(6)V99.
      10 WS-ORDER-DATE      PIC X(10).
      10 WS-SHIP-ADDRESS    PIC X(100).
 
*> JSON-like parsing for configuration
01 WS-CONFIG-PARSING.
   05 WS-CONFIG-STRING      PIC X(2000).
   05 WS-CONFIG-PAIRS OCCURS 50 TIMES.
      10 WS-CONFIG-KEY      PIC X(30).
      10 WS-CONFIG-VALUE    PIC X(100).
   05 WS-CONFIG-COUNT       PIC 99.
 
*> Log file parsing
01 WS-LOG-PARSING.
   05 WS-LOG-ENTRY          PIC X(500).
   05 WS-PARSED-LOG.
      10 WS-LOG-TIMESTAMP   PIC X(20).
      10 WS-LOG-LEVEL       PIC X(10).
      10 WS-LOG-SOURCE      PIC X(20).
      10 WS-LOG-MESSAGE     PIC X(200).
 
*> Financial transaction parsing
01 WS-TRANSACTION-PARSING.
   05 WS-TRANSACTION-DATA   PIC X(300).
   05 WS-PARSED-TRANSACTION.
      10 WS-TRANS-ID        PIC X(15).
      10 WS-TRANS-TYPE      PIC X(10).
      10 WS-ACCOUNT-FROM    PIC X(12).
      10 WS-ACCOUNT-TO      PIC X(12).
      10 WS-AMOUNT          PIC 9(10)V99.
      10 WS-TRANS-DATE      PIC X(10).
      10 WS-TRANS-TIME      PIC X(8).
      10 WS-REFERENCE       PIC X(20).
 
PROCEDURE DIVISION.
MAIN-PARSE-DEMO.
    DISPLAY "=== COMPREHENSIVE PARSING DEMONSTRATION ==="
    
    PERFORM DEMONSTRATE-CSV-PARSING
    PERFORM DEMONSTRATE-LOG-PARSING
    PERFORM DEMONSTRATE-CONFIG-PARSING
    PERFORM DEMONSTRATE-TRANSACTION-PARSING
    PERFORM DISPLAY-PARSING-STATISTICS
    
    DISPLAY "=== PARSE DEMO COMPLETE ==="
    STOP RUN.
 
DEMONSTRATE-CSV-PARSING.
    DISPLAY " "
    DISPLAY "=== CSV ORDER DATA PARSING ==="
    
    *> Sample CSV order data
    MOVE "ORD123456,CUST001,PROD789,100,25.50,2024-01-15,123 Main St City State 12345"
         TO WS-CSV-INPUT
    
    PERFORM PARSE-CSV-ORDER-DATA
    PERFORM VALIDATE-PARSED-ORDER
    PERFORM DISPLAY-ORDER-DETAILS.
 
PARSE-CSV-ORDER-DATA.
    UNSTRING WS-CSV-INPUT
        DELIMITED BY ","
        INTO WS-ORDER-FIELD(1), WS-ORDER-FIELD(2), WS-ORDER-FIELD(3),
             WS-ORDER-FIELD(4), WS-ORDER-FIELD(5), WS-ORDER-FIELD(6),
             WS-ORDER-FIELD(7)
    END-UNSTRING
    
    *> Map fields to structured data
    MOVE WS-ORDER-FIELD(1) TO WS-ORDER-NUMBER
    MOVE WS-ORDER-FIELD(2) TO WS-CUSTOMER-CODE
    MOVE WS-ORDER-FIELD(3) TO WS-PRODUCT-CODE
    MOVE WS-ORDER-FIELD(4) TO WS-QUANTITY
    MOVE WS-ORDER-FIELD(5) TO WS-UNIT-PRICE
    MOVE WS-ORDER-FIELD(6) TO WS-ORDER-DATE
    MOVE WS-ORDER-FIELD(7) TO WS-SHIP-ADDRESS
    
    ADD 1 TO WS-RECORDS-PARSED.
 
VALIDATE-PARSED-ORDER.
    MOVE 'Y' TO WS-PARSE-STATUS
    
    IF WS-ORDER-NUMBER = SPACES
        DISPLAY "Error: Missing order number"
        MOVE 'N' TO WS-PARSE-STATUS
        ADD 1 TO WS-PARSING-ERRORS
    END-IF
    
    IF WS-QUANTITY NOT NUMERIC OR WS-QUANTITY = 0
        DISPLAY "Error: Invalid quantity"
        MOVE 'N' TO WS-PARSE-STATUS
        ADD 1 TO WS-PARSING-ERRORS
    END-IF
    
    IF WS-UNIT-PRICE NOT NUMERIC
        DISPLAY "Error: Invalid unit price"
        MOVE 'N' TO WS-PARSE-STATUS
        ADD 1 TO WS-PARSING-ERRORS
    END-IF.
 
DISPLAY-ORDER-DETAILS.
    IF WS-PARSE-STATUS = 'Y'
        DISPLAY "✅ Order parsed successfully:"
        DISPLAY "   Order #: " WS-ORDER-NUMBER
        DISPLAY "   Customer: " WS-CUSTOMER-CODE
        DISPLAY "   Product: " WS-PRODUCT-CODE
        DISPLAY "   Quantity: " WS-QUANTITY
        DISPLAY "   Price: $" WS-UNIT-PRICE
        DISPLAY "   Date: " WS-ORDER-DATE
        DISPLAY "   Ship To: " WS-SHIP-ADDRESS
        
        COMPUTE WS-ORDER-TOTAL = WS-QUANTITY * WS-UNIT-PRICE
        DISPLAY "   Total: $" WS-ORDER-TOTAL
    ELSE
        DISPLAY "❌ Order parsing failed"
    END-IF.
 
DEMONSTRATE-LOG-PARSING.
    DISPLAY " "
    DISPLAY "=== APPLICATION LOG PARSING ==="
    
    *> Sample log entry
    MOVE "[2024-01-15 14:30:15] ERROR CustomerService: Failed to process customer CUST001 - Invalid account status"
         TO WS-LOG-ENTRY
    
    PERFORM PARSE-LOG-ENTRY
    PERFORM DISPLAY-LOG-ANALYSIS.
 
PARSE-LOG-ENTRY.
    *> Extract timestamp (between brackets)
    UNSTRING WS-LOG-ENTRY
        DELIMITED BY "]"
        INTO WS-TIMESTAMP-PART, WS-REMAINDER
    END-UNSTRING
    
    *> Remove leading bracket from timestamp
    UNSTRING WS-TIMESTAMP-PART
        DELIMITED BY "["
        INTO WS-DUMMY, WS-LOG-TIMESTAMP
    END-UNSTRING
    
    *> Parse remaining parts (level, source, message)
    UNSTRING WS-REMAINDER
        DELIMITED BY " "
        INTO WS-DUMMY, WS-LOG-LEVEL, WS-LOG-SOURCE-PART, WS-MESSAGE-PART
    END-UNSTRING
    
    *> Clean up source (remove colon)
    UNSTRING WS-LOG-SOURCE-PART
        DELIMITED BY ":"
        INTO WS-LOG-SOURCE
    END-UNSTRING
    
    *> Reconstruct message
    STRING WS-MESSAGE-PART DELIMITED BY SIZE
           " " DELIMITED BY SIZE
           WS-REMAINDER(LENGTH(WS-LOG-LEVEL) + LENGTH(WS-LOG-SOURCE) + 5:)
           DELIMITED BY SIZE
           INTO WS-LOG-MESSAGE
    END-STRING
    
    ADD 1 TO WS-RECORDS-PARSED.
 
DISPLAY-LOG-ANALYSIS.
    DISPLAY "📝 Log entry parsed:"
    DISPLAY "   Timestamp: " WS-LOG-TIMESTAMP
    DISPLAY "   Level: " WS-LOG-LEVEL
    DISPLAY "   Source: " WS-LOG-SOURCE
    DISPLAY "   Message: " WS-LOG-MESSAGE.
 
DEMONSTRATE-CONFIG-PARSING.
    DISPLAY " "
    DISPLAY "=== CONFIGURATION DATA PARSING ==="
    
    *> Sample configuration string (JSON-like)
    MOVE 'database_host=localhost;database_port=5432;timeout=30;retry_count=3;debug_mode=true;log_level=INFO'
         TO WS-CONFIG-STRING
    
    PERFORM PARSE-CONFIGURATION-DATA
    PERFORM DISPLAY-CONFIGURATION-SETTINGS.
 
PARSE-CONFIGURATION-DATA.
    MOVE 0 TO WS-CONFIG-COUNT
    MOVE WS-CONFIG-STRING TO WS-WORK-STRING
    
    PERFORM UNTIL WS-WORK-STRING = SPACES
        ADD 1 TO WS-CONFIG-COUNT
        
        *> Extract next key-value pair
        UNSTRING WS-WORK-STRING
            DELIMITED BY ";"
            INTO WS-CONFIG-PAIR, WS-WORK-STRING
        END-UNSTRING
        
        *> Split key and value
        UNSTRING WS-CONFIG-PAIR
            DELIMITED BY "="
            INTO WS-CONFIG-KEY(WS-CONFIG-COUNT),
                 WS-CONFIG-VALUE(WS-CONFIG-COUNT)
        END-UNSTRING
    END-PERFORM
    
    ADD 1 TO WS-RECORDS-PARSED.
 
DISPLAY-CONFIGURATION-SETTINGS.
    DISPLAY "⚙️ Configuration parsed:"
    PERFORM VARYING WS-INDEX FROM 1 BY 1 
        UNTIL WS-INDEX > WS-CONFIG-COUNT
        DISPLAY "   " WS-CONFIG-KEY(WS-INDEX) 
                " = " WS-CONFIG-VALUE(WS-INDEX)
    END-PERFORM.
 
DEMONSTRATE-TRANSACTION-PARSING.
    DISPLAY " "
    DISPLAY "=== FINANCIAL TRANSACTION PARSING ==="
    
    *> Sample transaction data
    MOVE "TXN20240115001|TRANSFER|ACC12345678|ACC87654321|1500.00|2024-01-15|14:30:15|REF-WTX-789"
         TO WS-TRANSACTION-DATA
    
    PERFORM PARSE-TRANSACTION-DATA
    PERFORM VALIDATE-TRANSACTION
    PERFORM DISPLAY-TRANSACTION-DETAILS.
 
PARSE-TRANSACTION-DATA.
    UNSTRING WS-TRANSACTION-DATA
        DELIMITED BY "|"
        INTO WS-TRANS-ID, WS-TRANS-TYPE, WS-ACCOUNT-FROM,
             WS-ACCOUNT-TO, WS-AMOUNT-FIELD, WS-TRANS-DATE,
             WS-TRANS-TIME, WS-REFERENCE
    END-UNSTRING
    
    *> Convert amount to numeric
    MOVE WS-AMOUNT-FIELD TO WS-AMOUNT
    
    ADD 1 TO WS-RECORDS-PARSED.
 
VALIDATE-TRANSACTION.
    MOVE 'Y' TO WS-PARSE-STATUS
    
    IF WS-TRANS-ID = SPACES
        DISPLAY "Error: Missing transaction ID"
        MOVE 'N' TO WS-PARSE-STATUS
        ADD 1 TO WS-PARSING-ERRORS
    END-IF
    
    IF WS-AMOUNT NOT NUMERIC OR WS-AMOUNT <= 0
        DISPLAY "Error: Invalid transaction amount"
        MOVE 'N' TO WS-PARSE-STATUS
        ADD 1 TO WS-PARSING-ERRORS
    END-IF
    
    IF WS-ACCOUNT-FROM = WS-ACCOUNT-TO
        DISPLAY "Error: Same source and destination accounts"
        MOVE 'N' TO WS-PARSE-STATUS
        ADD 1 TO WS-PARSING-ERRORS
    END-IF.
 
DISPLAY-TRANSACTION-DETAILS.
    IF WS-PARSE-STATUS = 'Y'
        DISPLAY "💰 Transaction parsed successfully:"
        DISPLAY "   Transaction ID: " WS-TRANS-ID
        DISPLAY "   Type: " WS-TRANS-TYPE
        DISPLAY "   From Account: " WS-ACCOUNT-FROM
        DISPLAY "   To Account: " WS-ACCOUNT-TO
        DISPLAY "   Amount: $" WS-AMOUNT
        DISPLAY "   Date: " WS-TRANS-DATE
        DISPLAY "   Time: " WS-TRANS-TIME
        DISPLAY "   Reference: " WS-REFERENCE
    ELSE
        DISPLAY "❌ Transaction parsing failed"
    END-IF.
 
DISPLAY-PARSING-STATISTICS.
    DISPLAY " "
    DISPLAY "📊 PARSING SYSTEM STATISTICS"
    DISPLAY "============================"
    DISPLAY "Records parsed: " WS-RECORDS-PARSED
    DISPLAY "Parsing errors: " WS-PARSING-ERRORS
    COMPUTE WS-SUCCESS-RATE = 
        ((WS-RECORDS-PARSED - WS-PARSING-ERRORS) / WS-RECORDS-PARSED) * 100
    DISPLAY "Success rate: " WS-SUCCESS-RATE "%"
    DISPLAY " "
    DISPLAY "🎯 Key PARSE Features Demonstrated:"
    DISPLAY "   • CSV data parsing and validation"
    DISPLAY "   • Log file analysis and extraction"
    DISPLAY "   • Configuration data processing"
    DISPLAY "   • Financial transaction parsing"
    DISPLAY "   • Multi-delimiter string processing"
    DISPLAY "   • Data validation and error handling"
    DISPLAY "   • Structured data transformation"

PARSE Features and Applications

Data Formats

• XML document processing
• CSV and delimited file parsing
• JSON-like configuration data
• Log file analysis

Parsing Techniques

• UNSTRING operations
• XML PARSE event handling
• Multi-delimiter processing
• Nested structure parsing

Validation Features

• Data format validation
• Type checking and conversion
• Error detection and handling
• Content verification

Business Applications

• System integration processing
• Data migration and ETL
• Configuration management
• Transaction processing

COBOL Tutorial

COBOL PARSE

Basic PARSE Operations

XML Parsing Operations

Complete PARSE System Implementation

PARSE Features and Applications

Best Practices

Related Concepts

XML Processing

String Operations

Data Integration

Related Pages

COBOL Tutorial

COBOL PARSE

Basic PARSE Operations

XML Parsing Operations

Complete PARSE System Implementation

PARSE Features and Applications

Best Practices

Parsing Strategy

Error Handling

Performance Optimization

Related Concepts

XML Processing

String Operations

Data Integration

Related Pages