Reference format: columns, Areas A and B, free-form

A COBOL line that ends with + 1000000 can compile as + 10000. When the last two zeros sit in columns 73 and 74, the compiler drops them without a word, and a card limit meant to be 1,250,000 comes out as 260,000. Fixed-form COBOL is read by its columns, and a few of them decide what each line means.

Below you will take a fixed-form line apart column by column, use column 7 for comments, continuations and debugging lines, catch text that has slipped past column 72, and switch to free-form source, where the columns no longer count.

A fixed-form line has five areas, and each has one job

The reference formatreference format: The rules for where text goes on a line of COBOL source. Fixed form reads columns 7 to 72 of each line; free-form reads the whole line. fixes where text may go on a line of COBOL. In fixed form, IBM’s Language Reference divides each line into the sequence number areasequence number area: Columns 1 to 6 of a fixed-form line. They may hold a number or a label for the line, and the compiler skips them., columns 1 to 6, the indicator areaindicator area: Column 7 of a fixed-form line: a space for code, * or / for a comment, - for a continuation line and D for a debugging line., column 7, Area AArea A: Columns 8 to 11 of a fixed-form line, where division, section and paragraph names, FD entries and the level numbers 01 and 77 begin., columns 8 to 11, and Area BArea B: Columns 12 to 72 of a fixed-form line, which hold statements, clauses and the rest of each entry., columns 12 to 72. The compiler reads nothing after column 72. Each area has its own job:

Older programs still use the outer areas. This one carries a line number in columns 1 to 6 and a program tag, LAYOUT01, in columns 73 to 80 of every line but the first, a comment that works as a ruler, with a digit at every tenth column:

....+.*..1....+....2....+....3....+....4....+....5....+....6....+....7..
000100 IDENTIFICATION DIVISION.                                         LAYOUT01
000200 PROGRAM-ID. LAYOUT.                                              LAYOUT01
000300* Columns 1-6 hold card numbers, 73-80 a program tag.             LAYOUT01
000400 DATA DIVISION.                                                   LAYOUT01
000500 WORKING-STORAGE SECTION.                                         LAYOUT01
000600 01  ACCOUNT-ID       PIC X(6) VALUE "AC0001".                    LAYOUT01
000700 PROCEDURE DIVISION.                                              LAYOUT01
000800 SHOW-ACCOUNT.                                                    LAYOUT01
000900     DISPLAY "Account " ACCOUNT-ID                                LAYOUT01
001000     STOP RUN.                                                    LAYOUT01

The session prints both outer areas with cut, then builds the program, and builds a second one, misplaced.cob, with a statement that starts in Area A and a paragraph name in Area B:

from session import files, run

# A program in the old card layout, with numbers in columns 1-6 and a tag in 73-80, which cobc ignores; then a program
# with a statement in Area A and a paragraph name in Area B, which only the ibm dialect reports.
files("layout.cob", "misplaced.cob")
run("""
cut -c1-6 layout.cob | sed -n '2,4p'
cut -c73-80 layout.cob | sed -n '2,4p'
cobc -x layout.cob
./layout
cobc -x misplaced.cob && ./misplaced
cobc -x -std=ibm -o misplaced-ibm misplaced.cob
""")

$ cut -c1-6 layout.cob | sed -n '2,4p'
000100
000200
000300
$ cut -c73-80 layout.cob | sed -n '2,4p'
LAYOUT01
LAYOUT01
LAYOUT01
$ cobc -x layout.cob
$ ./layout
Account AC0001
$ cobc -x misplaced.cob && ./misplaced
Two lines in the wrong area
$ cobc -x -std=ibm -o misplaced-ibm misplaced.cob
misplaced.cob:5: warning: 'MAIN-PARA' should start in Area A [-Wothers]
    3 |       * A statement that starts in Area A, and a paragraph name in B.
    4 |        PROCEDURE DIVISION.
    5 >            MAIN-PARA.
    6 |        DISPLAY "Two lines in the wrong area".
    7 |            STOP RUN.
misplaced.cob: in paragraph 'MAIN-PARA':
misplaced.cob:6: warning: start of statement in Area A [-Wothers]
    4 |        PROCEDURE DIVISION.
    5 |            MAIN-PARA.
    6 >        DISPLAY "Two lines in the wrong area".
    7 |            STOP RUN.
    8 | <EOF>

layout.cob compiled and printed Account AC0001, so the line numbers and the tags changed nothing. Enterprise COBOL never reads the numbers as code either, but its SEQUENCE option, on by default, checks that they ascend and reports a line that is out of order. misplaced.cob compiled too: GnuCOBOL’s default dialect does not check the areas at all. Only -std=ibm, whose dialect file turns areacheck on, warned that MAIN-PARA should start in Area A and that a statement started in Area A. Follow one line through the compiler, area by area:

Column 7 decides what kind of line it is

The indicator area holds one character, and IBM’s documentation gives each one a meaning. A space makes an ordinary line of code. An asterisk makes a comment line; a slash also makes a comment, and starts a new page of the compiler listing. A hyphen makes a continuation linecontinuation line: A fixed-form line with - in column 7 that carries on a word or literal from the line before. A continued literal keeps every blank up to column 72., which carries on a word or literal from the line before. A D makes a debugging linedebugging line: A fixed-form line with D in column 7. It is compiled only when debugging lines are switched on, by WITH DEBUGGING MODE or cobc -fdebugging-line, and is a comment otherwise., which is compiled only when debugging lines are switched on. This program uses all four:

....+.*..1....+....2....+....3....+....4....+....5....+....6....+....7..
       IDENTIFICATION DIVISION.
       PROGRAM-ID. INDICATORS.
      * An asterisk in column 7 makes this line a comment.
      / A slash is a comment too, and starts a new listing page.
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01  WS-MESSAGE   PIC X(70).
       PROCEDURE DIVISION.
           MOVE "Payment received, thank you for banking
      -        "with us." TO WS-MESSAGE
           DISPLAY "[" FUNCTION TRIM(WS-MESSAGE TRAILING) "]"
      D    DISPLAY "Debugging line: this ran"
           STOP RUN.

Line 10 opens a literal and stops in column 56 without closing it. Line 11 has a hyphen in column 7 and carries on the literal after its quote. Build the program twice, the second time with GnuCOBOL’s -fdebugging-line:

from session import files, run

# Column 7 at work: two kinds of comment, a continued literal and a debugging line, compiled without and with debugging lines.
files("indicators.cob")
run("""
cobc -x indicators.cob
./indicators
cobc -x -fdebugging-line -o indicators-debug indicators.cob
./indicators-debug
""")

$ cobc -x indicators.cob
$ ./indicators
[Payment received, thank you for banking                with us.]
$ cobc -x -fdebugging-line -o indicators-debug indicators.cob
$ ./indicators-debug
[Payment received, thank you for banking                with us.]
Debugging line: this ran

The comments did nothing, as comments should. The message has a long gap: an open literal runs to column 72, blanks included, so columns 57 to 72, 72 − 56 = 16 spaces, became part of it before with us. was added. The debugging line ran only in the second build. Writing WITH DEBUGGING MODE in the SOURCE-COMPUTER paragraph switches debugging lines on from inside the program, as IBM’s documentation describes it; the GnuCOBOL option does the same from outside and leaves the source untouched.

Text after column 72 disappears without an error

Here is the program from the opening. Line 9 used to fit inside column 72; then the base limit was renamed to a longer name, and the last two zeros of 1000000 slid into columns 73 and 74:

       IDENTIFICATION DIVISION.
       PROGRAM-ID. CARDLIM.
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01  WS-RETAIL-CUSTOMER-BASE-LIMIT PIC 9(7) VALUE 250000.
       01  WS-CARD-LIMIT                 PIC 9(7).
       PROCEDURE DIVISION.
      * The card limit is the base limit plus 1000000.
           COMPUTE WS-CARD-LIMIT = WS-RETAIL-CUSTOMER-BASE-LIMIT + 1000000
           DISPLAY "WS-CARD-LIMIT = " WS-CARD-LIMIT
           STOP RUN.

Build it plainly, with the warnings you would try first, with two warnings together and with -Wextra, and then look at the file itself with a one-line awk check that prints whatever lies after column 72:

from session import files, run

# Two zeros past column 72: the program that loses them, the warnings that see them, and a check that shows them.
files("cardlimit.cob", "layout.cob")
run("""
cobc -x cardlimit.cob
./cardlimit
cobc -x -Wall -Wdangling-text -o cardlimit-wall cardlimit.cob
cobc -x -Wdangling-text -Wcolumn-overflow -o cardlimit-both cardlimit.cob
cobc -x -Wextra -o cardlimit-extra cardlimit.cob 2>&1 | sed -n '1p'
awk 'length > 72 { print FILENAME ":" FNR ": " substr($0, 73) }' cardlimit.cob
cobc -x -Wdangling-text -Wcolumn-overflow -o layout-both layout.cob 2>&1 | grep -c 'after program-text area'
awk 'length > 72 { print FILENAME ":" FNR ": " substr($0, 73) }' layout.cob | sed -n '1,3p'
""")

$ cobc -x cardlimit.cob
$ ./cardlimit
WS-CARD-LIMIT = 0260000
$ cobc -x -Wall -Wdangling-text -o cardlimit-wall cardlimit.cob
$ cobc -x -Wdangling-text -Wcolumn-overflow -o cardlimit-both cardlimit.cob
cardlimit.cob:9: warning: source text after program-text area (column 72) [-Wdangling-text]
    7 |        PROCEDURE DIVISION.
    8 |       * The card limit is the base limit plus 1000000.
    9 >            COMPUTE WS-CARD-LIMIT = WS-RETAIL-CUSTOMER-BASE-LIMIT + 100000..
   10 |            DISPLAY "WS-CARD-LIMIT = " WS-CARD-LIMIT
   11 |            STOP RUN.
$ cobc -x -Wextra -o cardlimit-extra cardlimit.cob 2>&1 | sed -n '1p'
cardlimit.cob:9: warning: source text after program-text area (column 72) [-Wdangling-text]
$ awk 'length > 72 { print FILENAME ":" FNR ": " substr($0, 73) }' cardlimit.cob
cardlimit.cob:9: 00
$ cobc -x -Wdangling-text -Wcolumn-overflow -o layout-both layout.cob 2>&1 | grep -c 'after program-text area'
9
$ awk 'length > 72 { print FILENAME ":" FNR ": " substr($0, 73) }' layout.cob | sed -n '1,3p'
layout.cob:2: LAYOUT01
layout.cob:3: LAYOUT01
layout.cob:4: LAYOUT01

The plain build printed WS-CARD-LIMIT = 0260000: 250,000 plus 10,000, not plus 1,000,000. -Wall with -Wdangling-text stayed silent. Only -Wdangling-text and -Wcolumn-overflow together, on GnuCOBOL 3.2, warned that line 9 has source text after the program-text area, and so did -Wextra, which turns on more warnings than -Wall. The awk check needs no compiler and shows the text itself: cardlimit.cob:9: 00. On layout.cob the same two warnings fired 9 times, once for every tagged line of code, because a tag is text after column 72 too; there the awk listing tells tags and lost digits apart at a glance. Step through what happened to line 9:

Free-form source drops the columns

Free-form source has no sequence area, no indicator column and no margin at 72: the GnuCOBOL manual says its program text starts in column 1 and runs to the end of the line, up to 255 characters. Comments start with *>, anywhere on a line. Here is the card-limit program again, in free-form, with line 9 at 92 characters:

*> Free-form source: no sequence area, no indicator column, no column 72.
IDENTIFICATION DIVISION.
PROGRAM-ID. FREEFORM.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-RETAIL-CUSTOMER-BASE-LIMIT PIC 9(7) VALUE 250000.
01 WS-CARD-LIMIT                 PIC 9(7).
PROCEDURE DIVISION.
    COMPUTE WS-CARD-LIMIT = WS-RETAIL-CUSTOMER-BASE-LIMIT + 1000000 *> the whole line counts
    DISPLAY "WS-CARD-LIMIT = " WS-CARD-LIMIT
    STOP RUN.

GnuCOBOL 3.2 decides the format by itself when you do not name one: its NEWS says it reads column 7 of the first line that is not blank. You can also name it, with -free or --fixed, or switch inside a file with the directive >>SOURCE FORMAT IS FREE. The session tries each, and the last build joins two short literals with &:

from session import files, run

# Free-form source: detected by cobc, chosen with -free, switched on inside a file with >>SOURCE FORMAT IS FREE, and a
# long literal built from two joined with &.
files("freeform.cob", "directive.cob", "joinlit.cob")
run("""
cobc -x freeform.cob
./freeform
cobc -x --fixed -o freeform-fixed freeform.cob 2>&1 | sed -n '1p'
cobc -x -free -o freeform-flag freeform.cob && ./freeform-flag
cobc -x --fixed directive.cob && ./directive
sed 's/^       >>SOURCE/>>SOURCE/' directive.cob > directive-col1.cob
cobc -x --fixed -o directive-col1 directive-col1.cob 2>&1 | sed -n '1p'
cobc -x -free joinlit.cob && ./joinlit
""")

$ cobc -x freeform.cob
freeform.cob:1: note: free format detected
    1 > *> Free-form source: no sequence area, no indicator column, no column 72.
    2 | IDENTIFICATION DIVISION.
    3 | PROGRAM-ID. FREEFORM.
$ ./freeform
WS-CARD-LIMIT = 1250000
$ cobc -x --fixed -o freeform-fixed freeform.cob 2>&1 | sed -n '1p'
freeform.cob:1: error: invalid indicator 'e' at column 7
$ cobc -x -free -o freeform-flag freeform.cob && ./freeform-flag
WS-CARD-LIMIT = 1250000
$ cobc -x --fixed directive.cob && ./directive
Free-form from line 3 on
$ sed 's/^       >>SOURCE/>>SOURCE/' directive.cob > directive-col1.cob
$ cobc -x --fixed -o directive-col1 directive-col1.cob 2>&1 | sed -n '1p'
directive-col1.cob:2: error: invalid indicator 'C' at column 7
$ cobc -x -free joinlit.cob && ./joinlit
[Payment received, thank you for banking with us.]

freeform.cob printed 1250000, the right limit, because nothing was cut. --fixed read its first line by the old columns and stopped at the e in column 7, which is not an indicator. directive.cob starts in fixed form and switches with the directive written from column 8; the copy with the directive in column 1 failed, because under --fixed cobc read that line by the columns too and found C, from SOURCE, in column 7. The dialects ibm and cobol2014 read fixed form by default, so the same rule applies under them. Side by side, the two formats differ in four ways:

Practise: columns, indicators and formats

Use the example files and their runs to answer. Practice starts with your weakest concept and explains every choice as soon as you check it:

Interview questions

Warm-up (fresher to 2–5 years): which areas make up a fixed-form COBOL line, and what goes in each?

A fixed-form line has five parts. Columns 1 to 6 are the sequence number area, once used to number the lines, which the compiler never reads as program text. Column 7 is the indicator area: a space for code, * or / for a comment, - for a continuation line and D for a debugging line. Columns 8 to 11 are Area A, where division, section and paragraph names, FD entries and the levels 01 and 77 begin. Columns 12 to 72 are Area B, for statements, clauses and the rest of each entry. Everything after column 72 is ignored, which leaves room for a tag in columns 73 to 80 and also means that code which runs past column 72 is cut off without an error: a literal 1000000 crossing the margin compiled as 10000.

Two harder questions follow, about a limit that shrank after a rename and about converting a code base to free-form. Note your own answer first, then open each first step:

Key takeaways

• A fixed-form line has a sequence number area in columns 1 to 6, the indicator in column 7, Area A in 8 to 11 and Area B in 12 to 72, and the compiler ignores everything after column 72.
• Column 7 holds * or / for a comment, - for a continuation line and D for a debugging line, and a continued literal keeps every blank up to column 72, 16 spaces in indicators.cob.
• Text after column 72 is dropped without an error, which turned 1000000 into 10000, and only -Wdangling-text with -Wcolumn-overflow, -Wextra or an awk listing shows it.
• GnuCOBOL’s default dialect does not check Areas A and B, while -std=ibm warns about a paragraph name or a statement in the wrong area.
• Free-form source uses the whole line and *> comments, and it is chosen by detection, with -free, or with >>SOURCE FORMAT IS FREE written where the current format reads it.