PIC: Declaring Data

In modern languages, you declare variables by specifying their type: integers, strings, floats. If an integer gets bigger, the language gives it more memory. If a string gets longer, the language automatically reallocates memory to fit it.

COBOL does not work this way. In COBOL, you do not declare a general type. Instead, you declare the exact physical shape and width of the variable in memory.

This is done using the PICTURE (or PIC) clause inside the WORKING-STORAGE SECTION of the DATA DIVISION.

The WORKING-STORAGE SECTION

Before you can use a variable, you must allocate memory for it. In COBOL, this happens in the DATA DIVISION.

       IDENTIFICATION DIVISION.
       PROGRAM-ID. WORKING-STORE.
       
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 EMPLOYEE-ID PIC 9(5) VALUE 12345.
       
       PROCEDURE DIVISION.
           DISPLAY EMPLOYEE-ID.
           STOP RUN.

12345

Let’s break down the declaration line: 01 EMPLOYEE-ID PIC 9(5) VALUE 12345.

1. 01 (Level Number): This tells the compiler that EMPLOYEE-ID is a top-level, independent block of memory. It’s not just a bullet point; it defines the memory boundary!
2. EMPLOYEE-ID: The name of the variable.
3. PIC 9(5): The PICTURE clause. This dictates the variable’s physical shape.
4. VALUE 12345: The initial starting value.

The Shapes of Memory: 9 and X

The PIC clause uses specific characters to draw a “picture” of the memory:

• 9 stands for a single numeric digit.
• X stands for a single alphanumeric character (a string).

You specify the length by repeating the character or putting the count in parentheses.

       IDENTIFICATION DIVISION.
       PROGRAM-ID. STRINGS-DEMO.
       
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 EMPLOYEE-NAME PIC X(10) VALUE 'ALICE'.
       
       PROCEDURE DIVISION.
           DISPLAY EMPLOYEE-NAME.
           STOP RUN.

ALICE     

Notice the trailing spaces in the output! PIC X(10) creates a fixed block of exactly 10 characters. If you assign a 5-character string like 'ALICE', COBOL automatically pads the rest of the block with spaces on the right.

Similarly, if you put a small number into a large numeric field, COBOL pads it with zeros on the left:

       IDENTIFICATION DIVISION.
       PROGRAM-ID. ZERO-PAD.
       
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 SMALL-NUM PIC 9(5) VALUE 42.
       
       PROCEDURE DIVISION.
           DISPLAY SMALL-NUM.
           STOP RUN.

00042

Visualizing Memory Slots

When you write PIC X(5), you are allocating a physical array of exactly 5 bytes.

The Danger of Truncation

Because memory is strictly physical, COBOL will never dynamically resize your variables.

If you try to shove a large value into a small PIC slot, something has to give. In COBOL, excess data is silently truncated.

Let’s see this in action. A PIC 9(3) is 3 digits wide. Its absolute maximum physical capacity is 999.

If we try to store the number 1000 inside a 3-digit box, what happens?

       IDENTIFICATION DIVISION.
       PROGRAM-ID. OVERFLOW-DEMO.
       
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 MAX-SCORE PIC 9(3) VALUE 1000.
       
       PROCEDURE DIVISION.
           DISPLAY MAX-SCORE.
           STOP RUN.

000

COBOL chops off the high-order (leftmost) digits that don’t fit! The 1 in 1000 falls off the edge of memory, leaving only 000. This silent truncation can lead to catastrophic bugs in financial software if variables aren’t sized correctly from the start.

Similarly, if you place a long string into a short PIC X variable, COBOL will silently chop off the rightmost characters.

       IDENTIFICATION DIVISION.
       PROGRAM-ID. STR-TRUNC.
       
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 SHORT-NAME PIC X(4) VALUE 'ALEXANDER'.
       
       PROCEDURE DIVISION.
           DISPLAY SHORT-NAME.
           STOP RUN.

ALEX

When you define a PIC clause, you aren’t just giving the compiler a hint; you are forging a hard physical limit in memory.