Cobol

11 March 2003
The Unit
• Delivered as IT52/IS22
• Lecturing by Richard Bland, practical support from Mr WS
Johnstone
• Unit co-ordinator: Richard Bland
• Email addresses etc are on the syllabus sheet
• Course materials will be placed on the WWW at appropriate
times as the unit proceeds
11 March 2003 IT52/IS22 COBOL 1
Teaching, Assessment, Textbook
• Daytime teaching
– 3 lectures per week, times on syllabus sheet
– 1 Practical session per week in 1A11 (starts week 3)
– 1 Tutorial per week (starts week 3)
– IT PGs have been allocated to groups, ISMs should see me
• Assessment
– A COBOL assignment (40%) and an exam (60%)
– Assignment date 3rd April
• Parkin, A. & Yorke COBOL for Students, 4th edition, Edward
Arnold, 1995
– or any other text based on the 85 standard
– if you buy MicroFocus COBOL (as used in this unit) for
your own machine, you get a reference manual as well
IT52/IS22 COBOL 1
11 March 2003
COBOL
• COBOL: COmmon Business-Oriented Language

– a language designed for commercial data processing
• That is: handling large amounts of data, normally a large number
of “records” with a regular structure
• “regular structure”: data are in fixed “fields” in the records:
123456789012345678901234567890 ..
Mr R Bland 7424
Mr CMIRattray 7429
– we talk about “the surname field” occupying “columns 8-27”
• COBOL is a language specifically designed for processing
fixed-format data with great speed and a high level of control
– accuracy, robustness, and control are very important
Some COBOL History
• COBOL is one of the oldest “third generation” languages

• It was developed in 1959 to replace machine code dependent
assemblers (about same time as FORTRAN)
• CODASYL committee: COnference on Data System Languages.
• Made up from Government agency reps
• Grace Hopper, who was on the committee, was the “mother” of
COBOL (and, on one version of the story, coined “bug”)
• First ANSI (American National Standards Institute) version was
COBOL 68, although it had been commonly used since 61
• COBOL became very popular in business. Led to 74, and 85
standards. The vast majority of COBOL programs in existence
today follow the 85 standard
IT52/IS22 COBOL 2
11 March 2003
Status Now
• 100+ billion of lines of COBOL exist today

• The is a considerable demand for COBOL programmers to work
on “legacy systems”
• (and in 1999 there was particular interest in ones that stored the
year in two digits ..)
• A great deal of development is still done in COBOL
– 5 billion lines of code per year?
• Several companies make version for PCs, UNIX, and other
operating systems.
• Still the choice for a business oriented language
• The new standard ("2002+") contains proposals for OO features:
but we shall focus on classic COBOL
COBOL 85 compared with the ALGOL family
• No block structure: all variables global

• Procedures ("Methods") are parameterless (unless externally
linked)
• Weaker typing
• Numbers: much closer to human arithmetic
– stress on length of number
– numbers decimal not floating-point
• I/O record oriented not stream oriented
• No recursion
• “Bigger” (because facilities not packaged as libraries)
IT52/IS22 COBOL 3
11 March 2003
Programming in COBOL compared with Java
• There are a number of differences in the paradigm

– a new way of thinking is required (not OO)
• COBOL is closer to the machine
• In terms of data:
– before the steps of the program, we reserve all the memory
that we shall need (instead of asking for new objects
dynamically)
– we think of memory as contiguous bytes (instead of hardly
thinking of memory at all)
• In terms of program flow:
– instead of an implied loop through events (e.g. waiting for a
mouse click), we explicitly program a loop through the input
data
The COBOL that we shall use
• We shall use the MicroFocus Personal COBOL for Windows,

running on the machines in 1A11 and CS labs
• This offers an environment (“Animator”) in which the program
can be edited and tested
• Notice that we shall not be producing executables, but MF .int
files
– these can be run by Animator
– or by special MF shells (RunW and RunFront)
• Personal COBOL offers features that we shall not be using
– Facilities to build programs that use the Windows GUI
– OO facilities that anticipate the forthcoming standard
• So we shall restrict ourselves to COBOL 85, with terminal i/o in
a plain text window
IT52/IS22 COBOL 4
11 March 2003
An aside: The set-up of your environment
• The names of files in the MS enviroments (MS-DOS, Windows

3.1, 95, 98, NT) usually end with a dot and three characters: the
extension)
• Windows allows you to hide these: but some people think that it
is better to be able to see the extensions
– you set this using the options under View in an Explorer
window (next slide)
• Each extension can be “associated” with one application
– for example, .ppt is usually associated with MS
PowerPoint
• If there is an association
– the file displays the icon of the application
– and that application starts when the icon is double-clicked
Aside continued: File extensions

• (It is easy to be confused by this,
and think that a file with a .ppt
extension “is a PowerPoint file”
– it should be, but isn’t
necessarily)
• The lab machines are set up thus:
– .cbl is associated with
Animator
– .int is associated with RunW
• So you ought to see appropriate
behaviour when you double-click
their icons
IT52/IS22 COBOL 5
11 March 2003
Hello, world
• Here’s a complete COBOL program:

* This is a demonstration program
*
PROCEDURE DIVISION.
DISPLAY "Hello, world"
STOP RUN.
– (we shall see later that each line starts with six blanks)
• We could either:
– Put this text in a plain ASCII file called (say) hello.cbl
(using any simple text editor, such as Notepad) and then
double-click the file’s icon to bring up Animator
– Bring up Animator from the Start button, and type in the text
directly, then save the file from Animator
• Let us try some of that:
Hello, world in Animator
• We can compile the program (using the button with a tick on it,
or through the Compile/Run menu)
– if there are errors, we can edit and recompile (Animator will
always save an altered file before recompilation)
• If Animator is open in Edit+Execute mode, then we can run the
program: otherwise we close, & reopen the file in Execute mode
IT52/IS22 COBOL 6
11 March 2003
Hello, world (continued)
• Animator puts the output into a plain black window

– to see it, you may need to cycle round the windows using alt-
tab
• We can step or free-run
• And we can set breakpoints
• We shall see later that we can inspect the values of variables as a
run proceeds
Layout of lines of code

• Before we look at the specific features of hello, a note about
the layout of a 74 standard program
– COBOL programs were typically entered on punched cards
(one program line = one punched card). It was a catastrophe
if the deck got dropped, and so the cards had sequence-
numbers punched on them in columns 1-6. (A dropped deck
could then be restored using a counter-sorter.)
– Column 7 was the indicator-area: '*' for a comment, '-' for a
continuation line (with e.g. a long text constant split across
the continuation)
– Columns 8-11 was Area A, where division, section and
paragraph names had to start (and some level numbers,
discussed later)
– Columns 12-72 were for everything else in the code
– Columns 73-80 were alternative locations for card-numbers
IT52/IS22 COBOL 7
11 March 2003
Layout of lines of code (continued)
• When disks got big and cheap enough, programs were held on
disk and the need for the above format disappeared
– non-standard formats appeared
• However, Animator preserves the special nature of columns 1-7
and 73-80
• I shall (try to) show program examples with the first six
characters omitted, and using Area A and Area B conventionally
• Some more points about the program text

– The full-stops are significant. And double-quotes (not single
quotes) in a standard-conforming program.
– We see two statements and one sentence. The full-stop
terminates a sentence.
– What terminates a statement?
– Not newline (can be split across lines)
– Can be some explicit terminator (full-stop, END-something) ...
– or the start of a new statement
– Comma and semicolon followed by space are equivalent to
space. This can be put to good or bad effect
ADD bonus overtime TO pay
ADD bonus, overtime TO pay
DISPLAY ; "Hello World", , STOP ; RUN.
IT52/IS22 COBOL 8
11 March 2003
• Yet more points about the program text

– Sentences can be grouped into (named) paragraphs (later).
(Our Procedure Division, above, has a single anonymous
paragraph.)
– Paragraphs into (named) sections (later)
– then divisions. Here we see the Procedure Division. This is
always present. In a program conforming to the 74 standard,
all four divisions must be present.
COBOL: That is data processing - I.E. D.P.

* This is a demonstration program
*
IDENTIFICATION DIVISION.
* (This division could be replaced by comments)
PROGRAM-ID. Hello.
AUTHOR. Richard Bland.
DATE-WRITTEN. February 3rd 2003.
ENVIRONMENT DIVISION.
CONFIGURATION SECTION.
SOURCE-COMPUTER. Viglen-Genie.
OBJECT-COMPUTER. Viglen-Genie.
DATA DIVISION.
PROCEDURE DIVISION.
DISPLAY "Hello, world"
STOP RUN.
– This has an empty Data Division because the program has no

variables. However ...
IT52/IS22 COBOL 9
11 March 2003
Answer, Echo, Answer

IDENTIFICATION DIVISION.
PROGRAM-ID. Echo.
AUTHOR. Richard Bland.
DATE-WRITTEN. February 3rd 2003.
*
DATA DIVISION.
WORKING-STORAGE SECTION.
77 x PIC 999.
*
PROCEDURE DIVISION.
DISPLAY "Please enter a number"
ACCEPT x
DISPLAY "That number was ", x
STOP RUN.
• We see that a variable is declared and used
• We can get Animator to show its current value
An echo from the East Indies

// Read a number from the keyboard and echo it
//
import java.io.*;
public class Echo {
public static void main(String[] args) {
String line ;
int x ;
BufferedReader br =
new BufferedReader(new
InputStreamReader(System.in)) ;
System.out.print("Please enter a number:") ;
try {
line = br.readLine() ;
x = Integer.parseInt(line) ;
System.out.println("That was " + x) ; }
catch (Exception e)
{System.out.println(e.getMessage()) ; }
} // main
} // class
IT52/IS22 COBOL 10
11 March 2003
Echo: syntax
• The statements in the Procedure Division are typical: they

consist of (imperative) verbs followed by (mainly) nouns and
prepositions
FEED cat
PUT canary INTO cage.
• We can use syntax formats or diagrams to describe all parts of
COBOL. In these notes I’ll use formats, as in (e.g.) Appendix D
of Parkin and Yorke. I’ll use italic for these
ACCEPT ident [FROM name]
• Caps for words to be entered as-is, l/c for an element to be
replaced
ACCEPT x
Syntax (continued)
• Square brackets enclose optional parts

ACCEPT x FROM DAY-OF-WEEK
* Integer from 1 (Mon) to 7, returned by system
• Underline indicates that word must be present if element is used.
DISPLAY { ident | literal} ... [WITH NO
ADVANCING]
DISPLAY "Enter a number" NO ADVANCING
• Curly brackets with a vertical bar indicate a choice
DISPLAY x
DISPLAY 42
DISPLAY "Goodbye"
• Three dots (ellipsis) indicate that the previous element can be
repeated as often as you like
DISPLAY "The number was" x ", was it not?"
IT52/IS22 COBOL 11
11 March 2003
Declaring variables
• Let us now turn to the Data Division of echo
DATA DIVISION.
77 x PIC 999.
• Before the detail, let's look at the big picture. The Data Division
of any COBOL program can consist of three Sections: File,
Working-Storage and Linkage. We shall not deal with the last.
The first two relate to COBOL's model of data movement.
COBOL's data model
• Parkin Figure E1
Data Division
File Section
Input File Input Record Output Record Output File
READ WRITE
Working-Storage Section
IT52/IS22 COBOL 12
11 March 2003
COBOL's data model (continued)

• In the echo program we used the low-volume verbs ACCEPT
and DISPLAY, used for terminal I/O
• The high-volume, file-related verbs are READ and WRITE
• In the general case, data movement is as follows:
– Input data are transferred to an input area which is
essentially a map of the input record.
– Output data are similarly written from an area which is a
map of the desired output record.
– The output area is built up in two ways: by moving data
from the input directly; and by moving data to working-
storage, transforming it and moving it to the output area
• We shall see examples later on. In the case of the present
example, we had no File Section because we had no files.
Returning to echo's Data Division

DATA DIVISION.
77 x PIC 999.
• This says that we are declaring a variable x. It is "at level 77":
which means that it has no internal structure and no defined
relationship to any other variable. The PIC clause shows that it
is numeric, integer, and can hold numbers 0-999. It occupies 3
locations in memory.
• If we experiment:
4 That number was 004
41. That number was 041
• It is not always easy to grasp what ACCEPT/DISPLAY are doing.
But a guess that three digits were being stored would be correct.
IT52/IS22 COBOL 13
11 March 2003
An Aside about ACCEPT
• With MF (but not all COBOLs), ACCEPT into a numeric always

produces a numeric. Consider the echo program:
Keyed Value Stored
123 123
12 012
1 001
– so far so good. But:
12X 012
1XY 001
ZXY 000
• This behaviour is defensible, but not much help if you want to
check user input. One possible solution involves constructs that
we shall cover later. For the moment, concentrate on dealing
with genuinely-numeric input.
First look at the PIC clause: decimal fractions

• If we were using READ the system would expect three digits
(possibly with leading blanks)
• In order to handle decimal points:
DATA DIVISION.
77 x PIC 99V9.
• This means that a decimal point is implied at the indicated
position. It is not held in the variable: and indeed it does not
appear on the output.
4.9 That number was 049
• We shall see later how to edit to obtain less brutal output.
IT52/IS22 COBOL 14
11 March 2003
First look at the PIC clause: signed numbers
• How about a sign?

77 x PIC S999.
• In this case the sign is stored in the same locations as the digits
(in an implementation-dependent way)
• There is an optional phrase:
[[SIGN IS] { LEADING | TRAILING } [SEPARATE
CHARACTER]]
• So we can write
77 x PIC S999 SIGN IS LEADING SEPARATE.
now the number is stored in four locations
• Instead of (e.g.) 9999999 we can write 9(7)
First look at the PIC clause: alphabetic and alphanumeric
• We have been looking at “simple” PIC clauses (as opposed to

edited ones, later). There are three types: numeric (as above),
and
• alphabetic ('A' - 'Z' and 'a' - 'z')
PIC AAAAA
PIC A(5)
• alphanumeric (any characters)
PIC XXXXX
PIC X(5)
IT52/IS22 COBOL 15
11 March 2003
Name-formation and constants
• We called our variable 'x'. In fact we can use up to 30

characters, using letters, digits, and hyphen (not first or last)
Pay-Rate
payrate
PayRate
Day-7
watch out for the reserved words! (Count)
• Alpha constants in double-quotes.
• There are symbolic constants (“figurative constants”)
ZERO ZEROS ZEROES SPACE SPACES
HIGH-VALUE LOW-VALUE
– so the following are equivalent:
MOVE 0 TO I
MOVE ZERO TO I
Constants continued, and VALUE

or
MOVE " " TO NAME
MOVE SPACES TO NAME
• In Working-storage only, we can declare-and-initialise
77 x PIC 999 VALUE IS ZERO.
77 Vat-Rate PIC 99V9 VALUE IS 17.5 .
• Question: why is it only in Working-storage that we can declare-
and-initialise?
IT52/IS22 COBOL 16
11 March 2003
More verbs
• We shall return to data-declaration and data-structures, but for

the next few slides we look at some new Procedure Division
verbs
• The arithmetic verbs: we start with ADD (and spend quite a long
time on it)
• We can have ADD-TO and ADD-GIVING
ADD { ident | literal } ...
TO {ident [ROUNDED]} ...
– ident is a variable-name, literal is a constant
– where does the result go??
ADD 1 TO Kount
ADD Vat TO Price
ADD Vat, Delivery TO Price
ADD 1 TO Kount, Stack-Ptr
ADD Vat TO Price ROUNDED
ADD (continued)
– rounding is to the number of decimal places specified in the
PIC of the result. 5 and over rounds up.
• The ADD-GIVING version is
ADD {ident | literal} ...
GIVING {ident [ROUNDED]} ...
• (We can have an optional TO before the final input operand. I
have omitted this in the syntax.)
• In both cases, the ellipsis in the result comes after the optional
ROUNDED. So we can construct a total in number of different
ways: to different precisions and with/without rounding
ADD x,y,z GIVING Int-Ans ROUNDED, Real-Ans
• Let's write a complete program:
IT52/IS22 COBOL 17
11 March 2003
A complete ADD example

* Addition
*
DATA DIVISION.
77 a PIC 99V999 VALUE 1.777 .
77 b PIC 99V99 VALUE ZERO .
77 c PIC 9V9 VALUE 5.5 .
77 d PIC 9V9 VALUE 5.5 .
PROCEDURE DIVISION.
ADD a TO b ROUNDED
DISPLAY "b is ", b
ADD c TO d
DISPLAY "d is ", d
STOP RUN.
What the example does
• The output is
b is 0178
d is 10
• The value for b is correct, but something nasty has happened to
d. What is the problem?
• It is this:
– the numbers to be added are aligned on their decimal points
– added
– and then moved to the result variable
– which in this case is too small
• In fact the syntax is more complicated: in both cases we can
have SIZE ERROR clauses
IT52/IS22 COBOL 18
11 March 2003
SIZE ERROR clauses

ADD { ident | literal } ...
TO {ident [ROUNDED]} ...
[ON SIZE ERROR imperative-statement]
[NOT ON SIZE ERROR imperative-statement]
[END-ADD]
– imperative-statement can be several statements
– To terminate this series of statements we use either full-stop
(74) or END-ADD (85).
– Let us first program on the assumption that any size error
should stop the program:
Add example (continued)

PROCEDURE DIVISION.
ADD a TO b ROUNDED
ON SIZE ERROR
DISPLAY "Size Error" ; STOP RUN
END-ADD
DISPLAY "b is ", b
ADD c TO d ON SIZE ERROR
DISPLAY "Size Error" ; STOP RUN
END-ADD
DISPLAY "d is ", d
STOP RUN.
• The output is
b is 0178
Size Error
IT52/IS22 COBOL 19
11 March 2003
ADD example in 74 style
• The 74 style with full-stops is a bit more succinct.

PROCEDURE DIVISION.
ADD a TO b ROUNDED
ON SIZE ERROR
DISPLAY "Size Error" ; STOP RUN.
DISPLAY "b is ", b
ADD c TO d ON SIZE ERROR
DISPLAY "d is ", d
STOP RUN.
• We could also anticipate later material about program structure
(“performing a paragraph”):
ADD example using PERFORM

PROCEDURE DIVISION.
Main-para.
ADD a TO b ROUNDED
ON SIZE ERROR
PERFORM Add-Error.
DISPLAY "b is ", b
ADD c TO d
ON SIZE ERROR
PERFORM Add-Error.
DISPLAY "d is ", d
STOP RUN.
Add-Error.
• This example introduces
– paragraph-names (note full-stops)
– the idea that we can ask for a paragraph to be PERFORMed:
that is, control passes to the code in the paragraph
IT52/IS22 COBOL 20
11 March 2003
The ADD example using NOT
• Alternatively we could program so that any size-error is non-

fatal
PROCEDURE DIVISION.
ADD a TO b ROUNDED
ON SIZE ERROR DISPLAY "Size Error"
NOT SIZE ERROR DISPLAY "b is ", b
END-ADD
ADD c TO d
ON SIZE ERROR DISPLAY "Size Error"
NOT SIZE ERROR DISPLAY "d is ", d
END-ADD
STOP RUN.
• There's no absolute "best way": it depends on circumstances.
Defensive programming
• Should we always test for size errors?

DATA DIVISION.
77 c PIC 9V9 .
77 d PIC 9V9 .
77 e PIC 99V9 .
PROCEDURE DIVISION.
...
ADD c, d GIVING e
• This can never have a size error
• - but suppose a later change alters the PICs of the input variables
• A sense of proportion must be kept: but bitter experience teaches
us the value of testing for “impossible” errors
– “Can’t happen” messages
IT52/IS22 COBOL 21
11 March 2003
SUBTRACT
• Subtract is very similar. First, the version without GIVING
SUBTRACT { ident | literal} ...
FROM {ident [ROUNDED]} ...
– The total of the values on the left is subtracted from each of
the variables on the right
SUBTRACT Tax, Insurance, Sports, Union FROM Pay
SUBTRACT 1 FROM Loop1, Loop2
• Then the version with GIVING
SUBTRACT { ident | literal} ...
FROM { ident | literal}
– The total of the values on the left is subtracted from a single
value, and the result is stored, possibly in several variables
SUBTRACT (continued)
SUBTRACT a, b, c FROM 100 GIVING d

• Notice that with ADD-GIVING the TO was optional, but with
SUBTRACT-GIVING the FROM is compulsory
• Rounding can be used as with ADD
• We can also have the same size error clauses, and can terminate
the statement with END-SUBTRACT in the same style as with
ADD
• But do we need size error clauses? Surely subtracting something
always gives you a result smaller than the value you started
with?
IT52/IS22 COBOL 22
11 March 2003
MULTIPLY
• Versions with and without GIVING

MULTIPLY {ident | literal}
BY {ident [ROUNDED]} ...
– A single value on the left is used to multiply each of a
number of variables on the right
MULTIPLY {ident | literal}
BY {ident | literal}
– Two values are multiplied together and the result is stored,
possibly in several variables
MULTIPLY x BY y GIVING z ROUNDED, w
• We can have size error clauses and END-MULTIPLY
DIVIDE
DIVIDE {ident | literal}
INTO {ident [ROUNDED]} ...
• A single value on the left is divided-into each of a number of
variables on the right
DIVIDE {ident | literal}
INTO {ident | literal}
• A value is divided into another value and the result is stored,
possibly in several variables.
DIVIDE 2 INTO x GIVING y, z
• We can write this the other way round using BY
DIVIDE x BY 2 GIVING y, z
• Can have size error clauses and END-DIVIDE (and REMAINDER)
IT52/IS22 COBOL 23
11 March 2003
Some of these are wrong

MULTIPLY Salary BY 2
MUTLIPLY Salary BY 2 GIVING Delirium, Ecstasy
MULTIPLY 2 BY Salary
DIVIDE Cake INTO 5
DIVIDE 3 INTO Gaul
ADD 5, 6, 8, 3, 7, 4, 5, 4, 7 GIVING Outward
SUBTRACT 1, 2, 1, 1, 2, 1, 2, 1, 1
FROM Outward GIVING Handicapped
MULTIPLY x ROUNDED BY y
MULTIPLY x BY y ROUNDED
ADD Mark-up AND Tax TO Net GIVING Gross
COMPUTE
COMPUTE { ident [ROUNDED] } ...

= arithmetic-expression
– with possible size error clauses and END-COMPUTE
• the arithmetic expression is constructed using the usual operators
(** to raise to a power) and brackets
• strictly, a space on either side of each operator: usually the
compiler only enforces this for minus (why?)
• evaluation follows the usual precedence and left-to-right rules
COMPUTE Celsius = (Fahrenheit - 32) / 1.8
COMPUTE Area = 3.1416 * Radius ** 2
• some programmers feel it is safer to carry out the calculation in
stages
IT52/IS22 COBOL 24
11 March 2003
Transfer of control: IF
IF Tax > 100 THEN

DISPLAY "Surely not"
ELSE
DISPLAY "Oh, all right"
END-IF
• We shall look at conditions soon.
• The word THEN is optional, as is the ELSE part: and END-IF
was introduced in the 85 Standard as an option
IF Tax > 100 DISPLAY "Rats" .
• But the use of END-IF is strongly recommended. (The full-stop
closes all open IFs and so some nested constructions cannot be
coded in a natural way if it is used)
IF (continued)
• Each branch can contain a sequence of statements. (But,

obviously, no full-stops)
• (The old NEXT SENTENCE construct is unnecessary post-85)
• Obviously, we should adopt some sensible indentation
convention (such as two spaces)
• We can nest Ifs
IF c1 THEN
IF c2 THEN
s1
ELSE
s2
END-IF
ELSE
s3
END-IF
IT52/IS22 COBOL 25
11 March 2003
Matching ELSE with its IF

• In that example, we could omit the END-IFs
IF c1 THEN IF c1 THEN
s1 s1
ELSE ELSE
s2 s2
END-IF ELSE
ELSE s3 .
s3
END-IF
• The version on the right has the same effect and is shorter...
• This temptation should be firmly resisted. Consider the
example on the next slide
Catastrophe caused by omitting inner END-IF
• The indentation suggests that the programmer thinks that these

two fragments are equivalent: but (s)he is wrong
s1 s1
END-IF ELSE
ELSE s2 .
s2
END-IF
• The ELSE is matched with the closest un-elsed IF.
• Moral: always put in the END-IFs
• (Note: for the equivalent of a C or Java switch (Pascal CASE)
see EVALUATE on Slide 174)
IT52/IS22 COBOL 26
11 March 2003
Transfer of control: Out-of-line PERFORM

• Using PERFORM is a bit like using a Java method
PROCEDURE DIVISION.
Main-para.
PERFORM Greeting
PERFORM Doit
PERFORM Sign-Off
STOP RUN.
Doit.
ACCEPT x
DISPLAY "That number was " x .
Greeting.
DISPLAY "Hello".
Sign-off.
DISPLAY "Goodbye".
• The blocks of code are terminated by full-stop-followed-by-new-
paragraph-name (or by end of program text)
Out-of-line PERFORM, continued

• When the flow of control encounters PERFORM
– control passes to the paragraph to be performed (like a jump)
– but the system remembers where we jumped from
– and at the end of the paragraph we jump back to the
statement after the PERFORM
• So the example on the previous slide is equivalent to
PROCEDURE DIVISION. Greeting
DISPLAY "Hello".
Doit ACCEPT x
DISPLAY "Goodbye".
STOP RUN.
Sign-off
IT52/IS22 COBOL 27
11 March 2003
Benefits of out-of-line PERFORM
• The example on the last two slides shows (in a trivial example)
how we can obtain clarity by moving details into subsidiary
paragraphs
• The first paragraph then corresponds to a top-level description of
the algorithm. We refer to this as the “main paragraph”
– for example, many programs have a three-phase structure:
initialise, process, tidy-up
* This is the Procedure Division's first para
Main-para.
PERFORM Start-up
PERFORM Process-data
PERFORM Tidy-up
STOP RUN.
* The code for the three paragraphs follows
Global variables
• However, procedures / functions / methods in Pascal / C / Java /

Fortran can have private variables
• and we can pass parameters to them, applying them to particular
objects
// draw circle at (10,10), radius 2
mycircle.draw(10,10,2) ;
• In COBOL, on the other hand, all paragraphs share the same

variables. All variables are “global”
• Instead of passing parameters, we initialise the variables that we
know that the paragraph will use, and perform the paragraph.
On return, we use the variables as modified by the paragraph
• There should always be comments at the top of each paragraph
to say what variables are used and which are changed
IT52/IS22 COBOL 28
11 March 2003
Out-of-line PERFORM (continued)
• On Slide 54, the paragraphs were in an order that showed that

control does not simply fall through from paragraph to paragraph
• Here’s an extension of PERFORM
PROCEDURE DIVISION.
Main-para.
PERFORM Greeting THROUGH Sign-off.
STOP RUN.
Greeting.
DISPLAY "Hello".
Doit.
DISPLAY "Please enter a number" .
ACCEPT x .
Sign-off.
DISPLAY "Goodbye".
• We can spell THROUGH as THRU
Order of execution of COBOL paragraphs
• In C, Java, Pascal, Fortran (etc) the only way of entering a

procedure/function/method is by an explicit call
– and whenever we leave it, we return to the point after the call
• In COBOL, too, we can PERFORM a paragraph, in which case
– when we get to the end of the called paragraph we return to
the point after the call
• But in COBOL we can also execute a paragraph just by falling
off the end of the paragraph before, in which case we don't
return anywhere: we just fall into the next paragraph
• The next slide has an unlikely but possible arrangement that
illustrates these two possibilities
IT52/IS22 COBOL 29
11 March 2003
Order of execution (continued)
PROCEDURE DIVISION.
Main-para.
DISPLAY "Main-para".
A.
DISPLAY "A".
B.
DISPLAY "B1"
PERFORM A
DISPLAY "B2".
• What is the order of execution?
• So: we executed paragraph A twice
– the first time we fell into it (and so we fell out of it when it
was finished)
– the second time we jumped into it with PERFORM (and so we
jumped back when it was finished).
Order of execution: STOP

• Programs don’t always need STOP
– because they will stop anyway if they are about to go past
the last line
– so we only need as explicit STOP if the program is meant to
stop at some earlier point
– as in, say, Slide 54
• But STOP is normally a useful visual clue. We might expect to
find it at the end of a “main-para” or a “closedown” para
IT52/IS22 COBOL 30
11 March 2003
Nested Out-of-line PERFORMS

• Of course, the code executed as a result of a PERFORM may itself
contain PERFORM.
Main-para. Main-para.
... ...
PERFORM A PERFORM A THRU C
STOP RUN. STOP RUN.
A. A.
... ...
PERFORM B PERFORM B
... ...
B. B.
... ...
C.
...
• These are nested PERFORMs
– while PERFORMing A, we PERFORM B
Nested Out-of-line PERFORMS (continued)

• We say that the range of a PERFORM is all the statements
executed as the result of the PERFORM.
• The rule for nesting: the range of the inner must lie entirely
outside the range of the outer (left-hand example) or entirely
within it (right-hand example)
• The ranges must not overlap, or share the same end point.
• (MF COBOL does not enforce this rule, and it even allows
recursion (a procedure that calls itself). But this is very non-
standard.)
• (We can speculate where the rule comes from: it allows the
implementer to do the returns by patching the code at run-time.)
IT52/IS22 COBOL 31
11 March 2003
Out-of-line PERFORM : loops
• There are three other optional additions: these give us various

types of loop
[num TIMES]
[UNTIL condition]
[VARYING ident FROM num BY num UNTIL condition]
– num is an integer variable or constant
– we shall look at conditions in detail later
– “until” here describes a test that (by default) is done at the
top of the loop (a “leading” test)
PERFORM Read-Line 2 TIMES
PERFORM Read-Line UNTIL End-File = "Y"
PERFORM Add-up VARYING i FROM 1 BY 1
UNTIL i > 10
Types of loop
• The use of these is obvious:

• If you don’t need a loop variable inside the loop
– For a condition-controlled loop, equivalent to while, use
plain UNTIL condition
– For a count-controlled loop, use plain num TIMES
• But if you do need a loop variable inside the loop, use VARYING
• As an example, let’s compute factorials:
1! is 1
2! is 2*1 = 2
3! is 3*2*1 = 6
– factorials are used in all sorts of ways (for example, in
computing probabilities)
– they get very big!
IT52/IS22 COBOL 32
11 March 2003
PERFORM-VARYING
* Form factorial n
DATA DIVISION.
77 i PIC 99.
77 n PIC 99.
77 fact PIC 99999.
PROCEDURE DIVISION.
DISPLAY "Enter n: " WITH NO ADVANCING
ACCEPT n
MOVE 1 TO fact
PERFORM Mult-para VARYING i FROM 1 BY 1
UNTIL i > n
DISPLAY n, "! is ", fact
STOP RUN.
Mult-para.
MULTIPLY i BY fact
ON SIZE ERROR
DISPLAY "Overflow”
STOP RUN
END-MULTIPLY.
Loops (continued) : In-line PERFORM
• In the 74 Standard, repeatedly performing a paragraph was the

only form of loop
• But the 85 Standard introduced in-line loops. Here the code-
sequence follows the verb.
PERFORM UNTIL No-more = "Y"
...
END-PERFORM
PERFORM VARYING i FROM 1 BY 1 UNTIL i > 10

...
END-PERFORM
• If the body of the loop is fairly small, then use in-line code
IT52/IS22 COBOL 33
11 March 2003
Sample program: count-controlled out-of-line loop

* Average of five numbers read from keyboard
DATA DIVISION.
77 x PIC 999.
77 average PIC 999.
77 total PIC 9999.
77 i PIC 9.
*
PROCEDURE DIVISION.
Main-para.
MOVE ZERO TO total
PERFORM Read-para 5 TIMES
DIVIDE 5 INTO total GIVING average ROUNDED
DISPLAY "Average is " average
STOP RUN.
Read-para.
* Read a number from a line and add to "total"
DISPLAY "Please enter a number: "
WITH NO ADVANCING
ACCEPT x
ADD x TO total.
Sample program re-written with in-line loop
• We can re-write this to use in-line code

PROCEDURE DIVISION.
Main-para.
MOVE ZERO TO total
PERFORM 5 TIMES
DISPLAY "Please enter a number: "
WITH NO ADVANCING
ACCEPT x
ADD x TO total
END-PERFORM
DIVIDE 5 INTO total GIVING average ROUNDED
DISPLAY "Average is " average
STOP RUN.
• In this case (because the code is short) the in-line version is
probably clearer
IT52/IS22 COBOL 34
11 March 2003
Loops (continued): trailing test
• Leading tests are far more common than trailing tests

• We can obtain a trailing test (Pascal REPEAT-UNTIL, or C (or
Java) do-while) by inserting the optional element WITH TEST
AFTER
* Perform at least once
PERFORM Body-para
WITH TEST AFTER UNTIL Got-one = "Y"
* Perform 0 to n times
PERFORM Body-para
VARYING i FROM 1 BY 1 UNTIL i > n
* Perform at least once
PERFORM Body-para
WITH TEST AFTER
VARYING i FROM 1 BY 1 UNTIL i = n
Writing conditions (simplified)
• Conditions can be simple or complex.. Here are two “simple”

ones:
Tax = 42
Tax NOT > 100
• Paradoxically, complex ones are easy: they are just simple ones
connected with AND OR brackets and NOT
Tax > 100 AND NOT (Age > 65)
• “Simple” ones are quite complicated to describe:
– Relation
– Class
– Condition-name
– (Sign (redundant: can use relation))
– (Switch-status (specialised))
IT52/IS22 COBOL 35
11 March 2003
Relation conditions
• These have the form:

arith-exp rel-op arith-exp
– arith-exp is “arithmetic expression”: in the simplest case,
just a variable name or a constant
Tax
42
(Net + Markup) * 1.175
– a rel-op is a “relation operator”: > >= = < <= possibly
preceded by NOT (examples on previous slide)
– These can be spelled out in words if you like
Age >=21
Age IS GREATER THAN OR EQUAL TO 21
– and there are multiple forms like EXCEEDS
The evaluation of relation conditions
• If both operands are simple numeric, ordinary rules apply

• If both are non-numeric, then
– compare chars l-to-r
– pad shorter with trailing spaces (unlike e.g. C)
– use collating sequence implied (native) or specified in
OBJECT-COMPUTER paragraph
• If mixed (!)
– if the numeric is integer then it’s treated as a sequence of
characters
– otherwise it is an error (but it’s not clear where this error is
detected: the MF compiler doesn’t fault it)
– but these are shady dealings anyhow
IT52/IS22 COBOL 36
11 March 2003
Class condition
• The class condition has the form

ident IS [NOT] class-name
• the predefined class-names are NUMERIC, ALPHABETIC,
ALPHABETIC-LOWER and ALPHABETIC-UPPER
77 Month PIC AAA.
PROCEDURE DIVISION.
DISPLAY "Please enter a month, JAN to DEC”
ACCEPT Month
IF Month NOT ALPHABETIC-UPPER
DISPLAY "Wrong Format" ; STOP RUN
END-IF
• This is useful, but the example is rather crude in its approach.
We can do better using condition-names
Condition-names
• An (elementary) variable can have an associated variable called

a condition-name. We regard the condition-name as being true
or false: that is, the name itself is (all of) a simple condition
IF valid-data THEN ...
• The mechanism is best explained through an example:
77 Month PIC AAA.
88 Valid-Month VALUE "JAN" "FEB" "MAR"
"APR" "MAY" "JUN" "JUL"
"AUG" "SEP" "OCT" "NOV" "DEC".
PROCEDURE DIVISION.
DISPLAY "Please enter a month, JAN to DEC"
ACCEPT Month
IF NOT Valid-Month
DISPLAY "Wrong Format" ; STOP RUN
IT52/IS22 COBOL 37
11 March 2003
Condition-names (continued)
• We can associate several condition-names with a variable

77 Lottery-number PIC 99.
88 L-num-unlucky VALUE 13.
88 L-num-date VALUE 1 THRU 31.
88 L-num-invalid VALUE 0, 51 THRU 99.
PROCEDURE DIVISION.
DISPLAY "Please enter a lottery number, 1-50"
ACCEPT Lottery-number
IF L-num-invalid
DISPLAY "That's not a valid number"
ELSE
DISPLAY "That's a valid number"
IF L-num-date
DISPLAY "Everyone chooses birthdays"
END-IF
IF L-num-unlucky
DISPLAY "Lucky for some!"
END-IF
END-IF
Loop and condition-name
• We can put together several pieces of the preceding material:

77
Lottery-number PIC 99.
88 L-num-valid VALUE 1 THRU 50.
PROCEDURE DIVISION.
Main-para.
PERFORM Get-num
DISPLAY "That was ", Lottery-number
STOP RUN.
*
* Return valid Lottery-number, obtained from
* the keyboard
Get-num.
PERFORM WITH TEST AFTER UNTIL L-num-valid
DISPLAY "Enter a lottery number, 1-50"
ACCEPT Lottery-number
IF NOT L-num-valid
DISPLAY "Wrong format"
END-PERFORM.
IT52/IS22 COBOL 38
11 March 2003
Group and elementary
• So far, we have seen only two level-numbers, 77 and 88. 77 was

used for unstructured working-storage, 88 for condition-names
• Data in a COBOL program are more usually arranged in a
hierarchy:
Student-record
Student-number Student-name Degree-scheme
Year Seq Surname Initials Title
Hierarchical data
• The terminal nodes of the tree are elementary items: single

variables each with a PIC (and hence a type defined by that PIC)
• The interior nodes of the tree are group items. They do not have
PICs and are all of type “alphanumeric” (even though they may
be entirely composed of numeric items)
• The length of an elementary item can be deduced from its PIC
• The length of a group item is the sum of the lengths of its
components
IT52/IS22 COBOL 39
11 March 2003
Level-numbers
• We declare these structures using level-numbers 01 to 49

– reserving 01 for complete records (the top level)
– leaving gaps (01, 05, 10, etc) to allow for possible definition
of intermediate layers later
– 01 in Area A, others in Area B
• All items immediately subordinate to a given item should be
declared with the same level number
Declaration of hierarchical data in records

DATA DIVISION.
01 Student-record.
05 Stu-num.
10 Stu-num-year PIC 99.
10 Stu-num-seq PIC 9(5).
05 Stu-name.
10 Stu-name-surname PIC X(20).
10 Stu-name-inits PIC X(3).
10 Stu-name-title PIC A(4).
05 Stu-degree PIC X(6).
• How long is the whole record?
• It makes no sense to say ADD 1 TO Stu-num (and the compiler
should say so)
• It makes complete sense to say DISPLAY Student-record
IT52/IS22 COBOL 40
11 March 2003
Declaration of records (continued)
• We can declare constant parts of records (in working-storage)

01 Student-record-out.
05 Stu-num.
10 Stu-num-year PIC 99.
10 PIC X VALUE ":" .
10 Stu-num-seq PIC 9(5).
• In pre-85 programs, these anonymous elementary items were all
given the name FILLER
10 FILLER PIC X VALUE ":" .
• In fact, we can have a record that is all fillers
Declaration of records (continued)

01 Column-headings.
05 PIC A(7) VALUE "NUMBER".
05 PIC A(8) VALUE SPACES.
05 PIC A(4) VALUE "NAME".
05 PIC A(6) VALUE "DEGREE".
• Then DISPLAY Column-headings will output headings in the
right places for (the first version of) the student record
IT52/IS22 COBOL 41
11 March 2003
MOVE (first look)
• Coming from an Algol-family background we tend to think of

MOVE as being just assignment: but there is more to it than that.
MOVE {ident | literal} TO ident ...
• We speak of the source and receiving items. What happens in
the move is determined by their types. (Remember that a group
item is alphanumeric)
• If source and receiving items are both alphabetic or
alphanumeric, then the item is left-justified in the receiver and
space-filled or truncated as necessary
• Note the figurative constant ALL literal
MOVE ALL "*~" TO Out-line
MOVE (continued)
• If source and receiving items are both numeric,

– align the decimal point
– truncate/zero-fill at each end
– if receiver is unsigned, it gets absolute value
• It is possible to have moves between numeric and alphanumeric
- the transmitted item must be an integer
• Examples of moves
N-var PIC 999V99 .
A-var PIC X(6) .
MOVE 12 TO N-var 01200
MOVE "Ed" TO A-var Ed____
MOVE 1234.567 TO N-Var 23456
MOVE "Edinburgh" TO A-Var Edinbu
IT52/IS22 COBOL 42
11 March 2003
Corresponding
• There is a wonderful extension of MOVE. First we have to re-
visit our data declarations
• The names of data-items need not be unique: they must only be
unique within their wider group-item.
01 Home-address.
05 Street PIC X(20).
05 Town PIC X(20).
05 Postcode PIC X(8).
01 Work-address.
05 Street PIC X(20).
05 Town PIC X(20).
05 Postcode PIC X(8).
• We make references unique by qualification by OF or IN
MOVE "FK9 4LA" TO Postcode OF Work-address
Corresponding (continued)
• The amazing move:

MOVE CORRESPONDING group-item1 TO group-item2
• The move is between all pairs of elementary items within the
two groups that match in name (and are 01-49 and not FILLER)
01 Student-record.
05 Stu-name.
* etc
01 Student-out.
05 Stu-name.
10 PIC X VALUE SPACE.
10 PIC X VALUE SPACE.
IT52/IS22 COBOL 43
11 March 2003
Corresponding (continued)
• Assuming we have data in Student-record (from a file,
perhaps) we could say
MOVE CORRESPONDING Student-Record
TO Student-out
DISPLAY Student-out
• This example shows that the fields can be re-arranged in the two
group-items
• Also, there need not be a complete correspondence: fields (on
either side) that do not match are just ignored
• This kind of MOVE is very powerful, but
– you can lose track of what is copied and what is ignored
– it can involve the use of lengthy identifiers (as we shall see)
Files: Overview
• As in most programming languages, a file will have an external

name, governed by the conventions of the host system (e.g.
Transact.dat)
• But within the program it will be referred to by an internal name,
governed by the conventions of the language (e.g.
Transact-file)
• The two are connected at a single point in the code
• In COBOL this happens in the Environment Division.
• Thereafter we use the internal name
– Declaring the structure of the record(s) in the Data Division
– and using the verbs OPEN, READ, WRITE and CLOSE in the
Procedure Division
IT52/IS22 COBOL 44
11 March 2003
Reading a (sequential) file: example plus commentary
• Starting with the Environment Division:

INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT File-in ASSIGN TO "Input.dat"
ORGANIZATION IS LINE SEQUENTIAL.
– The SELECT connects the internal name to the external
– The external name here is a literal: if your OS is case-
sensitive, be very careful!
– Or could be a symbolic reference (set by the OS: e.g. in an
environment variable).
– Or we can have ASSIGN DYNAMIC with an alpha variable
(so we could e.g. capture the filename from the keyboard))
Reading a file: example plus commentary (continued)

– organiZation
– Line sequential is an MF feature. It makes “... your COBOL
system ... compatible ... with the editor software in any ...
system.” You must use this clause on MF for the PC. On
most systems you can miss out the ORGANIZATION clause
• Now the Data Division:
DATA DIVISION.
FILE SECTION.
FD File-in.
01 Student-record.
05 Stu-num.
Etc
• The FD prefaces the declaration of a record that will act as an
input buffer. Note the use of the internal name
IT52/IS22 COBOL 45
11 March 2003

– We have (exactly) one FD for each file referenced in the
Environment Division
– but we can have one or more descriptions at the 01 level for
that FD. We would have this if we expected records in
several different formats. It is an implicit redefinition of the
input buffer for this file (but the lengths may vary)
• Now we have any working-storage declarations. These will
include variables to keep track of the status of our file(s)
01 Flags.
05 File-in-eof-flag PIC A VALUE "N".
88 File-in-ended VALUE "Y".
• On to the Procedure Division. Here we shall open the file, read
to the end, and close it

• The syntax of OPEN
OPEN [INPUT internalname ...]
[OUTPUT internalname ...]
[EXTEND internalname ...]
OPEN INPUT File-in
• This opens the file and positions it at the start.
• Now we must construct a read loop. Central fact: the only way
we can tell if we are at EOF is by trying to read: a Cobol READ
will either read a record or detect EOF. We need to implement
the following algorithm:
read
while not at EOF
process record just read
read
IT52/IS22 COBOL 46
11 March 2003

• The syntax of READ
READ internalname [INTO ident]
[AT END imperative-statement]
[END-READ]
– why is the INTO part optional? Because the data is always
read into the associated buffer (i.e. all the 01 records under
the FD): this merely gives us the option of having another
copy somewhere else
– if the actual data read is too long, error
– if it is too short, then the remainder of the buffer is (usually)
unaltered (MF line sequential will space-fill)
– imperative-statement can be several statements (remember to
terminate the sequence!
– If EOF but no AT END, error
• We shall put our READ into its own paragraph (because it’s
quite a long bit of code and we need it twice)
Read-record.
READ File-in
AT END
MOVE "Y" TO File-in-eof-flag
CLOSE File-in
END-READ.
• (Remember that the flag has an associated condition-name: we
shall use that to control the read loop)
• Here’s the whole of the Procedure Division:
IT52/IS22 COBOL 47
11 March 2003
Main-para.
OPEN INPUT File-in
PERFORM Read-record
PERFORM UNTIL File-in-ended
* Process the record (just display)
DISPLAY Student-record
PERFORM Read-record
END-PERFORM
STOP RUN.
Read-record.
READ File-in
AT END
CLOSE File-in
END-READ.
More than one type of input record
• We saw above that there can be several 01 definitions under a

single FD
• Suppose our input data look like this:
19712345Davidson
21997A31311A
21997A46113C
19912345Wilkinson-Smyth
22000S31322A
22000S46122B
22000S31322F
• There are two kinds of record
• Header records start with ‘1’, detail records start with ‘2’
– Headers have registration-number and name
– Details have semester, unit-code and grade
IT52/IS22 COBOL 48
11 March 2003
More than one type of input record (continued)
• We give an 01 definition for each

DATA DIVISION.
FILE SECTION.
FD Students-file.
01 Header-rec.
05 Rec-type-H PIC X.
88 Is-header VALUE IS "1".
05 Regno PIC 9(7).
05 Student-name PIC X(30).
01 Detail-rec.
05 Rec-type PIC X.
05 Semester PIC X(5).
05 U-code PIC X(4).
05 Grade PIC XX.
• There is only one buffer area for the input record (38 bytes long)
• The two 01s give different identifiers for the same area
More than one type of input record (continued)

PROCEDURE DIVISION.
OPEN INPUT Students-file
PERFORM Read-S-record
PERFORM UNTIL S-file-ended
IF Is-header
DISPLAY Regno, " ", Student-name
ELSE
DISPLAY " ", Semester, " ",
U-code, " ", Grade
END-IF
PERFORM Read-S-Record
END-PERFORM
STOP RUN.
* Read-S-Record follows ...
9712345 Davidson
1997A 3131 1A
1997A 4611 3C
9912345 Wilkinson-Smyth
2000 S3132 2A
2000 S4612 2B
2000 S3132 2F
IT52/IS22 COBOL 49
11 March 2003
Writing a (sequential) file
• Writing a file doesn’t introduce much new material.

WRITE recordname [FROM ident]
– notice the potentially confusing (but necessary) fact that
READ references a (internal) filename but WRITE references
a record (one of those specified under an FD). The system
writes to the file associated with that record
– the optional FROM part gives us an implied move which
takes place before the write. The ident must not be part of
the file’s record-area
– the contents of the record-area are “unavailable” after the
write
– trailing spaces are removed in Line Sequential
Demonstration: read, transform, write
FILE-CONTROL.
SELECT File-in ASSIGN TO "Input.dat”
SELECT File-out ASSIGN TO "Output.dat”
DATA DIVISION.
FILE SECTION.
FD File-in.
01 Student-record.
* etc
FD File-out.
01 Student-out.
* etc
IT52/IS22 COBOL 50
11 March 2003
Demonstration: read, transform, write (continued)
01 Flags.
PROCEDURE DIVISION.
Main-para.
OPEN INPUT File-in
OUTPUT File-out
PERFORM Read-record
MOVE CORRESPONDING Student-record
TO Student-out
WRITE Student-out
PERFORM Read-record
END-PERFORM
CLOSE File-out
STOP RUN.
* Read-record para just as before
Edited PICs
• We have seen how to read structured input and write structured

output
• So far, all our PIC clauses have been “simple”. These were all
we needed for input: but our output was very crude.
• The basic idea of “editing” : we MOVE data from a variable with
a “simple” PIC to a variable with an “edited” PIC, and this
causes formatting to take place. (Or as the target of GIVING)
• This extends the action of MOVE, adding to its power
– but the basic principle remains the same: the effect of MOVE
is determined by the types of the source and receiving items
– the 85 Standard introduced “de-editing” - moves from edited
items to simple items
IT52/IS22 COBOL 51
11 March 2003
Simple example of editing

DATA DIVISION.
01 Variables.
05 Simple PIC 999.
05 No-zero PIC ZZ9.
PROCEDURE DIVISION.
DISPLAY "Please enter a number”
ACCEPT Simple
MOVE Simple TO No-zero
DISPLAY "Original o/p was '", Simple,
"', edited format is '", No-zero,
"'"
• The Z editing character gives “zero-suppression”
Please enter a number
4
Original o/p was '004', edited format is ' 4'
Editing in detail: Alphanumeric edited

• Alphanumeric PICs contain Xs
• Alphanumeric edited PICs contain, additionally, one or more of
B / 0 (zero). These are insertion characters that are added
during a move.
05 Date-1 PIC XX/XXX/XXXX.
05 Date-2 PIC XXBXXXBXXXX.
MOVE "25Feb1998" TO Date-1, Date-2
will give 25/Feb/1998 and 25 Feb 1998 in the target
variables
• Notice that we can still calculate the width of a variable. These
are 11 locations long. This is a general point: we can always
work out how long an item is
IT52/IS22 COBOL 52
11 March 2003
Editing in detail: Numeric edited

• Numeric PICs contain S 9 V
• Numeric edited PICs don't (usually) contain S V , but do
contain, additionally, one or more of a range of other characters
that control the formatting.
• Editing takes places as a result of a MOVE to a numeric-edited
item, or as the result of GIVING
• A numeric-edited data item is not numeric - the only
meaningful things you can do with it are:
– move it to an alphanumeric
– output it
– you cannot do arithmetic with it
Numeric edited in detail

The characters in numeric edited PICs are:
• , B / 0 (zero). (Simple insertion characters)
05 Num-1 PIC 9,999,999.
05 Num-2 PIC 9B999B999.
MOVE 1000000 TO Num-1, Num-2
will give 1,000,000 and 1 000 000 in the target variables
(more on comma later)
• the special insertion character full-stop. This replaces V and
causes an actual full-stop to appear in the result
05 DP-raw PIC 9V99 .
05 DP-edited PIC 9.99 .
DIVIDE 1 BY 100 GIVING DP-raw, DP-edited
will give 001 (numeric) and 0.01 (non-numeric) in the target
variables (more on full-stop later)
IT52/IS22 COBOL 53
11 March 2003
Numeric edited in detail (continued)

• £ + - DB CR as fixed insertion characters. (I am using £ to
indicate currency-sign (see Slide 110).) These are fixed because
– plus or minus must be first or last in the PIC
– DB or CR must be last in the PIC
– £ must be first, or after plus or minus
05 Balance-out PIC £999.99BDB .
* Debit is 200 and Balance is 100
SUBTRACT Debit FROM Balance GIVING Balance-out
will give £100.00 DB in the target variable
• if the result is +ve then only plus is inserted: the others are
replaced by space(s).
• if the result is -ve then plus is inserted as minus: the others are
inserted as themselves
Numeric edited in detail (continued)

• If we have repeated £ + - then these are floating insertion
characters, “floating” because the symbol “floats” to the right, to
the first non-zero digit, with spaces coming in from the left
05 Balance-out PIC £££9.99BDB .
* Debit is 100 and Balance is 105.75
SUBTRACT Debit FROM Balance GIVING Balance-out
will give __£5.75___ in the target variable (showing blanks
as underscores for clarity)
if Debit is 110 and Balance is 105.75 then we get
__£4.25_DB
• Z * are the zero-suppression characters. They cause leading
zeros to be replaced by space or asterisk
05 Cheque-amount PIC £**9.99 .
IT52/IS22 COBOL 54
11 March 2003
CURRENCY SIGN
• The compiler’s definition of the character which is the currency-

symbol in PIC clauses can be set by the programmer
SPECIAL-NAMES.
CURRENCY SIGN IS "£".
• You must do this before using a symbol other than the
compiler’s default (probably dollar)
• There are rules about the permissible characters
– obviously, £ and $ are both allowed (can be “L” in 85)
More on comma
• More on comma: if floating or suppression would leave a

floating or suppression character to the left of a comma, then the
comma is replaced by the floating or suppression character
05 Demo PIC Z,ZZZ,ZZ9.
If (say) 1 is moved to this, then we get ________1 and not
_,___,__1
IT52/IS22 COBOL 55
11 March 2003
More on full-stop
• More on full-stop: full-stop terminates floating or suppression

05 Demo PIC ZZZ.ZZ .
If (say) 0.01 is moved to this, then we get ___.01 and not
___._1 or _____1
but if item would otherwise be all blank then that’s what we

get: if zero is moved to Demo, then we get ______ and not
___.__
Example of file input & editing

• Suppose an input file, calls.dat, contains details of individual
phone calls, by extension and cost (as £ to two decimal places)
7424 00005
7421 02795
7433 00096
• We wish to print this file, formatting the cost field
SPECIAL-NAMES.
CURRENCY SIGN IS "£".
FILE-CONTROL.
SELECT File-in ASSIGN TO "Calls.dat"
IT52/IS22 COBOL 56
11 March 2003
Example of file input & editing (continued)

DATA DIVISION.
FILE SECTION.
FD File-in.
01 Call-record.
05 Extension PIC 9999.
05 PIC X.
* Charge in £
05 Call-charge PIC 999V99.
01 Header.
05 PIC AAAA VALUE "Extn".
05 PIC XXXX VALUE SPACES.
05 PIC AAAA VALUE "Cost".
01 Print-record.
05 PIC X.
05 Call-charge PIC £££9.99 .
01 Flags.
Example of file input & editing (concluded)

PROCEDURE DIVISION.
OPEN INPUT File-in
PERFORM Read-record
DISPLAY Header
MOVE CORRESPONDING Call-record
TO Print-Record
DISPLAY Print-Record
PERFORM Read-record
END-PERFORM
STOP RUN.
* Read-record just as before
Read-record.
READ File-in
AT END
CLOSE File-in
END-READ.
IT52/IS22 COBOL 57
11 March 2003
Back to the Data Division - REDEFINES
• Any data item can be redefined. (This is equivalent to Pascal's

variant records or C's unions)
01 Client-record.
05 Client-name PIC X(20).
05 Client-currency PIC A(3).
05 Client-balance-stg PIC **,***.** .
05 Client-balance-yen
REDEFINES Client-balance-stg
PIC *,***,*** .
• This redefines the same area and so must be the same length
PROCEDURE DIVISION.
MOVE "Smith" TO Client-name
MOVE "GBP" TO Client-currency
MOVE 27.23 TO Client-balance-stg
DISPLAY Client-Record
REDEFINES (continued)
This gives the output
Smith GBP****27.23
• However, if we use the other identifier:
MOVE "Kawasaki" TO Client-name
MOVE "JYE" TO Client-currency
* 183 Yen to the £, and 27.23 * 183 = 4983
MOVE 4983 TO Client-balance-yen
DISPLAY Client-Record
Then we obtain
Kawasaki JYE****4,983
• Formal syntax is
level new-id REDEFINES old-id [pic-clause]
IT52/IS22 COBOL 58
11 March 2003
• Some rules:
– level numbers must be the same and with no lower number
intervening:
05 this
04 is
05 wrong REDEFINES this
– if in FILE SECTION, not 01 (same effect achieved with other
means, as we have seen)
– either/both item(s) can be elementary (as in the currency
example) or group
05 Weight-metric PIC 9V999.
05 Weight-imperial REDEFINES Weight-metric.
10 Weight-lbs PIC 99.
10 Weight-oz PIC 99.
– same original item can be redefined more than once
05 This PIC 99.
05 That REDEFINES This PIC AA.
05 Other REDEFINES This PIC XX.
– cannot redefine the redefinitions
05 This PIC 99.
05 That REDEFINES This PIC AA.
05 Wrong REDEFINES That PIC XX.
– redefinitions cannot have VALUE (why?)
IT52/IS22 COBOL 59
11 March 2003
Using REDEFINES with condition-name
• A neat technique for inspecting several variables (e.g. error

flags) is to redefine them against a condition-name:
01 Status-area.
03 Check-flags.
05 Check-fuel PIC A VALUE "N".
05 Check-icing PIC A VALUE "N".
05 Check-runway PIC A VALUE "N".
03 All-flags REDEFINES Check-flags PIC AAA.
88 All-OK VALUE "YYY".
• Now we can replace
IF Check-fuel = "Y" AND Check-icing = "Y" AND
Check-runway = "Y" THEN
– by
IF All-OK THEN
Still in the Data Division: OCCURS
• COBOL has a simple but powerful way of declaring arrays:

these are “tables”.
05 Monthly-takings OCCURS 12 TIMES PIC 999v99.
• The number-of-times must be a constant, of course (why?)
• This gives us a simple array of values. Subscripts start at 1.
Subscripting is easy (but round brackets)
* January’s total is in Gross
MOVE Gross TO Monthly-takings(1)
• The permissible subscript forms are:
integer-constant
integer-variable
integer-variable { + | - } integer constant
IT52/IS22 COBOL 60
11 March 2003
Simple one-dimensional table: example
* ENVIRONMENT DIVISION sets up £ as currency

DATA DIVISION.
01 Sales .
05 Month-takings PIC 999 OCCURS 12 TIMES.
77 Loop-var PIC 99.
77 Annual-total PIC 99999 VALUE ZERO .
77 Annual-total-out PIC £££££9 .
PROCEDURE DIVISION.
DISPLAY "Enter 12 sales figures”
* Read and store, form total on the fly
PERFORM VARYING Loop-var FROM 1 BY 1
UNTIL Loop-var > 12
ACCEPT Month-takings(Loop-var)
ADD Month-takings(Loop-var) TO Annual-total
END-PERFORM
MOVE Annual-total TO Annual-total-out
DISPLAY "Total is ", Annual-total-out
One-dimensional array of group item

• Any item (including a group item) can be declared with OCCURS
05 Airport-line OCCURS 4 TIMES.
10 Airport-code PIC A(3).
10 PIC X.
10 Airport-name PIC A(20).
• This is an array of records in Pascal, or an array of structs in C
• How would we initialise this? If it was a large or volatile table,
from a file. If small or static, we could use constants and
REDEFINES
IT52/IS22 COBOL 61
11 March 2003
Initialisation using REDEFINES
• We declare the same area twice, once with coarser structure and
constants, then again in full detail
DATA DIVISION.
01 Airports.
03 Airport-strings.
05 PIC A(24) VALUE "LHR*London Heathrow" .
05 PIC A(24) VALUE "LCY*London City" .
05 PIC A(24) VALUE "GLA*Glasgow" .
05 PIC A(24) VALUE "EDI*Edinburgh" .
03 Airport-table REDEFINES Airport-strings.
10 PIC X.
A simple table look-up
• Now let us try table look-up

77 A-code PIC A(3) .
77 Loop-var PIC 99.
PROCEDURE DIVISION.
DISPLAY "Enter an airport code"
ACCEPT A-code
PERFORM VARYING Loop-var FROM 1 BY 1
UNTIL Loop-var > 4
OR A-code = Airport-code(Loop-var)
* Might need CONTINUE here for loop body
END-PERFORM
IF Loop-var > 4
DISPLAY A-code, " not found"
ELSE
DISPLAY Airport-name(Loop-var)
END-IF
IT52/IS22 COBOL 62
11 March 2003
What are we subscripting?
• Notice in the previous example that we had a subscript in a

natural-seeming place, but surprising to a grammarian
Airport-name(Loop-var)
• This is surprising because Airport-name is the name of an
item that does not have OCCURS. It is shorthand for
Airport-name OF Airport-line(Loop-var)
Multi-dimensional tables
• We can declare multi-dimensional tables using our existing

tools:
01 Sales-Table.
05 Month-takings OCCURS 12 TIMES.
10 Branch-takings PIC 999
OCCURS 5 TIMES
VALUE ZERO.
• The order of the subscripts follows the order of declaration, e.g.
we refer to Branch-takings(Month,Branch)
• Of course, when we loop across the table we can choose which
subscript varies faster/fastest (next slide)
IT52/IS22 COBOL 63
11 March 2003
Looping across multi-dimensional tables
• This outputs month-within-branch: months as columns, branches

as rows
Show-table.
* Transpose sales table to save paper:
* display 5 rows each with 12 columns
PERFORM VARYING Bloop FROM 1 BY 1
UNTIL Bloop > 5
PERFORM VARYING Mloop FROM 1 BY 1
UNTIL Mloop > 12
DISPLAY " ", Branch-takings(Mloop,Bloop)
NO ADVANCING
END-PERFORM
DISPLAY " "
END-PERFORM.
Tables: indexing versus subscripting
• Refer back to Slide 122: we can add an extra phrase:

05 Airport-line OCCURS 4 TIMES
INDEXED BY Airport-idx.
10 PIC X.
– In that previous example, we now delete the (redundant)
declaration of the variable Loop-var and replace every
reference to it by Airport-idx
• Although superficially nothing has changed
– the format of indexing is just the same as subscripting (Slide
120)
– we drive the index using PERFORM VARYING just as
before
IT52/IS22 COBOL 64
11 March 2003
Tables: indexing versus subscripting (continued)
• But we are “indexing” and not “subscripting”. Indexing is safer

– the index cannot be declared too small
– the index cannot be driven out of range
– the compiler will not allow arithmetic to be done on the
index (indeed, how the index works is hidden: it may not be
an integer starting at 1)
– we can only use PERFORM VARYING and SET to change the
index ourselves
SET index-name ...
TO {index-name | ident | integer}
SET index-name ... { UP | DOWN }

BY {ident | integer}
Searching an indexed table
• Also, there is a built-in lookup that we can use on indexed tables

DISPLAY "Enter an airport code"
ACCEPT A-code
SET Airport-idx TO 1
SEARCH Airport-line VARYING Airport-idx
AT END
WHEN A-code = Airport-code(Airport-idx)
DISPLAY Airport-name(Airport-idx)
END-SEARCH
– You must initialise the index (so you can start anywhere in
the table)
– The condition can be any conditional expression
– There are two branches: each can contain several statements
– At the end of each branch, control passes out of the search
(so only the first matching occurrence is found)
IT52/IS22 COBOL 65
11 March 2003
Searching a sorted table
• The coding above is only a little easier than hand-coding (but is

safer). But a binary chop is much easier using the built-in
search. Remember binary chop?
– Order log(n) rather than Order n
– so (e.g.) 10 comparisons not 500 when searching 1000
• First we must specify the column on which the table is (to be)
sorted (the example in Parkin & Yorke, page 196, shows this
wrongly)
ASCENDING KEY Airport-code
Searching a sorted table (continued)

– Then we must ensure that the data actually are sorted on the
key column (e.g. by rearranging the lines of literals)
– now we can use the binary version:
SEARCH ALL Airport-line
AT END
WHEN Airport-code(Airport-idx)= A-code
DISPLAY Airport-name(Airport-idx)
END-SEARCH
– Here we neither set nor vary the index-variable
– the condition must have the form
WHEN key-col(index-var) = expression
– (or else be a condition-name, with a single value, on the key-
column)
IT52/IS22 COBOL 66
11 March 2003
Tables that aren’t full
• So far we have assumed that the table is completely occupied by

useful data
– this may not always be the case
• We may not know the exact number of entries at the time the
program is written (perhaps we are reading in the table from a
file)
– but in classic COBOL we cannot acquire space dynamically
• So we must take a guess at the maximum number of entries and
declare the table at that maximum size (OCCURS 10000 TIMES,
say)
• As we read the table from the file, we must count the rows as the
table is loaded
Reading a table from a file: declarations

FILE-CONTROL.
SELECT Air-File ASSIGN TO "airtable.dat"
DATA DIVISION.
FILE SECTION.
FD Air-File.
01 File-record.
10 Code-field PIC X(4).
10 PIC X.
10 Name-field PIC X(16).
01 Airports.
10 Airport-code PIC X(4) .
10 PIC X.
10 Airport-name PIC X(16).
05 Table-size PIC 99999.
IT52/IS22 COBOL 67
11 March 2003
Reading a table from a file: counting the rows as we read

PROCEDURE DIVISION.
* Initialise table
OPEN INPUT Air-file
MOVE ZERO TO Table-size.
* Now use standard read loop with read para
PERFORM Read-airport
PERFORM UNTIL Air-file-ended
ADD 1 TO Table-size
IF Table-size > 10000
DISPLAY "Too many airports in file”
STOP RUN
END-IF
MOVE File-record
TO Airport-line(Table-size)
PERFORM Read-airport
END-PERFORM
DISPLAY "Table of ", Table-size,
" lines built ..."
Tables that aren’t full, continued
• Now that we have built the table, we could write our own code
to search the table from 1 ... Table-size
• But how could we use the clever built-in SEARCHes?
• As it stands, they would search the whole of the declared space
of the table (all 10,000 rows) and not just the useful data
• The answer to this problem is DEPENDING ON
• So the full declaration of the table now is
DEPENDING ON Table-size
ASCENDING KEY Airport-code
10 Airport-code PIC X(4) .
10 PIC X.
10 Airport-name PIC X(16).
• Now the built-in searches will work correctly

IT52/IS22 COBOL 68
11 March 2003
Sorting
• We have already seen that COBOL has a built-in table-lookup.

It also has a built-in (external) sort. This can save a huge
amount of programming: the programming of external sorts is
non-trivial (very)
• Overview of the simplest sort of sort:
– we have an input file, and will generate an output file. We
declare these as before (but we need give only elementary
descriptions of the records)
– we must declare a working file, using SD (Sort-Merge file
description). The records of this file must be declared so
that the sort field(s) can be referenced
– We don’t need any i/o statements other than the sort verb
itself (or even anything else in the Procedure Division)
Basic sort: example
• We shall sort some live data: all 20,639 grades obtained in units
in Autumn 2002. This file is 314 Kbytes in size
• A few records:
1023197 NM77 2C
1023180 NM77 2B
1023176 NM77 2D
1023195 NM77 1B
• The file is in no particular order. Let's sort it on registration-
number within unit
IT52/IS22 COBOL 69
11 March 2003
Basic sort: example (continued)
• Remember, we need three files:

FILE-CONTROL.
SELECT File-in ASSIGN TO "Regist.dat”
SELECT File-out ASSIGN TO "Sorted.dat”
SELECT Work-file ASSIGN TO "Work.tmp".
• We don’t know (or need to know) how the work file is
organised; also, in some systems the external name of the work
file may be conventional

:
DATA DIVISION.
FILE SECTION.
FD File-in.
01 Registration-in PIC X(15).
FD File-out.
01 Registration-out PIC X(15).
SD Work-file.
01 Registration.
05 Stu-num PIC 9(7).
05 PIC A.
05 Unit-code PIC X(4).
05 PIC A.
05 Grade PIC X(2).
PROCEDURE DIVISION.
SORT Work-file
ASCENDING KEY Unit-code
ASCENDING KEY Stu-num
USING File-in
GIVING File-out
STOP RUN.
IT52/IS22 COBOL 70
11 March 2003
• Here’s (some of) the output file

0020575 0192 W
0011631 0192 2F
...
1123580 IT21 2B
1018350 IT31 1B
...
9954199 XXP7 H
• Sorting is of crucial importance for commercial DP
– classic sequential master-file/transaction-file merge (later)
– rapid access to data via indexes
Sorting plus user programming
• So far, the COBOL sort gives us little more than we could have
obtained from the system’s built-in sort (in MS-DOS, Unix ..)
• But we can add our own programming ..
• We can manipulate (even create) the records that are input to the
sort
• The USING filename part of the verb is replaced by
INPUT PROCEDURE IS proc1 [THRU proc2]
• The procs are the names of paragraphs (or sections) in the
Procedure Division. (Sections, as in Check-input SECTION. ,
are a way of giving the following paragraphs a collective name)
• This is sometimes called “own-coding” the input to the sort
IT52/IS22 COBOL 71
11 March 2003
Own-coding the input to a sort
• The basic idea is that our code repeatedly places values in the
fields of the work-file record and “releases” each new record to
be included in the sort. The form is
SORT workfile
ASCENDING KEY field
INPUT PROCEDURE IS para
GIVING outfile.
...
para.
<loop>
<form workfile record>
RELEASE <workfile record>
<end-loop> .
• It is as if the own-coding “writes” a sequence of records into the
input of the sort. Often it reads (another) file to get the data
Telephone bills
• Let us suppose that the University telephone exchange generates

a record for every outgoing call. These are of the form
– calling extension ; duration (minutes) ; cost-band of call (e.g.
local, national, international) ; [timestamp, etc]
7424 189 1 (189 minutes of local call(!))
7448 027 3 (27 minutes of international call)
7421 045 2
7424 026 1
7448 013 1
7421 156 2
7424 012 3
• We want to work out each extension’s bill (e.g. 7424 owes £2.87)
• As a first step in processing, we decide to
– compute the cost of each call
– sort by extension (this groups the data conveniently)
IT52/IS22 COBOL 72
11 March 2003
Telephone bills, continued
• Suppose the tariffs are

– local calls are 1.0p per minute; national calls 2.5p;
international 6.0p
• First, we want to work out the cost per call
7424 189 1 => 189 @ 1.0p => 7424 189.0p
7448 027 3 => 27 @ 6.0p => 7446 162.0p
7421 045 2 => 45 @ 2.5p => 7421 112.5p
...
– then we want to sort the records by extension
7421 112.5
7421 ...
...
7424 189.0
7424 ...
...
7446 162.0
7446 ...
...
Telephone bills: Own-coding the input
• We need three files, as before

FILE-CONTROL.
SELECT File-in ASSIGN TO "Calls.dat”
SELECT File-out ASSIGN TO "Sorted.dat”
DATA DIVISION.
FILE SECTION.
FD File-in.
01 Call-record.
05 PIC X.
05 Duration PIC 999.
05 PIC X.
05 Band PIC 9.
IT52/IS22 COBOL 73
11 March 2003
Telephone bills: Own-coding the input (continued)
FD File-out.
01 Call-out PIC X(9)
SD Work-file.
01 Call-charge-record.
05 Call-charge PIC 9999V9.
• We need a a table to give the cost for each band. In a real
application we would read this from a file
01 Tariff-bands.
05 Three-costs PIC X(12)
VALUE "010*025*060*".
05 REDEFINES Three-costs.
10 OCCURS 3 TIMES.
15 Tariff PIC 99V9.
15 PIC X.
• We need an item to keep track of the input file’s status (identical

to Slide 91)
01 Flags.
• Now we’re ready to go (cf Slide 140)
PROCEDURE DIVISION.
Main-para.
SORT Work-file
ASCENDING KEY Extension
OF Call-charge-record
INPUT PROCEDURE IS Compute-cost
GIVING File-out
STOP RUN.
IT52/IS22 COBOL 74
11 March 2003

• Remember, the task of Compute-cost is to create records to be
sorted and “release” them to the sort
Compute-cost.
OPEN INPUT File-in
PERFORM Read-record
MOVE Extension OF Call-record
TO Extension OF Call-charge-record
MULTIPLY Duration BY Tariff(Band)
GIVING Call-charge
RELEASE Call-charge-record
PERFORM Read-record
END-PERFORM.
• We see that the paragraph uses a conventional read-loop, just as
on Slide 95 (Read-record is identical, and not shown here)
• Comparing the input and output files, we see
7424 189 1 742101125 (45 @ 2.5)

7448 027 3 742103900
7421 045 2 742401890 (189 @ 1.0)
7424 026 1 742400260
7448 013 1 742400720
7421 156 2 744801620 (27 @ 6.0)
7424 012 3 744800130
• The results appear to be correct (if not very readable)

• But actually they are just an intermediate stage: we now wish to
aggregate the records to work out each extension’s bill.
• This involves own-coding of the output
IT52/IS22 COBOL 75
11 March 2003
Telephone bills: Own-coding the output
• As you might expect, there is quite a lot of symmetry with the

input side
– just as we replaced USING with INPUT PROCEDURE, we
replace GIVING with OUTPUT PROCEDURE (cf Slide 148)
PROCEDURE DIVISION.
Main-para.
SORT Work-file
ASCENDING KEY Extension
OF Call-charge-record
INPUT PROCEDURE IS Compute-cost
OUTPUT PROCEDURE IS Sum-bill
STOP RUN.
• So the paragraph Sum-bill will add-up the various calls made
by an extension
Telephone bills: Own-coding the output, continued

742101125 7421 £5.03
742103900
742401890 7424 £2.87
742400260
742400720
744801620 7448 £1.75
744800130
• We'll skip the details of the coding: but the main point is
– Sum-bill will “read” the sort’s output as if it were a file
– it has a read-loop, and detects end-of-file, in the same way
– except it uses the verb RETURN instead of READ
– just as input coding is like “writing into the sort”, so output
coding is like “reading from the sort”: RELEASE is like
WRITE , RETURN is like READ
IT52/IS22 COBOL 76
11 March 2003
Classic master/transaction processing
• The classic style of DP is based on batch processing. We

maintain master files: changes to these files (transactions) are
applied in batches. A batch of transactions are placed in an
update file
• The master is always sorted on unique key field(s)
• The update file(s) are sorted into order on the same key field(s):
may have several transactions for the same master record
• Then we read record-at-time, in order, keeping the files in step.
This means
– small memory requirement as very few records in memory
simultaneously
– efficient i/o because access to next record has low (average)
cost (probably already in memory)
On-line Transaction Processing
• We can contrast this with On-Line Transaction Processing

(OLTP) in which each transaction is applied to master record(s)
as soon as it is originated
• This means that all records in the master file(s) must be
accessible within a (very) short time: in practice we achieve this
by holding a much higher proportion of the file in memory
• Batch is computationally much cheaper (and in the early stages
of commercial DP was the only feasible approach)
• Batch is still a sound approach for applications where
– continuously updated masters are not needed (cost of phone
call so far this month)
– data is inherently cyclic (payroll, exam records)
IT52/IS22 COBOL 77
11 March 2003
Designing a batch application
• The application must be very robust: must survive all possible

abnormal data conditions and run to completion
• Must ensure that all data problems can be dealt with later
– by editing transaction records and re-running
– by appropriate administrative action (e.g. writing to the
customer)
• An error-log should be produced: also, it is useful to place the
aberrant transaction records in suspense files
• We can distinguish between errors in transaction records
– that can be detected in the absence of the master record:
record has wrong structure, contains invalid codes
– that can only be detected by reference to master record(s): no
such customer, customer exceeded credit limit
Designing a batch application (continued)
• The first kind can be dealt with in a first pass, using a stand-
alone program, generating its own error log and suspense file(s)
• Then we execute the main pass, merging transaction and master
files
Old master Pass 2 New master
Suspense file
Transaction file Pass 1
Log file
Suspense file
Log file
IT52/IS22 COBOL 78
11 March 2003
Classic merge of transaction and master
• Remember, both the transaction and master files are sorted (by
e.g. client-number)
• The transaction records will be of three types:
– update (so there should be a matching master record)
– insertion (there should not be a matching master record)
– deletion (there should be a matching master record)
• A neat solution must deal cleanly with the ends of the files: it
greatly simplifies the algorithm if we use sentinels: dummy extra
records with keys higher than any valid key
– so the Master, Transaction and Suspense files are all
maintained with sentinel records at the end
• It's neat if the suspense file is the error log as well
– containing the dud transactions plus error messages
A sample problem
• Assume Departments are charged for the cost of phone calls.

We have master records with four fields:
– Telephone extension
– Chargeable department
– “Owner” of the extension
– Current balance (pence: negative if Dept owes)
7332M&O Dept Office -01538
7370M&O Dr R Thomas -01033
7421CS&M Dept Office -00503
• Three kinds of transaction records:
– Deletions: 7370D (Delete extension 7370)
– Insertions: 7427ICS&M Dr RG Clark +00000
(Insert extension 7427)
– Updates: 7332U-00057 (Charge 7332 57 pence)
IT52/IS22 COBOL 79
11 March 2003
Sample run of batch update

Old master
Transaction
New master
7332M&O Dept Office -01538
7370M&O Dr R Thomas -01033 Suspense file
7421CS&M Dept Office -00503
7424CS&M R Bland -00287 7332U-00057
7448CS&M Dr SP Marsh -00175 7332U+00100
9999 7333U+00100
7335D+00100
7421ICS&M Dr Wibble +00000
7332M&O Dept Office -01495 7427ICS&M Dr RG Clark +00000
7370M&O Dr R Thomas -01033 7427U-00050
7421CS&M Dept Office -00503 7448D
7424CS&M R Bland -00287 7999X+00100
7427CS&M Dr RG Clark -00050 9999
9999
7333U+00100 No master, or files unsorted
7335D+00100 No master, or files unsorted
7421ICS&M Dr Wibble +00000 Duplicate extension
7999X+00100 Transact code not recognised
9999
Batch update, algorithm
• The algorithm for batch update is fairly easy if we only have

updates or deletions
read master and transaction files
while (m-id < sentinel or t-id < sentinel)
if (m-id > transaction)
write transaction to suspense
read transaction
else if (m-id = t-id)
if (update)
do update
read transaction
else // deletion
read master
read transaction
else
write master to new-master
read master
write sentinels to new-master & suspense
IT52/IS22 COBOL 80
11 March 2003
Files and OLTP
• So far, we have looked at files that are read serially, starting at

the beginning, as if they were on reel-to-reel tape
• Such files cannot support OLTP. For that we need direct access
• Of course, disc is inherently direct access: we have the h/w
• So we just need language features to support it
• COBOL, like e.g. C, supports access-by-position-in-file - in
COBOL’s case,
– this is called RELATIVE organisation
– access is by record position (1, 2, 3, ...) in the file
• If the record position is inherently meaningful (e.g. data on
Room1, Room 2 ...) then this is all we need
• But in most cases our key fields do not run 1, 2, 3, ...
Indexes
• The programmer must know how to map between features of

interest in the data (key values such as student number) and
position in file. This is an index
Index Main file
9900018 003 001 Smith ...
9905924 001 002 Jones ...
9907013 005 003 Robinson ...
... 004 Farquharson
005 Wu ...
...
• (Most of) the index is held in memory: (most of) the main file is
not.
IT52/IS22 COBOL 81
11 March 2003
Managing indexes
• Under such an arrangement, the programmer is responsible for

building and maintaining the index and for providing fast look-
up (e.g. binary search)
• This is non-trivial, especially if we allow inserts and deletions
• COBOL will do all this work for us. If we use INDEXED
organisation then the index becomes part of the file structure and
all operations on it are handled for us.
• The facilities are very easy to use
• Of course, we do not know how any particular COBOL system
implements them: but, in general, files of this kind can be
unbalanced by “lumpy” inserts so that the retrieval of some
records becomes slow
Loading an indexed file
• To avoid this, we load as high a proportion of records as possible

in one pass, in sorted order
• The easiest way of doing this is to adapt the basic sort of Slides
139-142. Not many changes are needed.
• Suppose that we want a file with one record per student, indexed
by registration number. Suppose that the (unsorted) input
records are up to 60 columns long, with the registration number
at the start, like this:
9755864 Ms ABCSmith ..
9943814 Mr DE Jones ..
9612537 MissAN Other ..
IT52/IS22 COBOL 82
11 March 2003
Loading an indexed file (continued)

* Create an indexed file
FILE-CONTROL.
SELECT File-in ASSIGN TO "idxin.dat"
SELECT File-out ASSIGN TO "idxout.dat"
ORGANIZATION IS INDEXED
ACCESS MODE IS SEQUENTIAL
RECORD KEY IS Stu-num.
DATA DIVISION.
FILE SECTION.
FD File-in.
01 Student-in PIC X(60).
FD File-out.
01 Student-out.
05 Stu-num PIC 9(7).
05 Text-field PIC X(53).
SD Work-file.
01 Student-work.
05 Work-num PIC 9(7).
05 Text-field PIC X(53).
Loading an indexed file (continued)
• Notes on the previous slide:

– Obviously, the key field must occur in an FD associated with
the file (PC MF requires it to be unique).
– This means that the record description of the output file has
to be expanded to show the key field.
• The Procedure Division still contains only the SORT verb
PROCEDURE DIVISION.
SORT Work-file
ASCENDING KEY Work-num
USING File-in
GIVING File-out
STOP RUN.
• The file thus created cannot (on most systems) be manipulated
by (e.g.) editors. But with ACCESS IS SEQUENTIAL we can
read (and, say, list) it using our existing COBOL techniques
IT52/IS22 COBOL 83
11 March 2003
Direct access to an indexed file
• To obtain direct access, we make a number of changes to the

methods we used with sequential files
– Change the SELECT to use ACCESS IS RANDOM
– In the Procedure Division, change the OPEN to use
OPEN I-O internal-name
• Now, to read a record from anywhere, we move the required key
value to the key field
MOVE 9712345 TO Stu-num
and then read. If successful, this will bring in the rest of
9712345’s data into the record.
READ internal-name
[INVALID KEY imperative-statement]
[NOT INVALID KEY imperative-statement]
[END-READ]
Direct access to an indexed file (continued)
• As usual, these are two possible branches each of which can

contain several statements
• It would be very bad practice not to code the “invalid” branch
(no-such-record)
• To write to the file: assemble data in the fields of the record and
either write (if the key value ought not to be in the file already)
or rewrite (if it should be)
[RE]WRITE record-name
[END-WRITE]
• Once again it would be bad practice not to code the “invalid”
branch (wrong assumption about existence of key)
IT52/IS22 COBOL 84
11 March 2003
Direct access to an indexed file (continued)
• We can delete: once again we move the required key-value to

the key-field before using:
DELETE internal-name
[END-DELETE]
• There are also facilities to START reading sequentially from any
point in the file
• All of the above can save a huge amount of programming
• Notice that it may be advisable to occasionally rewrite an
indexed file in one sequential pass. The new index will not have
any unbalanced parts that may have been present in the old one
Some useful verbs: EVALUATE

• At its simplest, EVALUATE is like the C/Java switch:
DISPLAY "Please enter a character"
ACCEPT c
EVALUATE c
WHEN "Y" DISPLAY "yes"
WHEN "N" DISPLAY "no"
WHEN OTHER DISPLAY "neither Y nor N"
END-EVALUATE
• As usual, there can be multiple statements in each branch
• But this just begins to scratch the surface of the verb
• The case values can be ranges
EVALUATE age
WHEN 0 THRU 16 DISPLAY "School"
WHEN 17 THRU 65 DISPLAY "Work"
WHEN OTHER DISPLAY "Retired"
END-EVALUATE
IT52/IS22 COBOL 85
11 March 2003
EVALUATE (continued)
• The cases can test different conditions

EVALUATE TRUE
WHEN NOT (sex="F" OR sex="M")
DISPLAY "Sex incorrect"
WHEN sex="F" DISPLAY "Woman"
WHEN age<35 DISPLAY "Young man"
WHEN OTHER DISPLAY "Old man"
END-EVALUATE
• In fact, EVALUATE is designed to encode Decision Tables
Inputs Action
Age Sex
0-16 Any “School”
17-60 Any “Work”
61-65 Male “Work”
Other “Retired”
EVALUATE (continued)
• Here's that table in COBOL

* Assume sex already checked as M or F
EVALUATE age ALSO sex
WHEN 0 THRU 16 ALSO ANY
DISPLAY "School"
WHEN 17 THRU 60 ALSO ANY
DISPLAY "Work"
WHEN 61 THRU 65 ALSO "M"
DISPLAY "Work"
WHEN OTHER DISPLAY "Retired"
END-EVALUATE
• The verb tries to match each row to the column-headings: it
executes the action of the first row that matches completely
• The decision table can have as many input columns as we like
• The action part can be a sequence of statements, terminated by
the next WHEN or by END-EVALUATE
IT52/IS22 COBOL 86
11 March 2003
String handling
• We’ll look at four string-handling topics: Reference

modification, INSPECT, STRING and UNSTRING
• The full syntax of the verbs is too complex to be given here, so
look them up if you want to see their full power
• Reference-modification: we can refer to part of a data item
– we add (start:length) to the original reference
05 News PIC X(20)
VALUE " Here is the news ".
DISPLAY News
DISPLAY News(2:4)
– produces
Here is the news
Here
– the start and length can be variables
String handling: INSPECT
• The INSPECT verb deals with characters within strings.

– INSPECT ... TALLYING counts occurrences of a character
or string
– INSPECT ... REPLACING changes occurrences of a
character or string to another character or string
– INSPECT ... CONVERTING maps one set of characters into
another
(these can be BEFORE or AFTER a specified substring)
INSPECT News TALLYING N-Chars FOR ALL SPACES
MOVE ZERO TO N-Chars
INSPECT News TALLYING N-Chars FOR CHARACTERS
BEFORE "news"
INSPECT News REPLACING ALL SPACES BY "_"
INSPECT News CONVERTING "_eristhnw" TO
"*ERISTHNW"
IT52/IS22 COBOL 87
11 March 2003
String handling: UNSTRING

• The UNSTRING verb splits up a long string into shorter strings
01 Strings.
05 News PIC X(20)
VALUE " Here is the news ".
05 W OCCURS 5 TIMES
PIC X(5).
UNSTRING News DELIMITED BY ALL SPACE INTO
W(1), W(2), W(3), W(4), W(5)
ON OVERFLOW
DISPLAY "Too many words"
STOP RUN
END-UNSTRING
– the delimiter can be any string
– the ALL option means that consecutive delimiters count as
one delimiter
– so W(1) contains spaces, W(2) contains "Here ", etc
String handling: STRING
• The STRING verb concatenates shorter strings into one long

string
MOVE SPACES TO News
STRING W(2), W(3), W(4), W(5)
DELIMITED BY SPACE INTO News
ON OVERFLOW
DISPLAY "Destination string too short"
STOP RUN
END-STRING
– this gives "Hereisthenews "
• The delimiter can be any string (or SIZE)
• We can have different delimiters for different strings
STRING W(2), W(3) DELIMITED BY SPACE
W(4), W(5) DELIMITED BY SIZE
INTO News
– this gives "Hereisthe news "
IT52/IS22 COBOL 88

Cobol

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Cobol

Uploaded by

Copyright:

Available Formats

11 March 2003

11 March 2003 IT52/IS22 COBOL 1

Teaching, Assessment, Textbook

11 March 2003 IT52/IS22 COBOL 2

• COBOL: COmmon Business-Oriented Language

11 March 2003 IT52/IS22 COBOL 3

Some COBOL History

• COBOL is one of the oldest “third generation” languages

11 March 2003 IT52/IS22 COBOL 4

• 100+ billion of lines of COBOL exist today

11 March 2003 IT52/IS22 COBOL 5

COBOL 85 compared with the ALGOL family

• No block structure: all variables global

11 March 2003 IT52/IS22 COBOL 6

Programming in COBOL compared with Java

• There are a number of differences in the paradigm

11 March 2003 IT52/IS22 COBOL 7

The COBOL that we shall use

• We shall use the MicroFocus Personal COBOL for Windows,

An aside: The set-up of your environment

• The names of files in the MS enviroments (MS-DOS, Windows

Aside continued: File extensions

11 March 2003 IT52/IS22 COBOL 10

• Here’s a complete COBOL program:

Hello, world in Animator

11 March 2003 IT52/IS22 COBOL 12

Hello, world (continued)

• Animator puts the output into a plain black window

11 March 2003 IT52/IS22 COBOL 13

Layout of lines of code

Layout of lines of code (continued)

11 March 2003 IT52/IS22 COBOL 15

Hello, world (continued)

• Some more points about the program text

11 March 2003 IT52/IS22 COBOL 16

Hello, world (continued)

• Yet more points about the program text

11 March 2003 IT52/IS22 COBOL 17

COBOL: That is data processing - I.E. D.P.

– This has an empty Data Division because the program has no

11 March 2003 IT52/IS22 COBOL 18

Answer, Echo, Answer

11 March 2003 IT52/IS22 COBOL 19

An echo from the East Indies

11 March 2003 IT52/IS22 COBOL 20

• The statements in the Procedure Division are typical: they

11 March 2003 IT52/IS22 COBOL 21

• Square brackets enclose optional parts

11 March 2003 IT52/IS22 COBOL 22

11 March 2003 IT52/IS22 COBOL 23

COBOL's data model

11 March 2003 IT52/IS22 COBOL 24

COBOL's data model (continued)

11 March 2003 IT52/IS22 COBOL 25

Returning to echo's Data Division

An Aside about ACCEPT

• With MF (but not all COBOLs), ACCEPT into a numeric always

First look at the PIC clause: decimal fractions

11 March 2003 IT52/IS22 COBOL 28

First look at the PIC clause: signed numbers

• How about a sign?

11 March 2003 IT52/IS22 COBOL 29

First look at the PIC clause: alphabetic and alphanumeric