The Case of the Missing Decimal: Debugging Numeric Data Errors in COBOL

The Case of the Missing Decimal: Debugging Numeric Data Errors in COBOL

Challenge:

Can you spot the bug? Examine the COBOL code below and see if you can identify the issue that's causing the incorrect sales total.

IDENTIFICATION DIVISION.
PROGRAM-ID. DAILY-SALES.

DATA DIVISION.
WORKING-STORAGE SECTION.
    01  WS-DAILY-SALES-TOTAL PIC 9(7)V99. 
    01  WS-SALES-RECORD.
        05  WS-ITEM-PRICE     PIC 9(4)V99.  
        05  WS-QUANTITY-SOLD  PIC 9(3).   

PROCEDURE DIVISION.
MAIN-PARAGRAPH.
    PERFORM INITIALIZE-TOTALS.
    PERFORM READ-SALES-RECORDS.
    PERFORM DISPLAY-TOTAL.
    STOP RUN.

INITIALIZE-TOTALS.
    MOVE ZERO TO WS-DAILY-SALES-TOTAL. 

READ-SALES-RECORDS.
    * Code to read sales records from a file (omitted for brevity)
    PERFORM CALCULATE-SALES UNTIL END-OF-FILE. 

CALCULATE-SALES.
    COMPUTE WS-DAILY-SALES-TOTAL = 
        WS-DAILY-SALES-TOTAL + (WS-ITEM-PRICE * WS-QUANTITY-SOLD).  
    * Read the next sales record (omitted for brevity)

DISPLAY-TOTAL.
    DISPLAY "Daily Sales Total: $" WS-DAILY-SALES-TOTAL.

The Crime Scene:

Our client, a bustling online bookstore, has noticed a discrepancy in their financial reports. The total revenue calculated by their COBOL accounting system is consistently underreporting actual sales. We've traced the problem to a program responsible for calculating daily sales totals.

Sample Buggy Program Output:

Using real-world sales data from the bookstore, the program produces the following output:

Daily Sales Total: $375821400

However, a manual check against the sales records reveals the correct total should be $3,758,214.62. Hmm... those decimal places seem to have vanished!

Visualizing the Logic:

To better understand the program flow, let's visualize the logic:

DAILY-SALES
├── MAIN-PARAGRAPH 
│   ├── INITIALIZE-TOTALS 
│   │   └── MOVE ZERO TO WS-DAILY-SALES-TOTAL  
│   ├── READ-SALES-RECORDS  
│   │   └── CALCULATE-SALES (repeated until END-OF-FILE) 
│   │       └── COMPUTE WS-DAILY-SALES-TOTAL = 
│   │           WS-DAILY-SALES-TOTAL + (WS-ITEM-PRICE * WS-QUANTITY-SOLD) 
│   └── DISPLAY-TOTAL 
│       └── DISPLAY "Daily Sales Total: $" WS-DAILY-SALES-TOTAL
└── (End of program) 

Clues and Evidence:

• Data Definitions: The WS-DAILY-SALES-TOTAL variable, where we store the final result, is defined with PIC 9(7)V99, capable of holding a number as large as 9,999,999.99. So, the variable itself isn't the issue.
• Calculation: The COMPUTE statement appears correct, multiplying the item price (WS-ITEM-PRICE) by the quantity sold (WS-QUANTITY-SOLD) and adding it to the running total.

However, COBOL has a quirk: it can truncate intermediate calculation results if they don't fit within the receiving field's definition. Could this be our culprit?

The Debugging Toolkit:

Let's employ some debugging techniques:

• DISPLAY Statements: We'll strategically place DISPLAY statements to reveal the values of WS-ITEM-PRICE, WS-QUANTITY-SOLD, and the result of WS-ITEM-PRICE * WS-QUANTITY-SOLD before and after each calculation. This will illuminate where the truncation might be happening.
• Trace (Optional): If your COBOL environment offers a trace facility, utilize it to meticulously step through the program execution line by line, observing the state of variables at each step.

The Reveal:

Our suspicions are confirmed! The COMPUTE statement is the source of the missing decimals. When WS-ITEM-PRICE * WS-QUANTITY-SOLD results in a number with more than two decimal places, those extra decimal places are mercilessly truncated before being added to WS-DAILY-SALES-TOTAL.

The Fix:

To preserve those precious decimal places, we'll introduce a temporary variable with a higher precision:

WORKING-STORAGE SECTION.
    01  WS-DAILY-SALES-TOTAL PIC 9(7)V99.
    01  WS-SALES-RECORD.
        05  WS-ITEM-PRICE     PIC 9(4)V99.
        05  WS-QUANTITY-SOLD  PIC 9(3).
    01  WS-TEMP-CALCULATION  PIC 9(7)V9999.  

CALCULATE-SALES.
    MULTIPLY WS-ITEM-PRICE BY WS-QUANTITY-SOLD
        GIVING WS-TEMP-CALCULATION.         
    ADD WS-TEMP-CALCULATION TO WS-DAILY-SALES-TOTAL.  

By using WS-TEMP-CALCULATION with PIC 9(7)V9999, we allow for up to four decimal places in the intermediate calculation, preventing the truncation and ensuring accurate results.

Lessons Learned:

• Truncation Awareness: Always be vigilant about how COBOL handles intermediate calculations and the potential for data truncation.
• Temporary Variables: When precision is paramount, especially with decimal values, use temporary variables with sufficient decimal places to maintain accuracy.
• Strategic Debugging: Employ DISPLAY statements and trace facilities to effectively pinpoint the root cause of errors.

Conclusion:

Keep those debugging skills sharp, and stay tuned for more exciting cases in our 'COBOL Debugging Decoded' series! Happy coding! 😊

Need COBOL Expertise?

If you're looking for guidance on COBOL coding or want to collaborate, feel free to reach out! We'd love to help you tackle your coding projects. 🚀

Email us at: info@pacificw.com

Image: TyliJura from Pixabay