Home
4
Bob

Bob in Cobol: Complete Solution & Deep Dive Guide

Code Debug

Mastering Cobol String Manipulation: The Ultimate Guide to Building a Logic Bot

This comprehensive guide explores essential Cobol string manipulation by building a conversational logic bot. You will learn to parse and analyze text input using conditional logic like IF and EVALUATE, handle data structures in the WORKING-STORAGE SECTION, and apply core Cobol verbs to manage character data effectively.

You’ve heard the stories: Cobol, the bedrock of the financial world, running on massive mainframes, processing trillions of dollars in transactions daily. It might sound like a relic from a bygone era, a language shrouded in mystery and complexity. Many aspiring developers feel a sense of intimidation, wondering how they can possibly bridge the gap between modern languages and this cornerstone of enterprise computing.

But what if you could demystify it? What if you could learn one of its most fundamental and powerful aspects—string manipulation—not by memorizing dry syntax, but by building something practical and interactive? This guide promises to do just that. We'll walk you through a hands-on module from the exclusive kodikra.com curriculum, where you'll teach a Cobol program to respond with personality, mastering critical data processing skills along the way.

What is String and Character Manipulation in Cobol?

In Cobol, string manipulation refers to the process of handling and modifying character-based data. Unlike modern languages that often have built-in, dynamic string types, Cobol treats strings as fixed-length alphanumeric fields defined in the DATA DIVISION. This fundamental difference is key to understanding its programming paradigm.

A "string" in Cobol is typically declared using a PICTURE clause, like PIC X(100), which reserves a fixed block of 100 characters in memory. This fixed-length nature means developers must be deliberate about handling padding (usually spaces), trimming, and parsing data within these defined boundaries. It's a more disciplined approach, born from an era where memory efficiency was paramount.

Core to this process are powerful Cobol verbs designed specifically for character data. Verbs like INSPECT are used for counting or replacing characters, STRING concatenates multiple fields into one, and UNSTRING splits a single field into many. Mastering these tools is not just about learning syntax; it's about understanding how to process data with precision, a skill essential for parsing financial records, validating user input, and managing complex data files in mainframe environments.

The Core Problem: Building Bob, The Cobol Bot

To put theory into practice, we'll tackle a challenge from the kodikra Cobol learning path. We need to create a program that simulates a laconic teenager named Bob. Bob's responses are based on a strict set of rules applied to the string of text he receives:

  • If you ask him a question (input ends with "?"), he replies: "Sure."
  • If you YELL at him (input is in ALL CAPS and contains letters), he replies: "Whoa, chill out!"
  • If you YELL a question at him (both of the above are true), he replies: "Calm down, I know what I'm doing!"
  • If you say nothing to him (input is empty or only whitespace), he replies: "Fine. Be that way!"
  • For anything else, he replies: "Whatever."

This simple set of requirements forces us to solve several classic string manipulation problems in Cobol: trimming whitespace, checking the last significant character, and iterating through a string to analyze its case.

Why is This Skill Crucial for Mainframe Developers?

While building a chatbot might seem trivial, the underlying skills are directly transferable to high-stakes, real-world mainframe applications. The global economy relies on Cobol programs accurately parsing and manipulating string data every second. Understanding this is not just an academic exercise; it's a prerequisite for a successful career in enterprise technology.

Consider these real-world scenarios:

  • Financial Transaction Processing: Bank transaction files often come in fixed-format text records. A single record might contain a customer name, account number, transaction amount, and date, all concatenated into one long string. A Cobol program must use UNSTRING or reference modification to parse these fields accurately. A single character out of place could have significant financial consequences.
  • CICS Screen Validation: In many mainframe applications, users interact via CICS (Customer Information Control System) screens, which are text-based interfaces. When a user enters data, a Cobol backend program must validate it. This involves trimming leading/trailing spaces, checking for valid characters, and ensuring required fields are not empty—the exact skills our Bob module teaches.
  • Batch Report Generation: Mainframes excel at batch processing, where millions of records are processed overnight to generate reports. These reports often require formatting data from various sources into a readable, structured text file. The STRING verb is heavily used to concatenate data fields with labels and spacing to build each line of the report.

Mastering string manipulation in Cobol means you can confidently and correctly maintain and enhance the critical systems that form the backbone of industries like banking, insurance, and logistics.

How to Implement the Logic Bot in Cobol: A Step-by-Step Solution

Now, let's dive into the code. Our approach will be to first define our data structures, then build a logical flow in the PROCEDURE DIVISION to analyze the input string and set the appropriate response. We will systematically check each condition—silence, yelling, and question—using helper flags to keep our logic clean.

The Decision Logic Flow

Before writing the code, it's crucial to visualize the flow of logic. The program must check the input against a hierarchy of rules, as some conditions override others (e.g., yelling a question is more specific than just a question).

  ● Start (Receive Input String)
  │
  ▼
┌──────────────────┐
│ Trim Whitespace  │
└────────┬─────────┘
         │
         ▼
◆ Is input empty? ────── Yes ───> [Set Response: "Fine. Be that way!"]
│        │
│        No
│
▼
┌──────────────────┐
│ Analyze String:  │
│ - Is it a Question?│
│ - Is it Yelling?   │
└────────┬─────────┘
         │
         ▼
◆ Yelling AND Question? ── Yes ───> [Set Response: "Calm down..."]
│        │
│        No
│
▼
◆ Just Yelling? ──────── Yes ───> [Set Response: "Whoa, chill out!"]
│        │
│        No
│
▼
◆ Just a Question? ───── Yes ───> [Set Response: "Sure."]
│        │
│        No
│
▼
[Set Default Response: "Whatever."]
│
▼
● End (Output Response)

The Complete Cobol Solution

Here is the full, commented source code for the Bob program. We use standard Cobol constructs and a clear, top-down approach to ensure readability and maintainability.


       IDENTIFICATION DIVISION.
       PROGRAM-ID. Bob.
       AUTHOR. kodikra.com.

       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 WS-INPUT-STRING         PIC X(255).
       01 WS-RESPONSE             PIC X(50).

      *-- Helper variables for string analysis
       01 WS-TRIMMED-STRING       PIC X(255).
       01 WS-TRIMMED-LENGTH       PIC 9(03) VALUE 0.
       01 WS-LAST-CHAR-POS        PIC 9(03) VALUE 0.
       01 WS-CHAR-INDEX           PIC 9(03).

      *-- Flags to hold the analysis results
       01 WS-FLAGS.
          05 WS-IS-QUESTION       PIC X(01) VALUE 'N'.
          05 WS-IS-YELLING        PIC X(01) VALUE 'Y'.
          05 WS-HAS-LETTERS       PIC X(01) VALUE 'N'.

       PROCEDURE DIVISION.
       MAIN-LOGIC.
      *-- Entry point of the program. Accepts the input string.
           ACCEPT WS-INPUT-STRING.

      *-- 1. Trim leading and trailing spaces from the input.
           PERFORM TRIM-WHITESPACE.

      *-- 2. Check for silence (empty or all-whitespace string).
           IF WS-TRIMMED-LENGTH = 0
               MOVE "Fine. Be that way!" TO WS-RESPONSE
               PERFORM DISPLAY-AND-EXIT
           END-IF.

      *-- 3. Analyze the trimmed string for yelling and question marks.
           PERFORM ANALYZE-STRING.

      *-- 4. Use an EVALUATE statement to determine the correct response
      *--    based on the flags set during analysis. This is a clean
      *--    alternative to deeply nested IF statements.
           EVALUATE WS-IS-YELLING ALSO WS-IS-QUESTION
               WHEN 'Y' ALSO 'Y'
                   MOVE "Calm down, I know what I'm doing!"
                     TO WS-RESPONSE
               WHEN 'Y' ALSO 'N'
                   MOVE "Whoa, chill out!" TO WS-RESPONSE
               WHEN 'N' ALSO 'Y'
                   MOVE "Sure." TO WS-RESPONSE
               WHEN OTHER
                   MOVE "Whatever." TO WS-RESPONSE
           END-EVALUATE.

      *-- 5. Display the final response and stop the program.
           PERFORM DISPLAY-AND-EXIT.

       TRIM-WHITESPACE.
      *-- This paragraph trims trailing spaces to find the actual
      *-- length of the content. Cobol's INSPECT is perfect for this.
           INSPECT FUNCTION REVERSE(WS-INPUT-STRING)
               TALLYING WS-LAST-CHAR-POS FOR LEADING SPACES.

           IF WS-LAST-CHAR-POS < FUNCTION LENGTH(WS-INPUT-STRING)
               COMPUTE WS-TRIMMED-LENGTH =
                   FUNCTION LENGTH(WS-INPUT-STRING) - WS-LAST-CHAR-POS
               MOVE WS-INPUT-STRING(1:WS-TRIMMED-LENGTH)
                 TO WS-TRIMMED-STRING
           ELSE
      *-- If the string is all spaces, length is 0.
               MOVE 0 TO WS-TRIMMED-LENGTH
               MOVE SPACES TO WS-TRIMMED-STRING
           END-IF.

       ANALYZE-STRING.
      *-- This paragraph iterates through the string to check its
      *-- properties: case and ending punctuation.

      *-- Check if it's a question by looking at the last non-space char.
           IF WS-TRIMMED-STRING(WS-TRIMMED-LENGTH:1) = '?'
               MOVE 'Y' TO WS-IS-QUESTION
           END-IF.

      *-- Check for yelling. A string is yelling if it contains letters
      *-- and all of its letters are uppercase.
           PERFORM VARYING WS-CHAR-INDEX FROM 1 BY 1
               UNTIL WS-CHAR-INDEX > WS-TRIMMED-LENGTH

               IF WS-TRIMMED-STRING(WS-CHAR-INDEX:1) IS ALPHABETIC
      *-- We found at least one letter.
                   MOVE 'Y' TO WS-HAS-LETTERS

      *-- If we find any lowercase letter, it's not yelling.
                   IF WS-TRIMMED-STRING(WS-CHAR-INDEX:1) IS LOWER-CASE
                       MOVE 'N' TO WS-IS-YELLING
                       EXIT PERFORM
                   END-IF
               END-IF
           END-PERFORM.

      *-- Final check for yelling: must have letters and no lowercase.
           IF WS-HAS-LETTERS = 'N'
               MOVE 'N' TO WS-IS-YELLING
           END-IF.

       DISPLAY-AND-EXIT.
      *-- A simple utility paragraph to display the result and terminate.
           DISPLAY FUNCTION TRIM(WS-RESPONSE).
           STOP RUN.

Detailed Code Walkthrough

1. DATA DIVISION Setup

We begin in the WORKING-STORAGE SECTION, where we define all our variables.

  • WS-INPUT-STRING and WS-RESPONSE are our primary I/O fields.
  • WS-TRIMMED-STRING and WS-TRIMMED-LENGTH will hold the input after we remove leading/trailing whitespace, which is a critical first step in almost any string processing task.
  • The WS-FLAGS group item contains three single-character flags: WS-IS-QUESTION, WS-IS-YELLING, and WS-HAS-LETTERS. Using flags like this simplifies the final decision logic, preventing a messy "pyramid of doom" with nested IF statements.

2. PROCEDURE DIVISION - The Main Logic

The execution starts at the MAIN-LOGIC paragraph. The flow is clean and sequential:

  1. ACCEPT WS-INPUT-STRING: Reads the input from the user or system.
  2. PERFORM TRIM-WHITESPACE: We immediately call a paragraph to handle whitespace. This is crucial because a string like "How are you? " should be treated as a question. Our custom logic uses INSPECT FUNCTION REVERSE(...) to efficiently find the last non-space character and calculate the true length.
  3. Check for Silence: An IF statement checks if WS-TRIMMED-LENGTH is zero. If so, we set the response and exit immediately. This is the simplest case.
  4. PERFORM ANALYZE-STRING: This is the heart of the analysis. It sets our flags (WS-IS-QUESTION, WS-IS-YELLING) based on the content.
  5. EVALUATE Statement: This is Cobol's equivalent of a switch or match statement. It elegantly handles the combinations of our boolean flags. EVALUATE WS-IS-YELLING ALSO WS-IS-QUESTION checks the two flags simultaneously and executes the code for the first matching WHEN clause. This is far more readable than multiple IF...ELSE IF... blocks.
  6. PERFORM DISPLAY-AND-EXIT: Finally, we display the result and execute STOP RUN to terminate the program.

3. Deep Dive: The `ANALYZE-STRING` Logic

This paragraph is where the detailed character-by-character analysis happens.

  • Question Check: We use reference modification—WS-TRIMMED-STRING(WS-TRIMMED-LENGTH:1)—to inspect only the very last character of the trimmed string. If it's a ?, we set WS-IS-QUESTION to 'Y'.
  • Yelling Check: This is the most complex part. We must satisfy two conditions: the string contains at least one letter, and all of its letters are uppercase.
    • We loop through the string using PERFORM VARYING.
    • Inside the loop, we first check if a character IS ALPHABETIC. If it is, we set WS-HAS-LETTERS to 'Y'.
    • Then, we check if the alphabetic character IS LOWER-CASE. If we find even one, we know it's not yelling. We set WS-IS-YELLING to 'N' and use EXIT PERFORM to break out of the loop early, as there's no need to check further.
    • After the loop, a final IF statement ensures that if no letters were found at all (e.g., the input was "123!"), it cannot be considered yelling.

This detailed process of setting flags and then making a decision is a robust and common pattern in procedural programming, especially in Cobol.

Alternative Approaches and Best Practices

While our solution is robust, Cobol often provides multiple ways to solve the same problem. Understanding alternatives helps you write more efficient and readable code.

Using Level 88 Condition Names

A more idiomatic and self-documenting way to handle flags in Cobol is by using 88 Level condition names. Instead of checking IF WS-IS-QUESTION = 'Y', you can define a condition name and write code that reads like plain English.

You would modify the DATA DIVISION like this:


       01 WS-FLAGS.
          05 WS-IS-QUESTION-FLAG  PIC X(01) VALUE 'N'.
             88 IS-A-QUESTION              VALUE 'Y'.
          05 WS-IS-YELLING-FLAG   PIC X(01) VALUE 'Y'.
             88 IS-YELLING                 VALUE 'Y'.
             88 IS-NOT-YELLING             VALUE 'N'.

Then, your PROCEDURE DIVISION logic becomes much more readable:


      *-- Setting the flag
           IF WS-TRIMMED-STRING(WS-TRIMMED-LENGTH:1) = '?'
               SET IS-A-QUESTION TO TRUE
           END-IF.

      *-- Checking the flag
           EVALUATE TRUE ALSO TRUE
               WHEN IS-YELLING ALSO IS-A-QUESTION
                   MOVE "Calm down, I know what I'm doing!"
                     TO WS-RESPONSE
               ...
           END-EVALUATE.

Using 88 Level numbers is highly recommended as it greatly improves code clarity and maintainability, which is paramount in enterprise environments where code lives for decades.

Visualizing the "Is-Yelling" Logic

The logic for determining if a string is "yelling" can be complex. Here is a flowchart that breaks down the character-by-character check performed inside our loop.

  ● Start (Check String for Yelling)
  │
  ▼
┌───────────────────────────────┐
│ Initialize Flags:             │
│  - IS-YELLING = TRUE          │
│  - HAS-LETTERS = FALSE        │
└──────────────┬────────────────┘
               │
               ▼
PERFORM VARYING char FROM 1 BY 1
UNTIL end of string
╭──────────────┴──────────────╮
│ ◆ Is char a letter?         │
│╱                             ╲
Yes                           No (Skip)
│                              │
▼                              │
┌──────────────────┐             │
│ SET HAS-LETTERS=TRUE │             │
└────────┬─────────┘             │
         │                       │
         ▼                       │
  ◆ Is char lowercase?           │
 ╱          ╲                    │
Yes          No (Continue loop)  │
│             │                  │
▼             │                  │
┌──────────────────┐               │
│ SET IS-YELLING=FALSE │               │
│ EXIT PERFORM     │               │
└──────────────────┘               │
╰──────────────────────────────╯
               │
               ▼
◆ IS-YELLING is TRUE AND HAS-LETTERS is TRUE?
╱                  ╲
Yes                  No
│                    │
▼                    ▼
[Result: Is Yelling]  [Result: Not Yelling]
│                    │
└────────┬───────────┘
         ▼
         ● End

Pros and Cons of Different String Analysis Techniques

When working with strings in Cobol, you have several tools at your disposal. Choosing the right one depends on the task's complexity and performance requirements.

Technique Pros Cons
INSPECT Verb Highly optimized and efficient for counting, replacing, or finding characters. Very readable for simple tasks. Limited to character-level operations; cannot handle complex pattern matching (like regex).
PERFORM VARYING Loop Offers complete, character-by-character control for complex custom logic (like our yelling check). Can be more verbose and potentially slower than intrinsic functions for simple tasks like counting.
Reference Modification Excellent for extracting substrings (e.g., MY-STRING(1:10)). Simple and direct. Can become cumbersome if you need to perform many complex extractions. Requires careful length calculations.
UNSTRING / STRING Verbs Powerful for parsing delimited data or concatenating multiple fields into one. Essential for file processing. Can be complex to set up with all the pointers and counters. Overkill for simple analysis.

For our Bob module, a combination of INSPECT (for trimming), reference modification (for the last character), and a PERFORM loop (for the case check) provides the best balance of clarity and control.

Frequently Asked Questions (FAQ)

What is the difference between PIC X, PIC A, and PIC 9 in Cobol?

These are picture clauses that define the type of data a field can hold. PIC X is for alphanumeric characters (any character). PIC A is for alphabetic characters only (A-Z, a-z, and space). PIC 9 is for numeric digits only (0-9). For general string input, PIC X is the most common and flexible choice.

How do you handle variable-length strings in Cobol?

Natively, Cobol strings are fixed-length. The common pattern to simulate variable length is to use a group item containing a length field and a data field, like: 01 MY-VAR-STRING. 05 STR-LEN PIC 9(03). 05 STR-DATA PIC X(255). You must manually update the STR-LEN field whenever you modify the string's content. Our solution simulates this by calculating WS-TRIMMED-LENGTH.

Is the Cobol language itself case-sensitive?

No, Cobol code is not case-sensitive. PERFORM, perform, and PeRfOrM are all treated as the same verb. However, the data it processes is case-sensitive. A string comparison like IF "hello" = "Hello" will evaluate to false, which is why we must explicitly check for upper and lower case in our program.

Why is the INSPECT verb so powerful?

The INSPECT verb is a highly optimized, built-in tool for string scanning. It can perform multiple operations in a single pass over the data, such as counting occurrences of a character (TALLYING), replacing characters (REPLACING), or both. Writing the equivalent logic in a manual loop would be less efficient and more error-prone.

Can you use Regular Expressions (Regex) in Cobol?

Standard ANSI Cobol does not have built-in support for regular expressions. In modern enterprise environments, if complex pattern matching is required, a Cobol program will typically CALL a subroutine written in another language (like C or Java) that can handle regex, or use specialized third-party libraries available on the mainframe.

How do intrinsic functions like FUNCTION TRIM work?

Modern Cobol standards have introduced many intrinsic functions that simplify common tasks. FUNCTION TRIM(MY-STRING), for example, returns a new string with leading and trailing spaces removed. While very convenient, some older compilers might not support all functions, which is why knowing how to perform these operations manually (as we did in our TRIM-WHITESPACE paragraph) is still a valuable skill.

Conclusion: From Simple Logic to Enterprise Power

By building this seemingly simple Cobol bot, we have journeyed through the core of what makes Cobol a data processing powerhouse: precise control over fixed-length strings, powerful analysis verbs, and structured, readable logic. The techniques you've learned here—trimming whitespace, analyzing character properties, and using flags with EVALUATE statements—are not just for exercises. They are the daily building blocks for developers maintaining the critical infrastructure of the global economy.

You've seen how to break down a problem into manageable steps, translate those steps into clean Cobol code, and even consider more idiomatic alternatives like 88 Level condition names. This foundational knowledge is your gateway to tackling more complex challenges in the world of mainframe development.

To continue your journey and apply these skills to more advanced scenarios, we encourage you to explore the full Cobol curriculum available at kodikra.com. Dive deeper into file handling, database interaction, and interfacing with other systems. The path from here is clear, and you now have a solid foundation to build upon.

Disclaimer: All code examples and logic are based on GnuCOBOL 3.1.2 or compatible enterprise Cobol compilers. Syntax and available intrinsic functions may vary slightly between different compiler versions and vendors.

Published by Kodikra — Your trusted Cobol learning resource.

Post a Comment