MainframeMaster

COBOL Tutorial

COBOL DEBUGGING Features

COBOL provides built-in debugging capabilities through USE FOR DEBUGGING declaratives, allowing developers to trace program execution, monitor data changes, and troubleshoot applications.

USE FOR DEBUGGING Declarative

cobol
1
2
3
4
5
6
7
8
9
10
11
12
PROCEDURE DIVISION.
DECLARATIVES.
debug-section SECTION.
    USE FOR DEBUGGING ON procedure-name
                      or data-name
                      or ALL PROCEDURES
                      or ALL REFERENCES OF data-name.
    
    debug-paragraph.
        DISPLAY "Debug: " DEBUG-ITEM.
 
END DECLARATIVES.

Debug Item Register

DEBUG-ITEM Structure

cobol
1
2
3
4
5
6
7
8
9
10
11
12
13
*> DEBUG-ITEM is automatically provided by COBOL
01 DEBUG-ITEM.
   05 DEBUG-LINE           PIC X(6).     *> Line number
   05 FILLER               PIC X VALUE SPACE.
   05 DEBUG-NAME           PIC X(30).    *> Procedure/data name
   05 FILLER               PIC X VALUE SPACE.
   05 DEBUG-SUB-1          PIC S9(4) SIGN LEADING SEPARATE.
   05 FILLER               PIC X VALUE SPACE.
   05 DEBUG-SUB-2          PIC S9(4) SIGN LEADING SEPARATE.
   05 FILLER               PIC X VALUE SPACE.
   05 DEBUG-SUB-3          PIC S9(4) SIGN LEADING SEPARATE.
   05 FILLER               PIC X VALUE SPACE.
   05 DEBUG-CONTENTS       PIC X(n).     *> Data contents

Basic Debugging 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
IDENTIFICATION DIVISION.
PROGRAM-ID. DEBUG-DEMO.
 
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-COUNTER              PIC 9(3) VALUE ZERO.
01 WS-TOTAL                PIC 9(5) VALUE ZERO.
01 WS-EMPLOYEE-NAME        PIC X(30).
 
PROCEDURE DIVISION.
DECLARATIVES.
debug-section SECTION.
    USE FOR DEBUGGING ON ALL PROCEDURES.
    
    debug-paragraph.
        DISPLAY "PROC: " DEBUG-LINE " " DEBUG-NAME.
 
data-debug-section SECTION.
    USE FOR DEBUGGING ON ALL REFERENCES OF WS-COUNTER.
    
    data-debug-paragraph.
        DISPLAY "DATA: " DEBUG-NAME " = " DEBUG-CONTENTS.
 
END DECLARATIVES.
 
MAIN-SECTION SECTION.
MAIN-PROCESSING.
    PERFORM INITIALIZE-VARIABLES
    PERFORM PROCESS-LOOP 5 TIMES
    PERFORM DISPLAY-RESULTS
    STOP RUN.
 
INITIALIZE-VARIABLES.
    MOVE ZERO TO WS-COUNTER
    MOVE ZERO TO WS-TOTAL
    MOVE "John Smith" TO WS-EMPLOYEE-NAME.
 
PROCESS-LOOP.
    ADD 1 TO WS-COUNTER
    ADD WS-COUNTER TO WS-TOTAL.
 
DISPLAY-RESULTS.
    DISPLAY "Final Counter: " WS-COUNTER
    DISPLAY "Final Total: " WS-TOTAL.

Advanced Debugging Techniques

Conditional Debugging

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
WORKING-STORAGE SECTION.
01 WS-DEBUG-FLAGS.
   05 WS-DEBUG-MODE         PIC X VALUE 'N'.
      88 DEBUG-ON           VALUE 'Y'.
      88 DEBUG-OFF          VALUE 'N'.
   05 WS-TRACE-LEVEL        PIC 9 VALUE 1.
      88 BASIC-TRACE        VALUE 1.
      88 DETAILED-TRACE     VALUE 2.
      88 VERBOSE-TRACE      VALUE 3.
 
01 WS-PROCESS-DATA.
   05 WS-RECORD-COUNT       PIC 9(5) VALUE ZERO.
   05 WS-ERROR-COUNT        PIC 9(3) VALUE ZERO.
 
PROCEDURE DIVISION.
DECLARATIVES.
conditional-debug SECTION.
    USE FOR DEBUGGING ON PROCESS-RECORD.
    
    conditional-debug-para.
        IF DEBUG-ON
            EVALUATE WS-TRACE-LEVEL
                WHEN 1
                    DISPLAY "Processing record: " WS-RECORD-COUNT
                WHEN 2
                    DISPLAY "Line: " DEBUG-LINE 
                            " Procedure: " DEBUG-NAME
                    DISPLAY "Record: " WS-RECORD-COUNT 
                            " Errors: " WS-ERROR-COUNT
                WHEN 3
                    DISPLAY "=== VERBOSE DEBUG ==="
                    DISPLAY "Line Number: " DEBUG-LINE
                    DISPLAY "Procedure: " DEBUG-NAME
                    DISPLAY "Record Count: " WS-RECORD-COUNT
                    DISPLAY "Error Count: " WS-ERROR-COUNT
                    DISPLAY "Debug Contents: " DEBUG-CONTENTS
                    DISPLAY "===================="
            END-EVALUATE
        END-IF.
 
error-debug SECTION.
    USE FOR DEBUGGING ON ERROR-HANDLER.
    
    error-debug-para.
        DISPLAY "ERROR DEBUG: " DEBUG-LINE " " DEBUG-NAME
        ADD 1 TO WS-ERROR-COUNT.
 
END DECLARATIVES.
 
MAIN-SECTION SECTION.
MAIN-PROCESSING.
    ACCEPT WS-DEBUG-MODE FROM ENVIRONMENT "DEBUG_MODE"
    ACCEPT WS-TRACE-LEVEL FROM ENVIRONMENT "TRACE_LEVEL"
    
    PERFORM PROCESS-RECORDS
    STOP RUN.
 
PROCESS-RECORDS.
    PERFORM VARYING WS-RECORD-COUNT FROM 1 BY 1 
            UNTIL WS-RECORD-COUNT > 10
        PERFORM PROCESS-RECORD
        
        *> Simulate occasional errors
        IF FUNCTION MOD(WS-RECORD-COUNT, 3) = 0
            PERFORM ERROR-HANDLER
        END-IF
    END-PERFORM.
 
PROCESS-RECORD.
    *> Simulate record processing
    CONTINUE.
 
ERROR-HANDLER.
    *> Simulate error handling
    CONTINUE.

Data Change Monitoring

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
WORKING-STORAGE SECTION.
01 WS-CRITICAL-DATA.
   05 WS-ACCOUNT-BALANCE    PIC S9(8)V99 VALUE ZERO.
   05 WS-TRANSACTION-COUNT  PIC 9(5) VALUE ZERO.
   05 WS-LAST-UPDATE-TIME   PIC X(8).
 
01 WS-AUDIT-LOG.
   05 WS-LOG-ENTRY          PIC X(100).
   05 WS-LOG-TIMESTAMP      PIC X(20).
 
PROCEDURE DIVISION.
DECLARATIVES.
balance-monitor SECTION.
    USE FOR DEBUGGING ON ALL REFERENCES OF WS-ACCOUNT-BALANCE.
    
    balance-monitor-para.
        ACCEPT WS-LOG-TIMESTAMP FROM TIME
        STRING "BALANCE CHANGE: Line " DEBUG-LINE
               " Old: " DEBUG-CONTENTS
               " Time: " WS-LOG-TIMESTAMP
               DELIMITED BY SIZE INTO WS-LOG-ENTRY
        PERFORM WRITE-AUDIT-LOG.
 
transaction-monitor SECTION.
    USE FOR DEBUGGING ON ALL REFERENCES OF WS-TRANSACTION-COUNT.
    
    transaction-monitor-para.
        IF WS-TRANSACTION-COUNT > 1000
            DISPLAY "WARNING: High transaction count reached: " 
                    WS-TRANSACTION-COUNT
            DISPLAY "Location: Line " DEBUG-LINE
        END-IF.
 
END DECLARATIVES.
 
MAIN-SECTION SECTION.
MAIN-PROCESSING.
    PERFORM PROCESS-TRANSACTIONS
    STOP RUN.
 
PROCESS-TRANSACTIONS.
    PERFORM VARYING WS-TRANSACTION-COUNT FROM 1 BY 1
            UNTIL WS-TRANSACTION-COUNT > 50
        
        *> Simulate various transaction types
        EVALUATE FUNCTION MOD(WS-TRANSACTION-COUNT, 4)
            WHEN 0
                ADD 100.00 TO WS-ACCOUNT-BALANCE
            WHEN 1
                SUBTRACT 50.00 FROM WS-ACCOUNT-BALANCE
            WHEN 2
                ADD 250.00 TO WS-ACCOUNT-BALANCE
            WHEN 3
                SUBTRACT 75.00 FROM WS-ACCOUNT-BALANCE
        END-EVALUATE
        
        ACCEPT WS-LAST-UPDATE-TIME FROM TIME
    END-PERFORM.
 
WRITE-AUDIT-LOG.
    DISPLAY WS-LOG-ENTRY.

Debugging Best Practices

Debug Output 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
WORKING-STORAGE SECTION.
01 WS-DEBUG-CONTROL.
   05 WS-DEBUG-FILE-NAME    PIC X(20) VALUE "DEBUG.LOG".
   05 WS-DEBUG-COUNTER      PIC 9(5) VALUE ZERO.
   05 WS-MAX-DEBUG-ENTRIES  PIC 9(5) VALUE 1000.
 
FD DEBUG-FILE.
01 DEBUG-RECORD            PIC X(132).
 
PROCEDURE DIVISION.
DECLARATIVES.
debug-manager SECTION.
    USE FOR DEBUGGING ON ALL PROCEDURES.
    
    debug-manager-para.
        IF WS-DEBUG-COUNTER < WS-MAX-DEBUG-ENTRIES
            ADD 1 TO WS-DEBUG-COUNTER
            PERFORM WRITE-DEBUG-ENTRY
        ELSE
            IF WS-DEBUG-COUNTER = WS-MAX-DEBUG-ENTRIES
                ADD 1 TO WS-DEBUG-COUNTER
                MOVE "*** DEBUG LOG LIMIT REACHED ***" TO DEBUG-RECORD
                WRITE DEBUG-RECORD
            END-IF
        END-IF.
 
END DECLARATIVES.
 
MAIN-SECTION SECTION.
MAIN-PROCESSING.
    OPEN OUTPUT DEBUG-FILE
    PERFORM APPLICATION-LOGIC
    CLOSE DEBUG-FILE
    STOP RUN.
 
WRITE-DEBUG-ENTRY.
    STRING "Entry: " WS-DEBUG-COUNTER
           " Line: " DEBUG-LINE
           " Proc: " DEBUG-NAME
           DELIMITED BY SIZE INTO DEBUG-RECORD
    WRITE DEBUG-RECORD.
 
APPLICATION-LOGIC.
    PERFORM PROCEDURE-A
    PERFORM PROCEDURE-B
    PERFORM PROCEDURE-C.
 
PROCEDURE-A.
    DISPLAY "Executing Procedure A".
 
PROCEDURE-B.
    DISPLAY "Executing Procedure B".
 
PROCEDURE-C.
    DISPLAY "Executing Procedure C".

Performance Impact Monitoring

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
WORKING-STORAGE SECTION.
01 WS-PERFORMANCE-METRICS.
   05 WS-START-TIME         PIC 9(8).
   05 WS-END-TIME           PIC 9(8).
   05 WS-ELAPSED-TIME       PIC 9(8).
   05 WS-PROCEDURE-CALLS    PIC 9(7) VALUE ZERO.
   05 WS-DEBUG-OVERHEAD     PIC 9(5) VALUE ZERO.
 
01 WS-TIMING-WORK.
   05 WS-CURRENT-TIME       PIC 9(8).
   05 WS-LAST-TIME          PIC 9(8).
 
PROCEDURE DIVISION.
DECLARATIVES.
performance-debug SECTION.
    USE FOR DEBUGGING ON ALL PROCEDURES.
    
    performance-debug-para.
        ADD 1 TO WS-PROCEDURE-CALLS
        ACCEPT WS-CURRENT-TIME FROM TIME
        
        *> Calculate debug overhead
        IF WS-LAST-TIME > ZERO
            COMPUTE WS-DEBUG-OVERHEAD = WS-DEBUG-OVERHEAD +
                (WS-CURRENT-TIME - WS-LAST-TIME)
        END-IF
        
        MOVE WS-CURRENT-TIME TO WS-LAST-TIME
        
        *> Log only critical procedures to reduce overhead
        EVALUATE DEBUG-NAME
            WHEN "CRITICAL-CALC"
            WHEN "DATABASE-UPDATE"
            WHEN "ERROR-HANDLER"
                DISPLAY "PERF: " DEBUG-NAME " at " WS-CURRENT-TIME
        END-EVALUATE.
 
END DECLARATIVES.
 
MAIN-SECTION SECTION.
MAIN-PROCESSING.
    ACCEPT WS-START-TIME FROM TIME
    
    PERFORM APPLICATION-PROCESSING
    
    ACCEPT WS-END-TIME FROM TIME
    COMPUTE WS-ELAPSED-TIME = WS-END-TIME - WS-START-TIME
    
    PERFORM DISPLAY-PERFORMANCE-SUMMARY
    STOP RUN.
 
DISPLAY-PERFORMANCE-SUMMARY.
    DISPLAY "=== PERFORMANCE SUMMARY ==="
    DISPLAY "Total elapsed time: " WS-ELAPSED-TIME
    DISPLAY "Procedure calls: " WS-PROCEDURE-CALLS
    DISPLAY "Debug overhead: " WS-DEBUG-OVERHEAD
    DISPLAY "==========================".
 
APPLICATION-PROCESSING.
    PERFORM CRITICAL-CALC
    PERFORM DATABASE-UPDATE
    PERFORM NORMAL-PROCESSING.
 
CRITICAL-CALC.
    *> Critical calculation logic
    CONTINUE.
 
DATABASE-UPDATE.
    *> Database update logic
    CONTINUE.
 
NORMAL-PROCESSING.
    *> Normal processing logic
    CONTINUE.

Production Debugging Considerations

Production Debugging Guidelines

  • Use conditional debugging based on environment variables
  • Implement log rotation to prevent disk space issues
  • Monitor performance impact of debugging code
  • Use different debug levels for different environments
  • Ensure debugging code can be easily disabled
  • Protect sensitive data in debug output

Environment-Based Debug Control

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
WORKING-STORAGE SECTION.
01 WS-ENVIRONMENT-CONTROLS.
   05 WS-ENVIRONMENT        PIC X(10).
      88 DEVELOPMENT        VALUE "DEV".
      88 TEST               VALUE "TEST".
      88 PRODUCTION         VALUE "PROD".
   05 WS-DEBUG-ENABLED      PIC X VALUE 'N'.
      88 DEBUG-ENABLED      VALUE 'Y'.
   05 WS-LOG-LEVEL          PIC 9 VALUE 0.
      88 NO-LOGGING         VALUE 0.
      88 ERROR-ONLY         VALUE 1.
      88 WARNING-AND-ERROR  VALUE 2.
      88 INFO-LEVEL         VALUE 3.
      88 DEBUG-LEVEL        VALUE 4.
 
PROCEDURE DIVISION.
DECLARATIVES.
environment-debug SECTION.
    USE FOR DEBUGGING ON ALL PROCEDURES.
    
    environment-debug-para.
        IF DEBUG-ENABLED
            EVALUATE TRUE
                WHEN DEVELOPMENT
                    PERFORM FULL-DEBUG-OUTPUT
                WHEN TEST
                    PERFORM LIMITED-DEBUG-OUTPUT
                WHEN PRODUCTION
                    PERFORM ERROR-ONLY-OUTPUT
            END-EVALUATE
        END-IF.
 
END DECLARATIVES.
 
MAIN-SECTION SECTION.
MAIN-PROCESSING.
    PERFORM INITIALIZE-DEBUG-ENVIRONMENT
    PERFORM APPLICATION-LOGIC
    STOP RUN.
 
INITIALIZE-DEBUG-ENVIRONMENT.
    ACCEPT WS-ENVIRONMENT FROM ENVIRONMENT "APP_ENV"
    
    EVALUATE TRUE
        WHEN DEVELOPMENT
            SET DEBUG-ENABLED TO TRUE
            MOVE 4 TO WS-LOG-LEVEL
        WHEN TEST
            SET DEBUG-ENABLED TO TRUE
            MOVE 2 TO WS-LOG-LEVEL
        WHEN PRODUCTION
            MOVE 'N' TO WS-DEBUG-ENABLED
            MOVE 1 TO WS-LOG-LEVEL
        WHEN OTHER
            MOVE 'N' TO WS-DEBUG-ENABLED
            MOVE 0 TO WS-LOG-LEVEL
    END-EVALUATE.
 
FULL-DEBUG-OUTPUT.
    DISPLAY "FULL DEBUG: " DEBUG-LINE " " DEBUG-NAME.
 
LIMITED-DEBUG-OUTPUT.
    IF WS-LOG-LEVEL >= 2
        DISPLAY "LIMITED DEBUG: " DEBUG-NAME
    END-IF.
 
ERROR-ONLY-OUTPUT.
    IF DEBUG-NAME = "ERROR-HANDLER"
        DISPLAY "ERROR: " DEBUG-LINE " " DEBUG-NAME
    END-IF.

Related Topics

  • DECLARATIVES Section
  • USE Statement
  • DEBUG-ITEM Register
  • Program Testing
  • Error Handling
  • Performance Monitoring

Frequently Asked Questions

How do I enable debugging in COBOL programs?

Use the USE FOR DEBUGGING declarative in the DECLARATIVES section. Compile with debugging options enabled (varies by compiler) and ensure the DEBUG-ITEM register is accessible to your debug procedures.

What information is available in DEBUG-ITEM?

DEBUG-ITEM contains the line number, procedure/data name, subscript values (for arrays), and data contents. This provides comprehensive information about program execution flow and data changes.

Can debugging be used in production environments?

Yes, but with caution. Implement conditional debugging based on environment variables, use appropriate log levels, and monitor performance impact. Consider security implications when logging sensitive data.

How do I debug specific procedures or data items?

Use specific USE FOR DEBUGGING statements targeting individual procedures, data names, or use "ALL REFERENCES OF data-name" to monitor all changes to specific variables.