MainframeMaster

COBOL Tutorial

COBOL ACCEPT Statement Advanced

Progress0 of 0 lessons

Advanced ACCEPT Statement Concepts

Advanced ACCEPT statement usage involves sophisticated input handling techniques, comprehensive error management, and professional-grade input processing methods. These techniques are essential for building robust, user-friendly COBOL applications that can handle complex input scenarios gracefully.

Advanced ACCEPT techniques include:

  • Complex input validation and data transformation
  • Sophisticated error handling and recovery mechanisms
  • Multiple input source coordination
  • Professional user interface design
  • Integration with other COBOL features
  • Performance optimization for high-volume applications

Complex Input Validation Strategies

Advanced input validation goes beyond basic type checking to include business rule validation, format verification, and data integrity checks.

Multi-Level Validation Framework

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
IDENTIFICATION DIVISION.
PROGRAM-ID. ADVANCED-VALIDATION.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 INPUT-DATA.
   05 CUSTOMER-ID      PIC X(10).
   05 CUSTOMER-NAME    PIC X(30).
   05 CUSTOMER-EMAIL   PIC X(50).
   05 CUSTOMER-PHONE   PIC X(15).
   05 CUSTOMER-AGE     PIC 9(3).
 
01 VALIDATION-FLAGS.
   05 ID-VALID         PIC X(1) VALUE 'N'.
   05 NAME-VALID       PIC X(1) VALUE 'N'.
   05 EMAIL-VALID      PIC X(1) VALUE 'N'.
   05 PHONE-VALID      PIC X(1) VALUE 'N'.
   05 AGE-VALID        PIC X(1) VALUE 'N'.
 
01 ERROR-MESSAGES.
   05 ID-ERROR         PIC X(50).
   05 NAME-ERROR       PIC X(50).
   05 EMAIL-ERROR      PIC X(50).
   05 PHONE-ERROR      PIC X(50).
   05 AGE-ERROR        PIC X(50).
 
PROCEDURE DIVISION.
    PERFORM GET-CUSTOMER-DATA
    PERFORM VALIDATE-ALL-FIELDS
    PERFORM DISPLAY-RESULTS
    STOP RUN.
 
GET-CUSTOMER-DATA.
    DISPLAY "=== Customer Registration ==="
    DISPLAY "Enter Customer ID (10 chars): " WITH NO ADVANCING
    ACCEPT CUSTOMER-ID
    
    DISPLAY "Enter Customer Name: " WITH NO ADVANCING
    ACCEPT CUSTOMER-NAME
    
    DISPLAY "Enter Email Address: " WITH NO ADVANCING
    ACCEPT CUSTOMER-EMAIL
    
    DISPLAY "Enter Phone Number: " WITH NO ADVANCING
    ACCEPT CUSTOMER-PHONE
    
    DISPLAY "Enter Age: " WITH NO ADVANCING
    ACCEPT CUSTOMER-AGE.
 
VALIDATE-ALL-FIELDS.
    PERFORM VALIDATE-CUSTOMER-ID
    PERFORM VALIDATE-CUSTOMER-NAME
    PERFORM VALIDATE-EMAIL
    PERFORM VALIDATE-PHONE
    PERFORM VALIDATE-AGE.
 
VALIDATE-CUSTOMER-ID.
    IF CUSTOMER-ID = SPACES
       MOVE "Customer ID cannot be blank" TO ID-ERROR
    ELSE
       IF CUSTOMER-ID(1:1) NOT = "C"
          MOVE "Customer ID must start with 'C'" TO ID-ERROR
       ELSE
          MOVE "Y" TO ID-VALID
          MOVE "Customer ID is valid" TO ID-ERROR
       END-IF
    END-IF.
 
VALIDATE-CUSTOMER-NAME.
    IF CUSTOMER-NAME = SPACES
       MOVE "Customer name cannot be blank" TO NAME-ERROR
    ELSE
       IF FUNCTION LENGTH(FUNCTION TRIM(CUSTOMER-NAME)) < 2
          MOVE "Customer name must be at least 2 characters" TO NAME-ERROR
       ELSE
          MOVE "Y" TO NAME-VALID
          MOVE "Customer name is valid" TO NAME-ERROR
       END-IF
    END-IF.
 
VALIDATE-EMAIL.
    IF CUSTOMER-EMAIL = SPACES
       MOVE "Email cannot be blank" TO EMAIL-ERROR
    ELSE
       IF CUSTOMER-EMAIL NOT CONTAINS "@"
          MOVE "Email must contain '@' symbol" TO EMAIL-ERROR
       ELSE
          IF CUSTOMER-EMAIL NOT CONTAINS "."
             MOVE "Email must contain '.' symbol" TO EMAIL-ERROR
          ELSE
             MOVE "Y" TO EMAIL-VALID
             MOVE "Email is valid" TO EMAIL-ERROR
          END-IF
       END-IF
    END-IF.
 
VALIDATE-PHONE.
    IF CUSTOMER-PHONE = SPACES
       MOVE "Phone number cannot be blank" TO PHONE-ERROR
    ELSE
       IF CUSTOMER-PHONE IS NOT NUMERIC
          MOVE "Phone number must contain only digits" TO PHONE-ERROR
       ELSE
          IF FUNCTION LENGTH(FUNCTION TRIM(CUSTOMER-PHONE)) < 10
             MOVE "Phone number must be at least 10 digits" TO PHONE-ERROR
          ELSE
             MOVE "Y" TO PHONE-VALID
             MOVE "Phone number is valid" TO PHONE-ERROR
          END-IF
       END-IF
    END-IF.
 
VALIDATE-AGE.
    IF CUSTOMER-AGE IS NOT NUMERIC
       MOVE "Age must be numeric" TO AGE-ERROR
    ELSE
       IF CUSTOMER-AGE < 18 OR CUSTOMER-AGE > 120
          MOVE "Age must be between 18 and 120" TO AGE-ERROR
       ELSE
          MOVE "Y" TO AGE-VALID
          MOVE "Age is valid" TO AGE-ERROR
       END-IF
    END-IF.
 
DISPLAY-RESULTS.
    DISPLAY "=== Validation Results ==="
    DISPLAY "Customer ID: " ID-ERROR
    DISPLAY "Customer Name: " NAME-ERROR
    DISPLAY "Email: " EMAIL-ERROR
    DISPLAY "Phone: " PHONE-ERROR
    DISPLAY "Age: " AGE-ERROR.

Sophisticated Error Handling

Advanced error handling with ACCEPT involves comprehensive exception management, retry mechanisms, and graceful degradation strategies.

Exception Handling with Retry Logic

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
IDENTIFICATION DIVISION.
PROGRAM-ID. ROBUST-INPUT-HANDLER.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 INPUT-FIELD        PIC X(20).
01 RETRY-COUNT        PIC 9(2) VALUE ZERO.
01 MAX-RETRIES        PIC 9(2) VALUE 3.
01 SUCCESS-FLAG       PIC X(1) VALUE 'N'.
01 ERROR-MESSAGE     PIC X(50).
 
PROCEDURE DIVISION.
    PERFORM GET-INPUT-WITH-RETRY
    IF SUCCESS-FLAG = 'Y'
       DISPLAY "Input successful: " INPUT-FIELD
    ELSE
       DISPLAY "Failed to get valid input after " MAX-RETRIES " attempts"
    END-IF
    STOP RUN.
 
GET-INPUT-WITH-RETRY.
    MOVE ZERO TO RETRY-COUNT
    MOVE 'N' TO SUCCESS-FLAG
    
    PERFORM UNTIL SUCCESS-FLAG = 'Y' OR RETRY-COUNT >= MAX-RETRIES
       ADD 1 TO RETRY-COUNT
       DISPLAY "Enter data (attempt " RETRY-COUNT "): " WITH NO ADVANCING
       
       ACCEPT INPUT-FIELD
          ON EXCEPTION
             MOVE "Input error occurred" TO ERROR-MESSAGE
             DISPLAY ERROR-MESSAGE
          NOT ON EXCEPTION
             PERFORM VALIDATE-INPUT
       END-ACCEPT
       
       IF SUCCESS-FLAG = 'N' AND RETRY-COUNT < MAX-RETRIES
          DISPLAY "Please try again..."
       END-IF
    END-PERFORM.
 
VALIDATE-INPUT.
    IF INPUT-FIELD = SPACES
       MOVE "Input cannot be blank" TO ERROR-MESSAGE
       DISPLAY ERROR-MESSAGE
    ELSE
       IF FUNCTION LENGTH(FUNCTION TRIM(INPUT-FIELD)) < 3
          MOVE "Input must be at least 3 characters" TO ERROR-MESSAGE
          DISPLAY ERROR-MESSAGE
       ELSE
          MOVE 'Y' TO SUCCESS-FLAG
          DISPLAY "Input accepted successfully"
       END-IF
    END-IF.

Timeout and Interrupt Handling

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
DATA DIVISION.
WORKING-STORAGE SECTION.
01 TIMEOUT-COUNTER    PIC 9(4) VALUE ZERO.
01 MAX-TIMEOUT        PIC 9(4) VALUE 300.  * 30 seconds
01 INPUT-RECEIVED     PIC X(1) VALUE 'N'.
01 USER-INPUT         PIC X(50).
 
PROCEDURE DIVISION.
    DISPLAY "Enter data (timeout in 30 seconds): " WITH NO ADVANCING
    
    PERFORM UNTIL INPUT-RECEIVED = 'Y' OR TIMEOUT-COUNTER >= MAX-TIMEOUT
       ACCEPT USER-INPUT
          ON EXCEPTION
             ADD 1 TO TIMEOUT-COUNTER
             IF TIMEOUT-COUNTER >= MAX-TIMEOUT
                DISPLAY "Input timeout - using default value"
                MOVE "DEFAULT-INPUT" TO USER-INPUT
                MOVE 'Y' TO INPUT-RECEIVED
             END-IF
          NOT ON EXCEPTION
             MOVE 'Y' TO INPUT-RECEIVED
       END-ACCEPT
    END-PERFORM
    
    DISPLAY "Final input: " USER-INPUT
    STOP RUN.

Multiple Input Source Coordination

Advanced applications often need to coordinate multiple input sources, including user input, system data, and external sources.

Integrated Input Management

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
IDENTIFICATION DIVISION.
PROGRAM-ID. MULTI-SOURCE-INPUT.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 SYSTEM-DATA.
   05 CURRENT-DATE    PIC 9(8).
   05 CURRENT-TIME    PIC 9(6).
   05 USER-ID         PIC X(8).
   05 SYSTEM-NAME     PIC X(20).
 
01 USER-DATA.
   05 USER-NAME       PIC X(30).
   05 USER-DEPT       PIC X(15).
   05 USER-LEVEL      PIC 9(2).
 
01 PROCESSING-DATA.
   05 SESSION-ID      PIC X(10).
   05 PROCESS-TYPE    PIC X(10).
   05 PRIORITY        PIC 9(1).
 
PROCEDURE DIVISION.
    PERFORM INITIALIZE-SYSTEM-DATA
    PERFORM GET-USER-INFORMATION
    PERFORM GET-PROCESSING-PARAMETERS
    PERFORM DISPLAY-SESSION-SUMMARY
    STOP RUN.
 
INITIALIZE-SYSTEM-DATA.
    ACCEPT CURRENT-DATE FROM DATE YYYYMMDD
    ACCEPT CURRENT-TIME FROM TIME
    ACCEPT USER-ID FROM ENVIRONMENT "USER"
    ACCEPT SYSTEM-NAME FROM ENVIRONMENT "HOSTNAME"
    
    DISPLAY "System initialized at " CURRENT-DATE " " CURRENT-TIME
    DISPLAY "User: " USER-ID " on " SYSTEM-NAME.
 
GET-USER-INFORMATION.
    DISPLAY "=== User Information ==="
    DISPLAY "Enter your full name: " WITH NO ADVANCING
    ACCEPT USER-NAME
    
    DISPLAY "Enter your department: " WITH NO ADVANCING
    ACCEPT USER-DEPT
    
    DISPLAY "Enter your access level (1-9): " WITH NO ADVANCING
    ACCEPT USER-LEVEL.
 
GET-PROCESSING-PARAMETERS.
    DISPLAY "=== Processing Parameters ==="
    DISPLAY "Enter session ID: " WITH NO ADVANCING
    ACCEPT SESSION-ID
    
    DISPLAY "Enter process type: " WITH NO ADVANCING
    ACCEPT PROCESS-TYPE
    
    DISPLAY "Enter priority (1-5): " WITH NO ADVANCING
    ACCEPT PRIORITY.
 
DISPLAY-SESSION-SUMMARY.
    DISPLAY "=== Session Summary ==="
    DISPLAY "Date/Time: " CURRENT-DATE " " CURRENT-TIME
    DISPLAY "User: " USER-NAME " (" USER-ID ")"
    DISPLAY "Department: " USER-DEPT
    DISPLAY "Access Level: " USER-LEVEL
    DISPLAY "Session: " SESSION-ID
    DISPLAY "Process: " PROCESS-TYPE
    DISPLAY "Priority: " PRIORITY.

Professional User Interface Design

Creating professional user interfaces with ACCEPT involves thoughtful design, clear prompts, and enhanced user experience.

Formatted Input Screens

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
IDENTIFICATION DIVISION.
PROGRAM-ID. PROFESSIONAL-UI.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 EMPLOYEE-DATA.
   05 EMP-ID          PIC X(6).
   05 EMP-NAME        PIC X(30).
   05 EMP-DEPT        PIC X(15).
   05 EMP-SALARY      PIC 9(6)V99.
   05 EMP-HIRE-DATE   PIC 9(8).
 
01 SCREEN-CONTROL.
   05 LINE-NUMBER     PIC 9(2).
   05 COLUMN-NUMBER   PIC 9(2).
 
PROCEDURE DIVISION.
    PERFORM DISPLAY-HEADER
    PERFORM GET-EMPLOYEE-DATA
    PERFORM DISPLAY-SUMMARY
    STOP RUN.
 
DISPLAY-HEADER.
    DISPLAY "==============================================="
    DISPLAY "           EMPLOYEE REGISTRATION SYSTEM        "
    DISPLAY "==============================================="
    DISPLAY " "
    DISPLAY "Please enter the following information:"
    DISPLAY " ".
 
GET-EMPLOYEE-DATA.
    DISPLAY "Employee ID (6 characters): " WITH NO ADVANCING
    ACCEPT EMP-ID
    
    DISPLAY "Full Name (30 characters): " WITH NO ADVANCING
    ACCEPT EMP-NAME
    
    DISPLAY "Department: " WITH NO ADVANCING
    ACCEPT EMP-DEPT
    
    DISPLAY "Annual Salary: " WITH NO ADVANCING
    ACCEPT EMP-SALARY
    
    DISPLAY "Hire Date (YYYYMMDD): " WITH NO ADVANCING
    ACCEPT EMP-HIRE-DATE.
 
DISPLAY-SUMMARY.
    DISPLAY " "
    DISPLAY "==============================================="
    DISPLAY "           REGISTRATION SUMMARY                "
    DISPLAY "==============================================="
    DISPLAY "Employee ID: " EMP-ID
    DISPLAY "Name: " EMP-NAME
    DISPLAY "Department: " EMP-DEPT
    DISPLAY "Salary: $" EMP-SALARY
    DISPLAY "Hire Date: " EMP-HIRE-DATE
    DISPLAY "==============================================="
    DISPLAY "Registration completed successfully!"
    DISPLAY "Press Enter to continue..."
    ACCEPT EMP-ID.

Interactive Menu Systems

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
IDENTIFICATION DIVISION.
PROGRAM-ID. INTERACTIVE-MENU.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 MENU-CONTROL.
   05 MENU-CHOICE     PIC 9(1).
   05 CONTINUE-FLAG   PIC X(1) VALUE 'Y'.
   05 VALID-CHOICE    PIC X(1).
 
PROCEDURE DIVISION.
    PERFORM MAIN-MENU-LOOP
    DISPLAY "Thank you for using the system!"
    STOP RUN.
 
MAIN-MENU-LOOP.
    PERFORM UNTIL CONTINUE-FLAG = 'N'
       PERFORM DISPLAY-MENU
       PERFORM GET-MENU-CHOICE
       PERFORM PROCESS-CHOICE
    END-PERFORM.
 
DISPLAY-MENU.
    DISPLAY " "
    DISPLAY "==============================================="
    DISPLAY "              MAIN MENU SYSTEM                 "
    DISPLAY "==============================================="
    DISPLAY " "
    DISPLAY "1. Customer Management"
    DISPLAY "2. Order Processing"
    DISPLAY "3. Inventory Control"
    DISPLAY "4. Reports"
    DISPLAY "5. System Administration"
    DISPLAY "0. Exit System"
    DISPLAY " "
    DISPLAY "Enter your choice (0-5): " WITH NO ADVANCING.
 
GET-MENU-CHOICE.
    MOVE 'N' TO VALID-CHOICE
    PERFORM UNTIL VALID-CHOICE = 'Y'
       ACCEPT MENU-CHOICE
       IF MENU-CHOICE >= 0 AND MENU-CHOICE <= 5
          MOVE 'Y' TO VALID-CHOICE
       ELSE
          DISPLAY "Invalid choice. Please enter 0-5: " WITH NO ADVANCING
       END-IF
    END-PERFORM.
 
PROCESS-CHOICE.
    EVALUATE MENU-CHOICE
       WHEN 1
          PERFORM CUSTOMER-MANAGEMENT
       WHEN 2
          PERFORM ORDER-PROCESSING
       WHEN 3
          PERFORM INVENTORY-CONTROL
       WHEN 4
          PERFORM REPORTS
       WHEN 5
          PERFORM SYSTEM-ADMINISTRATION
       WHEN 0
          MOVE 'N' TO CONTINUE-FLAG
       WHEN OTHER
          DISPLAY "Invalid choice selected"
    END-EVALUATE.
 
CUSTOMER-MANAGEMENT.
    DISPLAY "Customer Management module selected"
    DISPLAY "Press Enter to return to main menu..."
    ACCEPT MENU-CHOICE.
 
ORDER-PROCESSING.
    DISPLAY "Order Processing module selected"
    DISPLAY "Press Enter to return to main menu..."
    ACCEPT MENU-CHOICE.
 
INVENTORY-CONTROL.
    DISPLAY "Inventory Control module selected"
    DISPLAY "Press Enter to return to main menu..."
    ACCEPT MENU-CHOICE.
 
REPORTS.
    DISPLAY "Reports module selected"
    DISPLAY "Press Enter to return to main menu..."
    ACCEPT MENU-CHOICE.
 
SYSTEM-ADMINISTRATION.
    DISPLAY "System Administration module selected"
    DISPLAY "Press Enter to return to main menu..."
    ACCEPT MENU-CHOICE.

Performance Optimization Techniques

Optimizing ACCEPT operations for performance involves minimizing input operations, efficient data handling, and smart user interaction design.

Batch Input 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
IDENTIFICATION DIVISION.
PROGRAM-ID. BATCH-INPUT-PROCESSOR.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 BATCH-DATA.
   05 RECORD-COUNT    PIC 9(4) VALUE ZERO.
   05 MAX-RECORDS     PIC 9(4) VALUE 100.
   05 CONTINUE-FLAG   PIC X(1) VALUE 'Y'.
 
01 INPUT-RECORD.
   05 RECORD-ID       PIC X(10).
   05 RECORD-DATA     PIC X(50).
   05 RECORD-TYPE     PIC X(5).
 
PROCEDURE DIVISION.
    PERFORM INITIALIZE-BATCH
    PERFORM PROCESS-BATCH-RECORDS
    PERFORM DISPLAY-BATCH-SUMMARY
    STOP RUN.
 
INITIALIZE-BATCH.
    DISPLAY "=== Batch Input Processor ==="
    DISPLAY "Enter up to " MAX-RECORDS " records"
    DISPLAY "Enter 'END' to finish input"
    DISPLAY " ".
 
PROCESS-BATCH-RECORDS.
    PERFORM UNTIL CONTINUE-FLAG = 'N' OR RECORD-COUNT >= MAX-RECORDS
       DISPLAY "Record " RECORD-COUNT + 1 ":"
       DISPLAY "Enter Record ID: " WITH NO ADVANCING
       ACCEPT RECORD-ID
       
       IF RECORD-ID = "END"
          MOVE 'N' TO CONTINUE-FLAG
       ELSE
          DISPLAY "Enter Record Data: " WITH NO ADVANCING
          ACCEPT RECORD-DATA
          
          DISPLAY "Enter Record Type: " WITH NO ADVANCING
          ACCEPT RECORD-TYPE
          
          ADD 1 TO RECORD-COUNT
          PERFORM PROCESS-INDIVIDUAL-RECORD
       END-IF
    END-PERFORM.
 
PROCESS-INDIVIDUAL-RECORD.
    * Process individual record logic here
    DISPLAY "Processed: " RECORD-ID " - " RECORD-DATA
    CONTINUE.
 
DISPLAY-BATCH-SUMMARY.
    DISPLAY " "
    DISPLAY "=== Batch Processing Summary ==="
    DISPLAY "Total records processed: " RECORD-COUNT
    DISPLAY "Batch processing completed successfully".

Efficient Data Collection

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
DATA DIVISION.
WORKING-STORAGE SECTION.
01 EFFICIENT-COLLECTION.
   05 COLLECTION-COUNT PIC 9(3) VALUE ZERO.
   05 MAX-COLLECTION   PIC 9(3) VALUE 50.
   05 COLLECTION-DATA.
      10 DATA-ITEM OCCURS 50 TIMES.
         15 ITEM-VALUE  PIC X(20).
         15 ITEM-TYPE   PIC X(5).
 
PROCEDURE DIVISION.
    PERFORM COLLECT-DATA-EFFICIENTLY
    PERFORM PROCESS-COLLECTED-DATA
    STOP RUN.
 
COLLECT-DATA-EFFICIENTLY.
    DISPLAY "Efficient data collection mode"
    DISPLAY "Enter data items (up to " MAX-COLLECTION ")"
    DISPLAY "Enter 'DONE' to finish"
    
    PERFORM UNTIL COLLECTION-COUNT >= MAX-COLLECTION
       DISPLAY "Item " COLLECTION-COUNT + 1 ": " WITH NO ADVANCING
       ACCEPT ITEM-VALUE(COLLECTION-COUNT + 1)
       
       IF ITEM-VALUE(COLLECTION-COUNT + 1) = "DONE"
          EXIT PERFORM
       ELSE
          DISPLAY "Type: " WITH NO ADVANCING
          ACCEPT ITEM-TYPE(COLLECTION-COUNT + 1)
          ADD 1 TO COLLECTION-COUNT
       END-IF
    END-PERFORM.
 
PROCESS-COLLECTED-DATA.
    DISPLAY "Processing " COLLECTION-COUNT " collected items"
    PERFORM VARYING COLLECTION-COUNT FROM 1 BY 1
       UNTIL COLLECTION-COUNT > COLLECTION-COUNT
       DISPLAY "Item " COLLECTION-COUNT ": " 
               ITEM-VALUE(COLLECTION-COUNT) 
               " (" ITEM-TYPE(COLLECTION-COUNT) ")"
    END-PERFORM.

Integration with Other COBOL Features

Advanced ACCEPT usage often involves integration with other COBOL features such as file operations, string manipulation, and data processing.

ACCEPT with File Operations

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
IDENTIFICATION DIVISION.
PROGRAM-ID. ACCEPT-FILE-INTEGRATION.
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
    SELECT INPUT-FILE ASSIGN TO "INPUT.DAT"
           ORGANIZATION IS SEQUENTIAL
           ACCESS MODE IS SEQUENTIAL.
 
DATA DIVISION.
FILE SECTION.
FD INPUT-FILE.
01 FILE-RECORD.
   05 FILE-DATA       PIC X(100).
 
WORKING-STORAGE SECTION.
01 USER-INPUT         PIC X(50).
01 FILE-STATUS        PIC X(2).
01 PROCESSING-FLAG    PIC X(1) VALUE 'Y'.
 
PROCEDURE DIVISION.
    PERFORM INITIALIZE-PROCESSING
    PERFORM PROCESS-USER-AND-FILE-DATA
    PERFORM FINALIZE-PROCESSING
    STOP RUN.
 
INITIALIZE-PROCESSING.
    DISPLAY "=== Integrated Processing System ==="
    DISPLAY "This system processes both user input and file data"
    DISPLAY " ".
 
PROCESS-USER-AND-FILE-DATA.
    PERFORM UNTIL PROCESSING-FLAG = 'N'
       DISPLAY "Enter processing command: " WITH NO ADVANCING
       ACCEPT USER-INPUT
       
       EVALUATE USER-INPUT
          WHEN "FILE"
             PERFORM PROCESS-FILE-DATA
          WHEN "USER"
             PERFORM PROCESS-USER-DATA
          WHEN "BOTH"
             PERFORM PROCESS-COMBINED-DATA
          WHEN "EXIT"
             MOVE 'N' TO PROCESSING-FLAG
          WHEN OTHER
             DISPLAY "Unknown command: " USER-INPUT
       END-EVALUATE
    END-PERFORM.
 
PROCESS-FILE-DATA.
    DISPLAY "Processing file data..."
    OPEN INPUT INPUT-FILE
    PERFORM UNTIL FILE-STATUS NOT = "00"
       READ INPUT-FILE
          AT END
             EXIT PERFORM
          NOT AT END
             DISPLAY "File record: " FILE-DATA
       END-READ
    END-PERFORM
    CLOSE INPUT-FILE.
 
PROCESS-USER-DATA.
    DISPLAY "Enter additional data: " WITH NO ADVANCING
    ACCEPT USER-INPUT
    DISPLAY "User data processed: " USER-INPUT.
 
PROCESS-COMBINED-DATA.
    DISPLAY "Processing combined user and file data..."
    PERFORM PROCESS-FILE-DATA
    PERFORM PROCESS-USER-DATA.
 
FINALIZE-PROCESSING.
    DISPLAY "Processing completed successfully".

Best Practices for Advanced ACCEPT

Following best practices ensures reliable, maintainable, and user-friendly input handling in advanced COBOL applications.

Design Principles

  • Always validate input immediately after ACCEPT
  • Provide clear, helpful error messages
  • Implement appropriate retry mechanisms
  • Use consistent input formats across the application
  • Design for both novice and experienced users

Security Considerations

  • Validate all input to prevent injection attacks
  • Implement proper access controls
  • Log input activities for audit purposes
  • Use secure input methods for sensitive data
  • Implement input sanitization routines

Performance Guidelines

  • Minimize the number of ACCEPT operations
  • Use batch processing when possible
  • Implement efficient data validation
  • Consider alternative input methods for high-volume applications
  • Profile and optimize critical input paths

Exercise: Advanced Input System

Create an advanced input system that demonstrates sophisticated ACCEPT usage. The system should include:

  • Multi-level input validation
  • Error handling with retry mechanisms
  • Professional user interface design
  • Integration with system date/time
  • Menu-driven navigation

Consider these advanced features:

  • How would you implement input history and recall?
  • What validation rules would you apply to different data types?
  • How would you handle input from multiple sources simultaneously?
  • What error recovery strategies would you implement?

FAQ

What are advanced ACCEPT statement techniques in COBOL?

Advanced ACCEPT techniques include complex input validation, error handling with ON EXCEPTION clauses, multiple input source handling, data transformation, and integration with other COBOL features for professional input processing.

How do you implement robust input validation with ACCEPT?

Robust input validation involves checking data types, ranges, formats, and business rules. Use IF statements, numeric tests, string manipulation functions, and validation routines to ensure input meets all requirements before processing.

What is the ON EXCEPTION clause in ACCEPT statements?

The ON EXCEPTION clause handles input errors during ACCEPT operations. It executes specified statements when input fails, allowing programs to recover gracefully from input errors and provide appropriate error handling.

How do you handle multiple input sources with ACCEPT?

Multiple input sources are handled by using different ACCEPT variations: terminal input (ACCEPT identifier), system data (ACCEPT FROM DATE/TIME), and special registers (ACCEPT FROM mnemonic-name). Each source requires different handling approaches.

What are best practices for ACCEPT error handling?

Best practices include implementing retry mechanisms, providing clear error messages, validating input immediately after ACCEPT, using appropriate data types, implementing timeout handling, and logging input errors for debugging.

ACCEPT Statement

Basic ACCEPT statement operations and syntax

Data Validation

Input validation and data integrity techniques

Error Handling

Comprehensive error handling strategies

Interactive Programming

Creating interactive COBOL applications