COBOL Data Types and Representation

In COBOL, the type and meaning of data come from the PICTURE clause (and sometimes USAGE). The same logical value can be stored in different internal formats: human-readable (DISPLAY), binary (COMP/COMP-4), or packed decimal (COMP-3). Each format uses a different number of bytes and a different way to store the sign. This page explains how data types and representation work so you can choose the right one for storage, arithmetic, and I/O.

Explain Like I'm Five: What Is a Data Type and Representation?

A data type is what kind of value a field holds: numbers, text, or a mix. Representation is how that value is stored in memory. The number 12345 could be stored as five separate digit characters (like on a display), or squeezed into fewer bytes in a special numeric format. COBOL lets you say both "this is a number" (with PICTURE 9) and "store it this way" (with USAGE). Choosing the right representation affects how much space you use and how fast arithmetic is.

PICTURE Clause: Defining the Type

The PICTURE (or PIC) clause defines the kind of data and its length. Common symbols are: 9 for a numeric digit, X for any character (alphanumeric), A for alphabetic (letter or space), V for an assumed decimal point (no storage; it only defines where the decimal point is), and S for a sign. The number in parentheses (e.g. 9(5)) gives the count. So PIC 9(5) is five numeric digits; PIC X(20) is 20 characters; PIC S9(7)V99 is a signed number with seven digits before the decimal and two after (the V does not take a byte). Editing symbols (Z, *, $, comma, period, CR, DB) are used for display formatting and change how the value is shown when moved to a display field.

1
2
3
4
       01 WS-AMOUNT    PIC S9(7)V99.     *> Signed, 7 digits + 2 decimals
       01 WS-NAME      PIC X(30).        *> 30 characters
       01 WS-CODE      PIC 9(5).         *> 5 digits, unsigned
       01 WS-RATE      PIC 9(2)V99.      *> 2 integer, 2 decimal (e.g. 0.25)

USAGE: How the Value Is Stored

USAGE (or the shorthand in the PICTURE, like COMP) determines the internal representation. The default is DISPLAY. Other common options are COMP (or COMP-4) for binary, COMP-3 for packed decimal, and COMP-1/COMP-2 for floating-point. The same PICTURE can be stored in different ways; the logical value (e.g. 12345) is the same, but the bytes in memory differ. That affects storage size, arithmetic performance, and how data looks when you move it to a DISPLAY field or a file.

USAGE DISPLAY (Default)

With USAGE DISPLAY, each character or digit occupies one byte. On the mainframe the encoding is usually EBCDIC. The value is human-readable: you can look at the bytes and see the digits or letters. For signed numeric fields (PIC S9...), the sign is stored in the rightmost byte as an "overpunch": the last digit and the sign are combined into one character code (e.g. a special code for "negative 5"). DISPLAY is ideal for data that is read from or written to users or files in character form. Arithmetic on DISPLAY is possible but the runtime must decode and encode each digit; for heavy computation, COMP or COMP-3 is faster.

USAGE COMP and COMP-4 (Binary)

COMP and COMP-4 are the same: the value is stored in binary (halfword, fullword, or doubleword). The number of digits in the PICTURE determines the size: 1–4 digits use 2 bytes, 5–9 digits use 4 bytes, 10–18 digits use 8 bytes. The sign is in the most significant bit (1 for negative, 0 for positive). Binary arithmetic is fast and is natural for integer math. The range is limited by the size: a 4-byte COMP holds roughly ±2 billion. Be careful with decimal places: COMP does not store a decimal point; if you need exact decimal fractions, use COMP-3 or DISPLAY with a V in the picture.

1
2
3
       01 WS-COUNT    PIC S9(4) COMP.   *> 2 bytes, -32768 to 32767
       01 WS-BIG      PIC S9(9) COMP.   *> 4 bytes, about ±2 billion
       01 WS-ID       PIC 9(5) COMP.    *> 2 bytes, 0 to 65535 (unsigned)

USAGE COMP-3 (Packed Decimal)

COMP-3 stores digits in packed form: two decimal digits per byte (each half-byte, or nibble, holds one digit). The rightmost nibble of the last byte holds the sign: hexadecimal C for positive, D for negative. So PIC S9(4) COMP-3 uses (4+1)/2 = 2.5 → 3 bytes (three bytes: two full digits in the first two nibbles of the first two bytes, then the last two digits and the sign in the third byte). PIC S9(5) COMP-3 uses 3 bytes. Packed decimal gives exact decimal arithmetic (no floating-point rounding) and is compact. It is commonly used for money and quantities on the mainframe. When you MOVE a COMP-3 field to a DISPLAY field, the compiler generates code to unpack and format it.

1
2
3
4
       01 WS-AMT     PIC S9(7)V99 COMP-3.  *> 5 bytes: 7+2 digits + sign
       01 WS-QTY    PIC 9(3) COMP-3.         *> 2 bytes: 3 digits (unsigned: F in last nibble)
 
       *> Value -1234 in S9(4) COMP-3: bytes X'1234D' (hex)

Sign Representation Compared

In DISPLAY, the sign is in the rightmost byte, overpunched with the last digit. In COMP/COMP-4, the sign is the high-order bit of the binary value. In COMP-3, the sign is the last nibble (C = positive, D = negative; F is sometimes used for unsigned). When you move data between formats (e.g. COMP-3 to DISPLAY), the compiler and runtime convert the representation so the logical value is preserved. If you REDEFINES a numeric field as alphanumeric and move it, you are moving bytes without conversion; the result is not a readable number.

Choosing a Representation

• Use DISPLAY for input/output buffers, screen fields, and report lines where human-readable form matters.
• Use COMP-3 for money, quantities, or any decimal value where you need exact arithmetic and compact storage.
• Use COMP/COMP-4 for integer counters, IDs, or heavy integer math when you do not need decimal places.
• Use COMP-1/COMP-2 only when you need floating-point (scientific or approximate); avoid for money.

Step-by-Step: Defining a Numeric Field for Money

1. Decide the maximum number of digits before and after the decimal (e.g. 9 digits before, 2 after).
2. Use PICTURE S9(9)V99 (or 7+2, etc.). The S allows negative; V fixes the decimal position.
3. Use USAGE COMP-3 for storage and arithmetic so the value is exact and compact.
4. When writing to a report or screen, MOVE the COMP-3 field to a DISPLAY or edited field (e.g. PIC with $, Z, comma) so it is formatted for display.

Best Practices

• Match USAGE between caller and subprogram (or document the conversion) when passing numeric parameters.
• Use COMP-3 for financial and decimal quantities; avoid floating-point for money.
• Use DISPLAY for any data that is read from or written to external sources (files, screens) in character form.
• Be aware of size and range: COMP has fixed sizes (2/4/8 bytes) by digit count; COMP-3 length is (n+1)/2 for n digits.

Test Your Knowledge