Mainframe Tutorials

JCL

2010-03-08T08:00:00.000-08:00

1. Introduction

2. JCL Syntax
Syntax Rules
Job Statement
Accounting Information parameter :
Programmer’s Name :
MSGLEVEL parameter :
TheMSGCLASS parameter :
The Class Parameter :
The PRTY parameter
The TIME Parameter
The REGION parameter
The ADDRSPC parameter
The NOTIFY parameter
The RESTART parameter
The TYPRUN parameter

3. The EXEC statement
The REGION Parameter
The TIME parameter
The ADDRSPC parameter
The ACCT Parameter
The PARM Parameter
The COND Parameter

4. The DD statement
The DSN Parameter
The DISP Parameter
The UNIT Parameter
The VOL Parameter
The SPACE Parameter
The LABEL Parameter
The DCB Parameter
Instream Data
The SYSOUT Parameter
Concatenation
DUMMY Parameter
The JOBLIB DD Statement
The STEPLIB STATEMENT
STORAGE DUMP

5. Procedure
SYMBOLIC PARAMETERS & SYMBOLIC OVERRIDES
THE PROC STATEMENT
IN-STREAM PROCEDURES

6. Utility
IEFBR14 UTILITY
IEBGENER UTILITY
SORT UTILITY

1. Introduction

2010-03-08T07:59:00.000-08:00

Need of JCL

1. Introduction

JCL is a language in which the users of a computer systems describes to that system the requirements of their jobs.

• Provides a primary interface between user and the JES.
• Used to perform batch mode processing under MVS.

Within a job, JCL provides the specification necessary for MVS to process the job.

Specifications of a job are :

• User identity
• Data file identity
• Resource requirement
• Error handling

Need of JCL

• Request execution of program under MVS environment
• Sets the requirement for a job

Back to JCL Index
Back to home page

2. JCL Syntax

2010-03-08T07:57:00.000-08:00

Syntax Rules

General JCL command format

//name operation parameter1,parameter2 Comments

where;
name : is not to exceed 8 characters
operation : generally begins in column 12
parameter : generally begins in column 17
comments : are separated from the parameters by a blank

Parameters are broadly classified into 2 categories viz. Positional and Keyword.

A positional parameter is identified by its position relative to other parameters in the operand field.

Rule 1 : All positional parameters are coded first in the operand field and in their proper sequence.

e.g. : p1,p2,p3
p1,p3,p2 illegal because they are not in sequence.

A keyword parameter is identified by a keyword followed by an equal sign (=) and variable information.

Rule 2 : A keyword parameter follows positional parameter and can be coded in any order.

e.g. : p1,p2,p3,k1=,k2=,k3=
p1,p2,p2,k3=,k2=,k1=

Both are valid.

Note : All parameters are separated by commas with no intervening spaces.

Rule 3 : The absence of positional parameter is noted by a comma(,) coded in its place, except for the last or remainder of the positional parameter are not present. The placeholder commas do not need to be coded.

e.g. : p1,,p3,k1=,k2=,k3= place holder comma required
p1,k1=,k2=,k3=

Rule 4 : Both positional parameters and variable information for keyword parameters may be composed of subparameters. The subparameters may be either positional or keyword. Subparameters must be coded as a list. The list must be enclosed in paranthesis unless only one subparameter is coded. When only one subparameter is coded the paranthesis are optional.

e.g : p1,(sp1,sp2),p3,k1=(sk1,sk2),k2=,k3=
p1,(sp1),p3,k1=(sk1),k2=,k3=
or p1,sp1,p3,k1=sk1,k2=,k3=

Rules for continuation : The JCL statement can be continued in a simple way. The statement must be interrupted at a comma. This means that the last valid character of the line must be a comma followed by atleast one blank. Then the statement can be continued into the next line by coding two slashes at the beginning of the line and continuing the parameter field starting anywhere between positions 4 and 16 (4 and 16 included). Note that the comma which indicates continuation, is not an extraneous character but part of the statement.

//dd1 dd dsn=da0001t.empfile,disp=(new,catalg,delete),
// unit=sysda,space=(trk,(5,1)),dcb=(lrecl=80,recfm=fb,blksize=800)
//dd1 dd dsn=da0001t.empfile,disp=(new,catalg,delete),
// unit=sysda,space=(trk,(5,
// 1)),dcb=(lrecl=80,recfm=fb,blksize=800)
//

Eg. 2.1 Examples of valid continuation

Job Statement

The job statement identifies job to the O/S with the job name operand.

The format of the JOB statement is :

//jobname JOB parameters

Note that jobname cannot exceed 8 characters and is usually the userid (loginid)

//da0001ta JOB parameters

Loginid is generally 7 characters, so you need to add a suffix lest the system prompts you to enter the character when a job is submitted to the system for execution.

When a job is submitted to the system, a job number is also assigned so that the job can be further identified. This way jobs with the same name can be uniquely identified. Jobs with the same name cannot execute simultaneously. If several jobs with the same name are submitted they execute sequentially even if additional jobs could be executing. Jobs waiting to run because of this time conflict are shown in hold status.

Remark : 1 A JOB statement must be at the beginning of every job submitted to the system for execution.
2 A JOB statement must have a name. The absence of a jobname will result in a JCL error.

The rest of the JOB statement contains postional parameters followed by keyword.

Accounting Information parameter :

It is a positional parameter. If present (it normally is), it must be the first in the parameter field. It can have a maximum of 142 characters (including parenthesis and commas but not apostrophes) . It is used to tie the resources used by the job to the appropriate account.

//jobname JOB ([account-number][,additional-accounting-information]),parameters

The account-number is an alphanumeric field from 1 to 4 characters long (many installations permit the use of more than 4 characters.

Additional-accounting-information is installation dependent. Many of the fields are not very important and are not often used. Note that except for the account number, all other subparameters can be supplied through the /*JOBPARM JES2 control statement. (JES2 control statements are not covered in this book, refer to IBM Manual.

e.g :
//da0001ta JOB LA2719,parameters

LA2719 is the account number for the training dept. This varies from project to project. Therefore, consult the right person.

If any portion of the field contains a special character other than a “,” (comma) or a “-“ (hyphen), the portion must be enclosed in apostrophes. If an ampersand or quotes is used in the accounting field, code two consecutive ampersands or quotes.

e.g. :1

//da0001ta JOB ‘LA2719,TRG’
or //da0001ta JOB (LA2719,TRG)

e.g. :2

//da0001ta JOB (LA2719,’P&&G’)

The system assumes a single ampersand.

Remark: An installation has the option of making the account number mandatory and most installations do. If so, its absence will cause a JCL error.

If the account number is incorrectly specified, in this case its not JCL error. However when job is submitted to the system for execution, we get the message JOB NOT RUN in the sysout.

Programmer’s Name :

Following the accounting information parameter, another positional parameter, the programmer’s name can be coded. The installation determines if this parameter is required or not. If required, it must be coded immediately after the accounting information, and its omission will cause a JCL error. The programmer’s name cannot exceed 20 characters. If it contains any special characters other than a hyphen and a period in the middle or the beginning (but not at the end) of the name, the name must be enclosed in apostrophes. The apostrophes are not added to the length of the name. If a name contains an apostrophe (e.g., D’COSTA), two apostrophes must be coded. They count as one character in the length of the name.

e.g. : 1

//da0001ta JOB LA2719,Pai,parameters

e.g. : 2

//da0001ta JOB LA2719,’D’’COSTA’,parameters

Note : Accounting information and Programmer’s name are the only two positional parameters in the JOB statement, what follows after that are keyword parameters.

MSGLEVEL parameter :

This parameter specifies whether the submitted JCL and/or JCL-related messages should be shown on the job’s output.

General syntax

MSGLEVEL=([jcl][,messages]) Keyword parameter
Jcl - 0, 1, or 2

0 - only the JOB statement will be shown
1 - All JCL will be shown
• instream
• expanded cataloged procedures
• symbolic parameter substitutions
2 - All JCL will be shown, but not expanded procedure listing.

Messages – 0 or 1
0 - No messages will be shown i.e information about step completion.
1 – All messages will be shown viz allocation and termination messages.
The messages subparameter can be thought of as On (1) or Off (0) .

Remark:

1. If the entire parameter or either of the two fields is omitted, an installation-defined default is assumed.
MSGLEVEL=1 ------------------MSGLEVEL=(1,default)
MSGLEVEL=(,1) ------------------MSGLEVEL=(default,1)
Parameter omitted ------------------ MSGLEVEL=(default,default)

2. If the job encounter an ABEND failure, the second field always defaults to 1 even if coded as 0

TheMSGCLASS parameter :

This parameter assigns a sysout class to the Job log. The job log consists of what is what is known as system or JES datasets:
• JES2 or JES3 log
• JCL and its associated messages
• Allocation and Termination messages

MSGCLASS - indicates the format of output
- specifies output class for
job log (collection of all operations)
list (collection of all printed output like compiled listing)

General Syntax

MSGCLASS=class Keyword parameter
Class - A character from A to Z or a number from 0 to 9 (in all 36 classes)

MSGLEVEL parameter indicates whether or not one wishes to print the JCL statements and allocation messages. The MSGLEVEL can save paper. After a job is debugged, there may be no need to print all the JCL and allocation messages each time it runs. To reduce printing to a minimum, one may wish to MSGLEVEL=(0,0).

All datasets to be printed must have a class. This is normally called the output class, sysout class or message class. Sysout datasets created by the executing programs are assigned a class by the SYSOUT DISTINCT statement. After the job terminates, the sysout datasets, which are saved on the spool pack , will be selected and printed by a JES2 or JES3 component called a printer. There are several printers available, and each one is assigned one or more sysout classes (from 1 t0 36). The sysout class can be thought of as a print-scheduling class.

Remark : If the MSGCLASS parameter is omitted, an installation-defined default will be used.

The Class Parameter :

This parameter assigns a class to a job.

General Syntax

CLASS=jobclass Keyword parameter
Jobclass – A letter from A to Z or a number from 0 to 9 ( in all 36 classes)

The jobclass affects job’s processing in these ways :
• When job is submitted, it is placed in an input queue where it waits to be executed. Queues can be thought of as waiting lines for jobs. Each job class has its own input queue
• Job waits in the input queue until it is selected by an initiator to be processed. Each initiator is set to a list of job classes that it can select from.

Simply put Jobclass identifies the nature of the job
- short running or long running
- resource utilization

Each installation group jobs that have like characterstics into classes. By segregrating jobs with similar characterstics, an installation can maintain a good mix of the jobs running at a given moment. This maintains system throughput and efficient use of resources.

Let us look at the sample table below

Class Code Run Time (in minutes) Tape Disk Production Test
1 5 X X X
2 >5 X X X
A 5 X X X
B <5 X X X
C >5 X X X

Table 2.1

In the sample table, the job classes were separated by
- Production vs Test
- Tape vs disk
- expected run time

The example shows some of the characteristics an installation may look at, but certainly not all. Also, resources used by a job may be critical at one installation, but not at another. What is important is that one should follow installation’s standard.

For e.g. Suppose the default Class is A

This Job statement
//DA0001TA JOB LA2719,PCS,MSGCLASS=A,MSGLEVEL=(1,1)

is equivalent to
//DA0001TA JOB LA2719,PCS,MSGCLASS=A,MSGLEVEL=(1,1),CLASS=A

Remark :
Frequently, installations develop a testing class structure that favors short-running jobs with minimal resource requirements and penalize long-running jobs with heavy resource demands. This is achieved by assigning the class used by trivial jobs to many initiators and class used by heavy jobs to few. To keep people honest, the CLASS parameter in a testing environment is often tied to several other parameters such as TIME,PRTY, REGION, etc. For example, a job coding CLASS=A can be given TIME=(0,5),PRTY=6. Note that the values assigned to these parameters is not shown in the output. However, if any of these parameters were coded in the JOB statement, they would be ignored.

Most installation assigns a default job class if the Class parameter is omitted.

The PRTY parameter

This parameter determines the scheduling priority of a job in relation to other jobs in the job input queue of the same class.

General Syntax

PRTY=priorty - keyword parameter
Priorty – a number from 0 to 15 for JES2 or 0 to 14 for JES3

The PRTY parameter is used to define the job’s input class selection priority :
• The higher the number, the better (greater) the priority
• The PRTY parameter simply controls the job’s position in the input queue. It has no affect on the job’s performance.
• Jobs with higher priorities will be selected before job’s will lower priority
• A job’s priority does not affect its performance. Once the job is selected for execution, the priority function is finished.
• Two jobs having same job class and same priority will be executed in sequence

Comparing the PRTY parameter of two jobs belonging to different classes is meaningless.

Remark :
This parameter is of seldom use in a testing environment. Since high priorty would be used by practically all users negating the very purpose the parameter,. Therefore, in most installation the PRTY, whether coded or not, will default to an installation-defined value or will be supplied by the CLASS parameter.

The TIME Parameter

This parameter specifies the total amount of CPU time that all steps in a job can use collectively.

General Syntax

TIME=([minutes][,seconds] | [1440]) keyword parameter

minutes - a number from 1 to 1439
seconds - a number from 1 to 59
1440 - The job will not be timed for CPU. It was also not “time out” (S522 ABEND failure) when a single wait state exceeds the installation-defined limit (often 10 to 20 minutes). Note that TIME=1440 is rarely used, and most installation disallow its use in a testing environment. TIME=1440 should be used by an on-line system like CICS OR ADS/O.

When the TIME parameter is omitted, an installation-defined default will be used. This default is usually very high and unlikely to cause an S322 ABEND failure unless the program goes into an endless loop.

If the TIME parameter is also coded in the JOB statement, both will be in effect and either can cause a S322 ABEND failure. It is not advisable to use them both.

CPU time is the amount of time that the computer devoted to the job after it was selected for processing. It is not the amount of time it was in the machine.

TIME parameter puts an upper limit on the amount of CPU time that a job may use.
e.g : TIME=(3,20).

All the steps in the job are allowed collectively 3 minutes and 20 seconds of CPU time. If this amount is exceeded, the result will be a S322 ABEND failure.

If the TIME parameter is coded using only minutes, seconds defaults to zero. For example, TIME=5 is the same as TIME=(6,0).

If the TIME parameter is coded using only seconds, minutes defaults to zero. For example, TIME=(,6) is the same as TIME=(0,6).

The TIME parameter is intended almost exclusively for a testing environment and should be coded to preempt the program going into CPU loop.

The TIME parameter can also be supplied by the CLASS parameter. When the TIME parameter is omitted and the CLASS parameter does not supply it, the job will not be timed for CPU time. However each step will be individually timed (TIME parameter at EXEC statement or its installation-defined default), unless it contains TIME=1440.

Remark:
It is possible for a job to get more CPU time than that is specified in the TIME parameter by a maximum 10.5 seconds. This is due to the fact that the system checks for violations every 10.5 seconds.

The REGION parameter

This parameter specifies the limit of available storage for each of the steps in the job within the job’s address space. i.e., the amount of storage the job is allocated. Or, in other words, it specfies the amount of storage needed by the step (within the job) with the highest storage requirements.

General Syntax

REGION=value{K|M} keyword parameter
Value – 1 to 2096128 if K (1024 bytes) is used. It should be an even number, it will be rounded to the next higher even number.

Value – 1 to 2047 if M (1024K or 1048576 bytes) is used. M is not available to MVS/SP, only to MVS/XA and MVS/ESA

When a job is selected by an initiator for execution, it is given an address space of 16 MB ( minus what MVS/SP uses) .Incase of MVS/XA, job is given an address space of 2GB. And all of it is available to the job’s steps. However a step normally requires only a small fraction of this huge storage, below the 16M line. An ordinary COBOL or any other language program seldom needs more than 1000k. This is normally what the value in the REGION parameter represents in the installations. Few jobs like CICS, IMS, DB2 need storage above the 16M line. An ordinary batch job seldom has such high requirements and, as a result confined to storage below the 16M line. Storage availability below this line varies in different installations, but is generally around 8MB in MVS/SP and around 9 MB in MVS/XA. Storage above the 16M line can be acquired by coding a value higher than 16M. However, it may be restricted by the installation to only those jobs that need it.

E.g 1.
Assume REGION=1000K was coded in the JOB statement. All the steps in the job are limited to this value. If more storage is needed, the usual result is S878 or S80A or S804 ABEND failure. If one of these failures occurs, the user must increase the value in the REGION parameter.

E.g 2.
REGION=10M
When the amount of storage requested in the REGION parameter is higher than the address space can provide, an S822 ABEND failure will result.

Note that for job run under MVS/SP, the entire address space is limited to 16M, of which usually less than 8M is available to the user. In case of MVS/XA, the entire address space is limited to 2G, of which usually around 9M is available to the user.

E.g 3.
REGION=0K (or 0M) is coded the entire address space except for those areas used by MVS/SP (or MVS/XA) is available.

The ADDRSPC parameter

This parameter specifies if the job will use real or virtual storage.

General syntax

ADDRSPC={VIRT|REAL}
VIRT – The REGION will be virtual storage and is the default
REAL – The REGION will be real storage.

Remark:
This is the rarely used parameter because of the default. Note that ADDRSPC=REAL is a parameter that is disallowed in practically all installation because it can cause serious performance problems for other jobs.

The NOTIFY parameter

This parameter informs a TSO user when his or his job terminates.

General Syntax

NOTIFY=userid keyword parameter
Userid – A name from 1 to 7 character, identifying a valid TSO user.

E.g NOTIFY=DA0001T

If coded, a message will appear on the user’s TSO terminal indicating if the job abended or got a JCL error. If the job terminates while the user was logged off, the message will appear when the user logs on. If the NOTIFY parameter is omitted, no message will appear when the job terminates.

Remark :
You can also code NOTIFY=&SYSUID instead of your userid.

The RESTART parameter

This parameter requests that a job begin its execution with a step other than the first one.

General Syntax

RESTART={stepname|procexec.stepname| *} keyword parameter

Stepname – The name of the step where execution is to begin.
Procexec.stepname – The name of the EXEC statement invoking a procedure and the name of the step within the procedure where execution is to begin

Note : Procedures will be covered on day 4.

* - indicates that execution of the job is to begin with the first step and is the default.

Things to avoid :
• Duplicate name for EXEC statements invoking procedure. If RESTART=procsexec.stepname is used, the first procexec found will be used.
• Duplicate stepnames within procedure. If RESTART=procsexec.stepname is used, the first stepname within procexec found will be used.
• Duplicate stepnames. If RESTART=stepname is used, the first stepname found will be used.
• EXEC statements (invoking procedures or any step) without names. No restart is possible
• Creating and passing temporary datasets. Such datasets are always deleted by the time the job terminates and, therfore unavailable for restarting.
• Creating and passing nontemporary datasets. If such a dataset is not received and assigned a permanent disposition, Job Termination will delete it, making restart impossible

The TYPRUN parameter

This parameter requests special processing for the job.

General Syntax

TYPRUN={HOLD|JCLHOLD|SCAN|COPY} keyword parameter

HOLD - Job will held (and not executed temporarily) until the operator uses a command to release. A job will be held in the input queue only if syntactically correct
JCLHOLD (JES2 only) – Job will held (and not executed) until the operator uses a command to release it. Note the job will be held in queue if it is syntactically incorrect. Rarely used

SCAN – Job will be scanned for all syntactical JCL errors but will not execute.

COPY (JES2 only)- Job will be printed. No execution and no syntax checking takes place. Rarely used.

Back to JCL Index
Back to home page

3. The EXEC Statement

2010-03-08T07:53:00.000-08:00

An EXEC statement identifies a step during the reading the reading process when a job is submitted to the system. When an EXEC is found, the system accepts all JCL statements that follow as belonging to the step, until a delimiter is found. There are four possible delimiters for a step during the reading process :
• Another EXEC statement in the input stream. It signals the end of (reading) one step and the beginning of (reading) of another.
• A JOB statement
• A null statement i.e //. All JCL statements will be ignored except for a JOB statement.
• End-of-file on the reading device, meaning there are no more statements to read.

General Syntax

//[stepname] EXEC parameters
stepname is optional. When the stepname is omitted no reference can be made. A job can contain a maximum of 255 steps.

The PGM Parameter
The PGM parameter identifies the program to be executed in a step.

General Syntax
PGM=pgmname positional parameter

Pgmname - Name of the program to be fetched from the loadlibrary and executed.

The program specified in PGM is always a member of library (PDS). This is commonly known as an executable program library or a load library. The EXEC statement can identify only the member. It has no parameter available to identify the library. If necessary, this must be done by using a JOBLIB or a STEPLIB DD statement.

E.g.3.1

//da0001ta job la2719,pcs,msglevel=(1,1),notify=&sysuid
//joblib dd dsn=da0001t.lib.loadlib=shr
//s1 exec pgm=ass1

OR

//da0001ta job la2719,pcs,msglevel=(1,1),notify=&sysuid
//s1 exec pgm=ass1
//steplib dd dsn=da0001t.lib.loadlib=shr

If neither JOBLIB or STEPLIB is coded, the system searches certain predefined libraries. They are the system default libraries. If the specified member is found, it is executed. If not found, the result is S806-04 ABEND failure.

The following keyword parameters can be specified at the EXEC statement. They are REGION, ADDRSPC, TIME , PARM and ACCT.

The REGION Parameter

This parameter specifies the limit of available storage for the step within the job’s address space.

General Syntax

REGION=value{K|M} keyword parameter
Value – 1 to 2096128 if K (1024 bytes) is used. It should be an even number, it will be rounded to the next higher even number.

Value – 1 to 2047 if M (1024K or 1048576 bytes) is used. M is not available to MVS/SP, only to MVS/XA and MVS/ESA

If the REGION parameter is omitted , the REGION parameter in the EXEC statements within the job will be used. If it is coded in neither the JOB nor the EXEC statement, an installation-defined default will be used. The default value of most installations is between 500K and 1000K.
If the REGION parameter is coded in both the JOB and an EXEC statement within the job, the value in the JOB statement will be used.
The REGION parameter in the JOB statement is used much more often than the one in the EXEC statement. Coding the same value for all steps would have the same effect as the REGION parameter in the JOB statement.

E.g. 3.2

//da0001ta job la2719,pcs,msglevel=(1,1),notify=&sysuid
//s1 exec pgm=ass1,region=500k
//steplib dd dsn=da0001t.lib.loadlib=shr

The TIME parameter

This parameter specifies the total amount of CPU time that the step is allowed to use.

General Syntax

TIME=([minutes][,seconds] | [1440]) keyword parameter

minutes - a number from 1 to 1439
seconds – a number from 1 to 59

1440 - The step will not be timed for CPU. It was also not “time out” (S522 ABEND failure) when a single wait state exceeds the installation-defined limit (often 10 to 20 minutes). Note that TIME=1440 is rarely used, and most installation disallow its use in a testing environment. TIME=1440 should be used by an on-line system like CICS OR ADS/O.

When the TIME parameter is omitted, an installation-defined default will be used. This default is usually very high and unlikely to cause an S322 ABEND failure.
If the TIME parameter is also coded in the JOB statement, both will be in effect and either can cause a S322 ABEND failure. It is not advisable to use them both.

Remark :
It is possible for a step to get more CPU time than that is specified in the TIME parameter or the default by a maximum 10.5 seconds. This is due to the fact that the system checks for violations every 10.5 seconds.

E.g 3.3

//da0001ta job la2719,pcs,msglevel=(1,0),notify=&sysuid
//s1 exec pgm=ass1,region=500k,time=(,3)
//steplib dd dsn=da0001t.lib.loadlib=shr

The ADDRSPC parameter

This parameter specifies if the step will use real or virtual storage.

General syntax

ADDRSPC={VIRT|REAL}
VIRT – The REGION will be virtual storage and is the default
REAL – The REGION will be real storage.

If the ADDRSPC parameter is also coded in the JOB statement, the value in the JOB will be used.

Remark:
This is the rarely used parameter because of the default. Note that ADDRSPC=REAL is a parameter that is disallowed in practically all installation because it can cause serious performance problems for other jobs.

The ACCT Parameter

The parameter specifies accounting information to be used for the step as opposed to the accounting information in the JOB statement.

General Syntax

ACCT=(acctno [additional-acct-info]) keyword parameter

Acctno – The account number to be used for the step
Additional-acct-info – same as in the JOB statement.

The ACCT parameter is seldom used, and when it is, only the account number normally appears. This is used to charge resource utilization for a step to a different account number other than the one coded in the JOB statement.

If an account number is also coded in the JOB statement, the account number in the EXEC statement will be used.

E.g 3.4

//da0001ta job la2719,pcs,msglevel=(1,0),notify=&sysuid
//s1 exec pgm=iefbr14,acct=(‘es0013,hr4200,iefbr14’)
//dd1 dd dsn=da0001t.pai.empfile,disp=(mod,delete),
// space=(trk,0),unit=sysda

The PARM Parameter

This parameter provides a way to supply data of limited size to the executing program

General Syntax
PARM=string keyword parameter

String –A string of characters up to 100. If commas are part of the string, the entire field must be enclosed in parenthesis (or apostrophes). If any portion of the string contains special characters (other than hyphen), that portion of the entire string must be enclosed in apostrophes. Note that any parenthesis used count toward the maximum. Apostrophes do not.

All information after the “=” in the PARM parameter, excluding apostrophes, will be saved by the system within the step’s own region. When the program begins execution by using the appropriate instructions, it can find the saved information in storage.

In COBOL, the following must be coded :

LINKAGE SECTION.
01 PARM.
05 PLENGTH PIC S9(04) COMP.
05 INFO PIC X(05).
PROCEDURE DIVISION USING PARM.
0000-MAIN-PARA.

Note that any valid name may be used in place of PARM. The string is stored in PARM and the PLENGTH is set to the length of the string.

E.g 3.5

//da0001ta job la2719,pcs,msglevel=(1,1),notify=&sysuid
//s1 exec pgm=ass2,parm=’g2 ‘,time=(,3)
//steplib dd dsn=da0001t.lib.loadlib=shr

Rules for continuation

E.g 3.6

//da0001ta job la2719,pcs,msglevel=(1,1),notify=&sysuid
//cob exec pgm=ikfcbl00,region=1024k,
// parm=(‘notrunc,nodynam,lib,size=4096k,buf=116k’,
// ‘apost,nores,seq’)
.
.
or

//da0001ta job la2719,pcs,msglevel=(1,1),notify=&sysuid
//cob exec pgm=ikfcbl00,region=1024k,
// parm=(notrunc,nodynam,lib,’size=4096k’,’buf=116k’,
// apost,nores,seq)
.
.
Note that an expression in quotes cannot be continued, we need to enclose the string in parenthesis and field containing special characters in apostrophes.

E.g.2 PARM=’29/06/00’ or (‘29/06/00’)
E.g 3 PARM=(A,B,C,D) or ‘A,B,C,D’
The two, however , are not the same. When parentheses are used, the information found by the program is (A,B,C,D). If apostrophes are used, the information found by the program is A,B,C,D.

The COND Parameter

The COND parameter can be coded in the JOB as well as the EXEC statement. It is mostly used in the EXEC statement. The main tool for controlling the execution of steps within a job is the COND parameter.

A Return (or Condition) code

A return code is a number between 0 and 4095, issued by an executing program just before its execution is finished. It is intended to identify an important event found (or not found) during the execution. For example, a program may issue a return code of 21 to indicate that a problematic event (such as a record is out of sequence) was detected during the execution or a return code of 0 to indicate that the execution was trouble free. The return code issued by a program is saved by the system for the duration of the job. Any subsequent step of the same job can interrogate this return code by using the COND parameter either in the JOB or EXEC statement. The result of this interrogation is to permit or bypass the execution of the step. Note that the return code is never available to a job other than the one issued it. In other words, the step that interrogates the return code must be in the same job as, and subsequent to, the step that issued it.

IBM-established conventions.
• Return code of 0 indicates a complete success.
• Return code of 4 indicates a warning. The warning is benign, so a return code will normally be treated as acceptable.
• Return code of 8 indicates a questionable results.
• Return code of 12 indicates bad results.
• Return code of 16 indicates a terminal condition.

The COND Parameter in the JOB statement.

The COND Parameter can perform a test (or multiple tests) at the beginning of each step against the return (condition) codes issued by the previous steps. If a test is satisfied , none of the steps from that point on will be executed.

General Syntax

COND=((code,operator) [,(code,operator)]…….) keyword parameter
Code - is a number between 0 and 4095
Operator – provides a comparison between a return code and the code. There are six operators : LT, LE, NE, EQ, GT, GE

There can be a maximum of eight tests in the COND parameter. Condition is evaluated from left to right and if a test is satisfied, the job stops execution at that point.

An example can best illustrate the mechanism of the COND parameter. Consider a job with five steps. Assume that none will ABEND.

//da0001ta job la2719,pcs,cond=((12,lt),(8,eq))

STEP1 issues a return code of 0
STEP2, if executed, issues a return code of 4
STEP3, if executed, issues a return code of 16
STEP4, if executed, issues a return code of 0
STEP5, if executed, issues a return code of 4
(warning : This example does not adhere to conventions.)

STEP 1 is executed by default, since no previous return codes exist and hence, the COND parameter in the JOB statement will be ignored for the first step.

Before STEP2 begins execution, the system interrogates the existing return code (0), using the tests in the COND parameter and reading the test from left to right,
• Is 12 less than 0? The answer is “no”. The first test of the COND parameter was not satisfied. The second test is tested.
• Is 8 equal to 0? . The answer is “no”. Neither of the two tests was satisfied, and therefore, STEP2 is executed.

Before STEP3 begins execution, the system interrogates the existing return codes (0 and 4), using the tests in the same COND parameter. Since the result for return code 0 is already known, only 4 will be tested :
• Is 12 less than 4? The answer is “no”. The first test of the COND parameter was not satisfied. The second test is tested.
• Is 8 equal to 4 . The answer is “no”. Neither of the two tests was satisfied, and therefore, STEP3 is executed.

Before STEP4 begins execution, the system interrogates the existing return codes (0 , 4 and 16), using the tests in the same COND parameter. Since the results for return code 0 and 4 are already known, only 16 will be tested :
• Is 12 less than 16? The answer is “yes”. The first test of the COND parameter was satisfied. There is no need for the second test . Executions of the job stops. STEP 4 and the remaining steps will not be executed.

A message will appear in the output:
IEF2011 DA0001TA STEP4-JOB TERMINATED BECAUSE OF CONDITION CODES.

A formula can be devised and used to code the COND parameter, if return code conventions are strictly adhered to :
COND=(last-good-return-code,LT)
Or
COND=(first-bad-return-code,LE)

Let us apply this formula to this example 0-4 is a good return code :
4 -is the last good return code….COND=(4,LT)
or
5 - is the first bad return code…..COND=(5,LE)
The two COND parameters are logically equivalent to each other, and it makes no difference which one is used.

Exercise : Code the COND parameter, where 0 is the only good return code.

The COND parameter in the EXEC statement
The COND parameter can perform a test (or multiple tests) before a step begins execution against the return (condition) codes issued by previous steps. If a test is satisfied, the step will not be executed.

General Syntax

COND=((code,operator[,stepname])[,(code,operator[,stepname])]……[,EVEN|ONLY]) keyword parameter

Code - is a number between 0 and 4095

Operator – provides a comparison between a return code and the code. There are six operators : LT, LE, NE, EQ, GT, GE
Stepname – Identifies the name of the preceding step whose return code will be interrogated. It can also appear as two names procexec.stepname where “procexec” identifies the name of the EXEC statement invoking a procedure and “stepname” the stepname within the procedure.
EVEN - requests that execution be permitted even though a previous (any previous) step has ABENDed.
ONLY - requests that execution be permitted only if a previous (any previous) step has ABENDed.

There can be a maximum of eight tests in the COND parameter. EVEN or ONLY counts toward eight. Condition is evaluated from left to right and if a test is satisfied, only that step is not executed.

Remark :
• EVEN and ONLY cannot make reference to a particular step. They refer to any previous step that has ABENDed.
• EVEN and ONLY are mutually exclusive
• EVEN and ONLY have no positional significance. Each can be coded anywhere in the COND parameter in relation to other tests
• Following an ABEND failure, a step cannot be executed unless it contains EVEN or ONLY in the COND parameter of its EXEC statement
• The first step will always be executed unless COND=ONLY appears in the exec statement. COND=ONLY would cause the first step to be bypassed, since no previous ABEND failures could have occurred. Any other COND parameter in the first EXEC statement will be ignored (i.e., COND=(4,LT) or COND=EVEN) or will result in JCL error (i.e., COND=(5,LT,stepname)) – since there are no previous step.
• A step that is not executed issues no return code because a program responsible for for issuing the return code was not even loaded into the storage. As a result no return code exists. An attempt to interrogate the return code of such a step in the COND parameter of a subsequent step will be ignored.
• A step that ABEND’s issues no return code because a program always issues a return code (conditionally or by default) if it reaches the end of its execution and intentionally returns control to the system. When an ABEND occurs, the program loses control instantly. And is evicted from from execution by the system. As a result when a step ABEND’s no return code exists ( a completion code exists). An attempt to interogate the return code of such a step in the COND parameter of a step will be ignored until it contains EVEN or ONLY.

An example can best illustrate the mechanism of the COND parameter. Consider a job with five steps. This is a class room exercise.

//da0001ta job la2719,pcs,notify=&sysuid,msglevel=(1,1)
//s1 exec pgm=p1 (4)
//s2 exec pgm=p2,cond=((0,lt,s1),even) (12)
//s3 exec pgm=p3,cond=(8,lt,s2) (0)
//s4 exec pgm=p4,cond=(4,lt) (8)
//s5 exec pgm=p5,cond=((4,lt,s1),(0,lt,s3)) abend
//s6 exec pgm=p6,cond=(even,(0,le,s5),) (16)*
//s7 exec pgm=p7,cond=((0,lt,s1),even) (0)
//s8 exec pgm=p8,cond=((0,lt,s1),(12,lt,s3) ) (0)
//s9 exec pgm=p9,cond=only) (4)
//s10 exec pgm=p10,cond=only (0)

If the COND parameter is coded neither at the JOB nor at the EXEC statement, the step will be executed regardless of previous return codes. However it will not be if a previous step has ABENDed.

If the COND parameter is coded in both the JOB statement as well as an EXEC statement within the JOB. The COND parameter of the JOB statement is tested first. If none of its tests are satisfied, then the COND parameter of the EXEC statement is tested. If a test is satisfied, none of the steps from that point on will be executed.

This is a class room exercise.

//DA0001TA JOB LA2719,PCS,COND=(5,EQ),NOTIFY=DA0001T
//S1 EXEC PGM=P1 (4)
//S2 EXEC PGM=P2,COND=(7,LT) (ABEND)
//S3 EXEC PGM=P3,COND=((20,GT,S1),EVEN) (6)
//S4 EXEC PGM=P4,COND=(3,EQ),ONLY) (8)
//S5 EXEC PGM=P5,COND=(2,LT,S3) -
//S6 EXEC PGM=P6 -
//S7 EXEC PGM=P7,COND=((6,EQ,S5),ONLY) (5)
//S8 EXEC PGM=P8,COND=EVEN (0)
//S9 EXEC PGM=P9 -

Back to JCL Index
Back to home page

4. The DD statement

2010-03-08T07:08:00.000-08:00

A DD (Data Definition_ statement must appear in a step when the executing program expects to read from or write to a dataset. In other words DD statement describes the dataset. The DD statement is the most complicated of all the JCL statements.
The maximum number of DD statements in a step is 3273 . The DD statement can be coded in any order and always appear after the EXEC statement with the exeception of
JOBLIB, JOBCAT, PROCLIB DD statement.

The DSN Parameter

The DSN (or DSNAME) parameter identifies the name of the dataset to be created or retreived.

General Syntax

DSN=name| referback keyword parameter

Name - It could be a qualified name. This name consists of two or more simple name separated by periods for a maximum of 44 characters.
E.g 1 DSN=da0001t.pcs.empfile

E.g.2 DSN=da0001t.pcs.cobol(ass1) identifies a library (da0001t.pcs.cobol) and a particular member. This notation describes a sequential dataset.

e.g.3 DSN=&&name
A simple name preceded by two ampersands identifies a temporary dataset. Temporary because it is not retained beyond job termination.
The system generates a name with the following format :
SYSyyddd.Thh.mm.ss.RV001.jobname.name
Yyddd – Julian Calender;
hhmmss – uses 24 hour clock ;
RV001 –system provided information in reference to the reader;
jobname – as it appears in the JOB statement ;
Name – whatever is coded after &&.

For e.g DSN=&&temp
SYS00173.T090000.RV001.da0001ta.temp

Remark :
If the DSN name is omitted from a DD statement (except DD * , SYSOUT and DUMMY) also indicates a temporary dataset. However the system generates a name with the following format :
SYSyyddd.Thhmmss.RV001.jobname.R0000001
//SORTWK1 DD UNIT=SYSDA,SPACE=(TRK,(1,2),RLSE)

SYS00173.T100000.RV001.da0001ta.R0000001

This form is basically used when a step requires a work dataset (a dataset created at the beginning of the step’s exeution and deleted at the end). Mostly by utilities.

Most utility uses this form

Referback : This can have three formats :
- *.stepname.ddname – Requests that the dataset name be copied from DD statement “ddname “ found in a previous step “stepname”.

e.g : DSN=*.step1.dd1

- *.ddname – Requests that the dataset name be copied from a previous DD statement “ddname “ found in the same step “stepname”.

e.g : DSN=*.dd1

- *.procexec.stepname.ddname – Requests that the dataset name be copied from DD statement “ddname “ found in a previous step “stepname” found within procedure “procexec”. (name of EXEC statement invokinh the procedure)
e.g : DSN=*.ps1.step1.dd1

The DISP Parameter

The DISP parameter specifies :
- if the dataset is to be created or retreived
- how to dispose of the dataset when the step terminates (normally or abnormally)

General Syntax

NEW ,DELETE ,DELETE
OLD ,KEEP ,KEEP
DISP= ( SHR ,CATLG ,CATLG ) keyword parameter
MOD ,UNCATLG ,UNCATG;
,PASS

DISP=(status-field,normal-disp-field,abnormal-disp-field)
The status-field : This field tells the system whether the dataset is to be created or retrieved.

NEW – Indicates that the dataset will be created in this step

OLD - Indicates that an existing dataset will be retrieved and demands exclusive control.

SHR - Indicates that an existing dataset will be retrieved. It also indicates that this dataset ,if on disk, can be shared with one or more other users.

MOD - This subparameter has two possible meanings :
Indicates that an existing dataset will be retrieved . This will be true if
• The dataset is either cataloged or passed
• The DD statement contains either VOL=SER or VOL=REF (a VOL VOL=REF referring to a DD statement, which is a nonspecific request for a new dataset, is not included)
Indicates that the dataset will be created. This is true if :
• The DD statement contains neither VOL=SER nor VOL=REF and it describes a dataset which is neither cataloged nor passed.
• The DD statement contains VOL=REF referring to a DD statement which is nonspecific request for a new dataset.

e.g. 1 //dd1 dd dsn=da0001t.empfile,disp=(mod,catlg),
// unit=tape

Explanation:
1. The system assumes da0001t.empfile to be an existing dataset, since the DD statement contains neither VOL=SER or VOL=REF. The system searches the catalog and gets volume informatiom from the catalog entry. The volume have been found. This dataset will be treted as existing dataset.
2. Had the dataset been neither cataloged nor passed. The systen would have been unable to find the volume information and MOD will default to new.

e.g 2 //dd1 dd dsn=da0001t.empfile,disp=(mod,catlg),
// unit=sysda,vol=ser=bs3003,space=(trk,(1,2))

Explanation: Since VOL=SER is specified, the fate of MOD is sealed, whether or not it exists. It will be treated as OLD (with appropriate positioning). If the dataset exists on that volume no problem, however, if it does not exist the result will be S213-04 ABEND failure (i.e dataset does not exists)

Note :When UNIT and VOL=SER is specified the system does not search the catalog to locate the dataset.

The normal disposition field : This field is used to tell the system how to dispose of the dataset when the step terminates normally (without an ABEND).
DELETE – indicates that the dataset is to be deleted when the step terminates. For an existing dataset, OLD, SHR or MOD (not defaulting to NEW), the dataset will also be uncataloged, if the catalog were used while retreiving the dataset. It will only delete if the catalog were not used during the retrieval. This means that for a cataloged dataset, if you specify UNIT and VOL=SER the system does not search the catalog.

Note :
1 When a tape dataset is deleted, nothing happens. A tape dataset cannot be deleted through the DISP parameter. It is effectively deleted when the dataset is written over.
2 A VSAM cluster cannot be deleted by coding DISP=(OLD,DELETE) as it defaults to DISP=(OLD,KEEP).
3 A member of PDS cannot be deleted, as DISP applies to the entire PDS, and as result it deletes the entire PDS. Use either TSO or IEHPROGM utility.
4 The system always issues a message indicating “ DELETED’ or “NOT DELETED N” N indicates the reason for failing.

KEEP – Indicates that the dataset is to be kept when the step terminates. The system takes no action and issues a message indicating the dataset was kept. Again, the system issues a message “KEPT”. Note that “NOT KEPT” message does not exists.

Note : KEEP does not imply CATLG. As a result, DISP=(NEW,KEEP) should be rarely used because next time you retrieve the dataset, you need to specify UNIT and VOL=SER.

CATLG – Indicates that the dataset is to be kept and an entry for it placed in the catalog when the step terminates.

Note :
1. If cataloging is successful, the system issues “CATALOGED”
2. If cataloging fails for a NEW dataset, the message will “NOT CATLGD n”
(n indicates the reason for failing).
3. If the dataset to be catologed is OLD or MOD , which was opened but did extend into additional volume(s), the message will “RECATALOGED n”
4. If the dataset to be cataloged is OLD or MOD and has extended into additional volume(s), the message will be “recataloged”
5. CATLG implies KEEP. DISP=(NEW,CATLG,DELETE) is a very common parameter.

When an attempt to catalog fails ?
Explanation: Under certain conditions, the attempt to catalog a new entry fails. The step termination routines normally issue a message to inform the user :
IEF287I dataset name
IEF287I VOL=SER=BS3001, BS3003 NOT CATLGD n
Followed by the message identifing the user catalog where the attempt to add the entry was made.
IEF285I user catalog name
IEF285I VOL=SER=vol serial KEPT
“n” identifies the reason for which the cataloging operation failed.
Often, n is 2. There are several reasons for failing to catalog a dataset. Most of them are seldom encountered. For instance, the failure could be due to an I/O error or an out-of-space condition in the catalog, both extremely rare. The one that is common is illustrated by means of an example.

//dd1 dd dsn=da0001t.empfile,disp=(new,catlg,delete),
// space=(trk,(1,2)),unit=sysda,
// dcb=(lrecl=80,recfm=fb,blksize=800)

If an entry for DA0001T.EMPFILE already exists in the catalog, the step termination routines will not replace the existing entry with the new one, however it keeps the dataset and issues the appropriate message. Unfortunately, “NOT CATLGD 2 “ is just a warning, operator tend to ignore.
Whenever, you get this message. The existing entry must be removed before the one with the same one is added. Use IEHPROGM or any other utility to remove the catalog before adding a new one.
What are the implications of ignoring this warning ? Assume that the existing catalog entry for dataset points to BS3001, which may or may not contain such a dataset. As a result of DD statement DD1 the dataset by the same name has been created and kept on different volume say BS3008 while the catalog entry remains unaltered.
Later, the user, who did not notice the “NOT CATLGD 2” message submits a job containing a DD statement.
//infile dd dsn=da0001t.emfile,disp=shr

The system will search the catalog, retrieves the dataset residing on volume BS3001, with no outward appearance of failure. If the dataset by that name does not exist, the result is S213-04 ABEND failure.
Note that an attempt to add a dulpicate entry in the volume encounters a “DULPCIPATE NAME ON DIRECT ACCESS VOLUME” JCL error.
This problem is not encountered in MVS/ESA, because the system deletes the dataset as well as uncatalog.

PASS – Indicates that an entry for the dataset (containing dsn, volume and unit information) be placed on a table in storage (Passed Dataset Queue). This entry is to be used in a subsequent step to “receive the passed dataset”. A message will appear “PASSED”.

The abnormal (or conditional) disposition field : This field is used to tell the systen how to dispose of the dataset when the step terminates abnormally (ABENDs). It is required only if this disposition is different from the normal disposition.
DELETE,KEEP,CATLG, and UNCATLG have the same meaning they do in the normal disposition. Note that PASS is not permitted in the abnormal disposition field.
The best example of using the abnormal disposition field is DISP=(NEW,CATLG,DELETE). If there is ABEND, the dataset is to be deleted. This eliminates future manual intervention to delete and uncatalog the dataset in order to restart.

Defaults: Some defaults in the DISP parameter are fixed and others variable.
• If the DISP parameter is omitted, the default is always (NEW,DELETE.
//sysut1 dd unit=sysda,space=(trk,(1,2))
//* (NEW,DELETE) IS THE DEFAULT

• If the status is omitted, the default is always NEW
DISP=(,CATLG) is same as DISP=(NEW,CATLG)

• If the normal disposition field is omitted
- If the status field is NEW, the default is DELETE
- If the status field is OLD or SHR and the dataset name non temporary
If the DD statement is not receiving a passed dataset, the default is KEEP.
//dd1 dd dsn=da0001t.empfile,disp=shr

• If a DD statement is receiving a passed dataset, which was created during the execution of the job and was never given a permanent disposition, the default is DELETE.

• If a DD statement is receiving a passed dataset, which was created during the execution of the job but was given permanent disposition since being created, the default is KEEP.

• If a DD statement is receiving a passed dataset which existed before the job began execution, the default is KEEP.

• If the status field is OLD or SHR and the dataset name temporary, the default is pass.
//dd1 dd dsn=old,dsn=&&temp
DISP=OLD defaults to DISP=(OLD,PASS) and the message will appear in the output –“INVALID DISP FIELD – PASS SUBSTITUTED”

• If the abnormal disposition field is omitted, the default is the normal disposition field.

The UNIT Parameter

The UNIT parameter identifies :
The device type or device address where the volume is mounted. The volume is the one where the dataset resides (or will reside if DISP=NEW).
• The number of devices to be allocated to the dataset.

• When the mount message is to be shown to the operator.

General Syntax

device address
UNIT =( generic device name ,device count ,DEFER ) Keyword parameter
generated device name

device address – Identifies the exact device address. This notation is almost never used.

Generic device name – Identifies the device type using a universal system-supplied name.
e.g : UNIT=3390 ; UNIT=3400-5 ; UNIT=3480

generated device name – Identifies the device type using an installation-defined name.

UNIT=SYSDA ; UNIT=DISK ; UNIT=TAPE
The generated names can be made to mean whatever an installation wishes them to mean. For example, UNIT=SYSDA can mean all 3380 devices of any density, or single density only, or a subset of double density devices or a combination of 3380 and 3390 device. Their definition can vary from installation to installation. Our GE machine has UNIT=SYSALLDA.

Of the three, the generated name is far the most commonly used.

Device count – Specifies the number of devices to be allocated for the dataset. The limit is 59 devices. If omitted default is 1 except when DD statement describes a disk multivolume dataset. In such case, device count=number of volumes.
E.g. 1 UNIT=(SYSDA,5) ; UNIT=(TAPE,2)

E.g. 2 UNIT=SYSDA is same as UNIT=(SYSDA,1) because of default

E.g. 3 //dd1 dd dsn=da0001t.empfile,disp=(,catlg,delete),
// unit=sysda,vol=ser=(bs3001,bs3002,bs3003),
// space=(trk,(1,2)),dcb=(lrecl=80,recfm=fb,
// blksize=800)

In this example UNIT =SYSDA defaults to UNIT=(SYSDA,3)

Note : UNIT=(,2) can also be used if the device is being supplied by the catalog.

DEFER : Requests that the mount message to the operator not be issued by the allocation routines but by the open routines when, and, if the dataset is opened.
Note : DEFER must never be used with disk. Generally, used for tapes.
There is no default for device name. If it is not coded in the UNIT parameter and it is also not supplied by the catalog, the Passed dataset Queue, the result will be allocation JCL error . The message is
“IEF210I JOBNAME STEPNAME DDANAME –UNIT FIELD SPECIFIES INCORRECT DEVICE NAME”, which is misleading. It means that the device name was needed but not coded.

The VOL Parameter

The main function of the VOL (or VOLUME) is to identify the volume(s) by serial number where an existing dataset resides or where a new dataset will reside.
General Syntax

vol ,SER=(vol1 [,vol2]…….
Volume =( ,REF=referback
,REF=dsname

SER=(vol1,vol2….) – Specifies the serial number(s) of the volume(s) to be used. The maximum number of volumes is 255.

A volume serial is a combination of alphabetic , numeric, and national characters ($ @ #) up to 6. A hyphen is also permitted. In a real (or production) environment, the number of characters is almost never less than 6.

e.g VOL=SER=BS3001 OR VOLUME=SER=BS3001
VOL=SER=(BS3013,BS3014)

REF=referback
Referback – This can have three formats :
*.stepname.ddname - Requests that the volume be the same as for DD statement “ddname” found in the previous step “stepname”.

VOL=REF=*.STEP2.DD1

*.ddname - Requests that the volume be the same as for previous DD statement “ddname” found in the same step “stepname”.

VOL=REF=*.DD1

*.procexec.stepname.ddname - Requests that the volume be the same as for DD statement “ddname” found in the previous step “stepname” found within a procecure “procexec” (name of EXEC statement invoking the procedure.

VOL=REF=*.PR1.STEP2.DD1

Remark:
Referbacks are not encouraged. They should be used only when they are necessary. A referback with a “stepname” will cause a JCL error if the referenced step does not execute. Such referbacks must be avoided where restart is required.

REF=dsname – Requests that the volume be the same as the one where dataset “dsname” resides on. The dataset must be cataloged or Passed. The dataset does not even have to exist, as long as it is cataloged or passed. The name of the referenced dataset need not appear anywhere else in the job.

e.g : VOL=REF=DA0001T.EMPFILE

Remark:
When VOL=REF (referback or dsname) is used, the system supplies the volume as well as the unit information. Therefore, the UNIT parameter is usually unnecessary.

The SPACE Parameter

The SPACE parameter must be included in a DD statement when :
• A new disk dataset is created.

• An old dataset needs to alter its entitlement to additional space. i.e., Request additional disk space for an old dataset when available space is exausted.

• An old disk dataset must free up all unused space.

General Syntax

TRK,
SPACE=( CYL, (prim-alloc [,sec-alloc] [,directory]) [,RLSE])
Blksize,
TRK – Requests that space be allocated in tracks.
CYL – Requests that space be allocated in cylinders.
Blksize – Specifies the average blocksize of the dataset. The system will translate it to tracks.
Prim-alloc. Primary allocation or primary quantity. It identifies the number of tracks (if TRK is coded) or cylinders (if CYL is coded) or the number of blocks (if blksize is coded) that must be allocated during the allocation process for a new dataset before the step begins execution. The system will allocate the requested space in one extent. If this is not possible (and CONTIG is not coded), two extents will be used, then three and so on up to five extents. If as many as five extents still cannot satisy the request, the result will be a allocation JCL error :

IEF257I jobname stepname ddname –SPACE REQUESTED NOT AVAILABLE.
If the request is nonspecific (no VOL=SER or VOL=REF), needing a storage volume, the JCL error message will be different :

IEF257I jobname stepname ddname –INSUFFICIENT SPACE ON STORAGE VOLUMES.

Remark :
The system will always allocate the primary quantity in the least number of extents possible on a single volume. The primary quantity cannot be split over multiple volumes. The primary allocation cannot be omitted (coding 0 is allowed). It is ignored if the dataset is old.
e.g 1 SPACE=(TRK,3)
e.g 2 SPACE=(CYL,4)
e.g 3 SPACE=(23440,100)
e.g 5 SPACE=(TRK,0)

sec-alloc - Secondary allocation or secondary quantity. It identifies the number of tracks (if TRK is coded) or cylinders (if CYL is coded) or the number of blocks (if blksize is coded) that are to be allocated when all available space is exhausted while writing to a dataset. The system will allocate the secondary quantity in the least number of extents possible, and just like the primary quantity, it can be given in as many as five extents, if necessary.
The system will always supply the specified secondary allocation when one is needed unless one of the two events occurs :
• The allocated volume does not have enough space to satisfy the secondary allocation and no other volumes are allocated.

• The needed secondary allocation, if granted, will cause the dataset to exceed 16 extents on the volumes and no other volumes are allocated.

If either of these two conditions arises, the result will be a SB37-04 ABEND failure (normally for a sequential dataset). For a PDS, the ABEND, can also be SE37-04. Please note that a PDS is confined to a single volume, ehile a sequential dataset can extend into a maximum of 59 volumes. The 16-extent-per-volume limit for a dataset is system-supplied and cannot be altered.
The secondary allocation is optional. If omitted, defaults to 0. When no secondary allocation is coded and the primary allocation is exhausted, the result is an SD37-04 ABEND failure.

Remark :
The secondary allocation can be used for new as well as old datasets. The secondary allocation requested when the dataset is created is recorded in the dataset’s DSCB (VTOC entry). If space is exhausted when the dataset is retrieved as OLD and extended, the system attempts to provide secondary allocation appearing in the DSCB. If ,however, a SPACE parameter is included in the DD statement, the secondary allocation will be based on what is coded in this SPACE parameter rather than what appears in the dataset’s DSCB.

E.g 1 SPACE=(TRK,(1,2))
E.g 2 SPACE=(CYL,(7,4))
E.g 3 SPACE=(23440,(200,100))

directory – Specifies the number of directory blocks (256 bytes each) to be assigned to the directory of a PDS.
The directory quantity, if not coded, defaults to zero; therefore, the directory quantity must be specified for a new PDS. If it is, not S013-14 ABEND failure will occur if an attempt is made to add the first member to a PDS.

Remark :
The directory quantity is taken away from the beginning of the primary allocation if TRK or CYL is coded in the SPACE parameter. When blksize is coded, the system adds the directory blocks to the data blocks and then computes the amount of primary space.

E.g 1 SPACE=(TRK,(20,5,5)) OR SPACE=(TRK,(20,,5)) if no secondary
E.g 2 SPACE=(CYL,(20,5,5)) OR SPACE=(CYL,(20,,5)) if no secondary
E.g 3 SPACE=(23440,(200,50,5)) OR SPACE=(23440,(200,,5)) if no secondary

RLSE –Requests that any unused space be freed when the dataset is closed. This works for both new and old datasets, provided they were opened for output. Space will be released on the boundary used in the SPACE parameter. If tracks (or cylinders) were allocated, unused tracks (or cylinders), will be released.

Remark :
Using RLSE is highly recommended for datasets not intended for future expansions. Temporary datasets are ideal candidates. For datasets that expand in future runs, RLSE can result in a larger number of extents, and, possibly, a premature SB37-04 ABEND failure. RLSE will be ignored if the dataset is opened by another user (or shared by another job) ot the step ABEND’s.

e.g: SPACE=(TRK,(5,1),RLSE)

The LABEL Parameter

The LABEL parameter can specify :
• The sequence of a tape dataset on a volume.

• The type of label of the dataset.

General Syntax

LABEL=([seq-no][,type]) keyword parameter

Seq-no – Identifies the sequence number of the dataset on a tape volume. 1 to 4 digits. If omitted, it defaults to 1. If 0 is coded, it defaults to 1. Maximum : 9999
e.g LABEL=3

type – Identifies the type of label for the dataset.
There are many types of labels. To name a few, which are important from project perspective.
SL – Indicates IBM standard label. If the subparameter is omitted, SL is the default.

NL – Indicates no labels are used. NL is not commonly used. Normally, NL is used for a tape coming from or going to another installation which has no SL capabilities.

BLP – Bypass Label Processing : Indicates that labels will not be recognized and will be treated as ordinary files. BLP is used as a last resort when neither SL nor NL can accomplish what is required.

Label Verification : When retrieving an SL tape dataset, both the volume serial and the dataset name will be verified. When creating an SL tape dataset with VOL=SER or VOL=REF, only the volume serial will be verified.

When retrieving an NL tape dataset, neither the volume serial nor dataset name can be verified. However, only an NL tape volume can be mounted. An SL volume will be rejected.

Defaults : If omitted, the LABEL parameter defaults to (1,SL). There are four ways to supply the same information.
• Omit the LABEL parameter

• Code LABEL=(,SL) 1 is the default

• Code LABEL=1 SL is the default
SL
VOL HDR1 HDR2 TM SL DATA SET # 1 TM EOF1 EOF2 TM TM
NL
NL DATASET #1 TM NL DATASET #2 TM TM

TM – Tape Mark

The DCB Parameter

The DCB parameter specifies values to be used to complete the Data Control Block (DCB) when a dataset is opened. A DCB is constructed by the language processor (compiler or assembler), based on the appropriate instructions of the language being used, and resides inside the code of the program. The compiler, collects this information and defaults from various parts of the program (For e.g In COBOL, RECORD CONTAINS 80 CHARACTERS; BLOCK CONTAINS 10 RECORDS and so on ) and constructs the DCB. Note that the DCB exists only for non VSAM datasets and is checked by the OPEN routines (for input or output). Certain values must be “hard-coded” in the DCB by the program. Others can can be left out, giving the user the option of supplying these values via the DCB parameter( as well as other means).

There are three suppliers of DCB information :
• Values supplied by the program, referred to as hard-coded. When a value is hard-coded, it cannot be changed unless the program is changed.

• Values coded in the DCB parameter of the DD statement. These values will be ignored if they are already hard-coded.

• Values from the standard label of the dataset. The values supplied by the label are limited to : BLKSIZE,LRECL, RECFM, DSORG etc. Values from the label will not be used if they are hard-coded inside the program or coded in the DCB parameter.

General Syntax

DCB=([referback] | [model][,subparameter],…… keyword parameter

Referback – This can have three formats :
*.stepname.ddname - Requests that the DCB parameter be copied from the DD statement “ddname” found in the previous step “stepname”.
DCB=*.STEP2.DD1

*.ddname - Requests that the DCB parameter be copied from a previous DD statement “ddname” found in the same step “stepname”.
DCB=*.DD1

*.procexec.stepname.ddname - Requests that the DCB parameter be copied from DD statement “ddname” found in the previous step “stepname” found within a procecure “procexec” (name of EXEC statement invoking the procedure.
DCB=*.PR1.STEP2.DD1

Remark :
The DCB referback copies the DCB parameter as opposed to the DSN and VOL=REF referbacks which acquire the dataset name and the volser respectively, whether or not the DSN and VOL parameters are present in the referenced DD statement. If the DCB referback refers to a DD statement which contains no DCB, nothing is copied and no message appears.

Model – specifies the name of the dataset which :
• Must be cataloged. If it is not, the result will be a JCL error : IEF2121 jobname stepname ddname –DATASET NOT FOUND

• Must be on disk (Tapes not allowed)

• Must reside on a volume that is accessible (online)

This dataset is called a model DSCB. The DCB information from the label of the model is extracted and can be used.

E.g 1. DCB=DA0001T.EMPFILE
E.g 2. In case you want to override some of the subparameters, the overriding subparameters must follow the DSCB model dataset name.

DCB=(DA0001T.EMPFILE,LRECL=100,BLKSIZE=800)

Models, are generally used, during the creations of GDG’s and dummying the PDS.

Subparameters : There is vast number of subparameters, the great majority of which are seldom or never used.
• BLKSIZE -Specifies the size of the block (also known as the physical record). For RECFM=FB, the blocksize must be multiple of the logical record length, and it identifies the exact size of the block. For RECFM=VB, the blocksize can be any value up to the limit but atleast 4 bytes larger than the logical record length. For RECFM=U, the blocksize can be any value up to the limit
Remark : There is no default for BLKSIZE. Coding BLKSIZE=0, the system will compute the optimum blocksize based on the device type.

E.g DCB=BLKSIZE=800

LRECL – Specifies the size of the logical record. The maximum size is 32,760, and it cannot be larger than blocksize, unless RECFM=VBS is used.

E.g. DCB=(LRECL=80,BLKSIZE=800)

RECFM –Specifies the record format. There are several values (or combinations of values) that can be coded.
• F - All blocks and all logical records are fixed in size.

• V - Blocks as well as logical records are of variable size. The first 4 bytes of each block (and logical record) describes its length.

• B – One or more logical records reside in each block. B cannot be coded alone. It is used in conjunction with F or V. For example FB or VB.

• U – Blocks are of variable size. There are no logical records. Mainly used with Load Library.

• S- For fixed-size records, it indicates that no short blocks are permitted anywhere but the end of the data. For variable-size records, it indicates that a logical record can span more than one block. S cannot be coded alone. It must follow F,V,FB or VB.

• A – Indicates that the first character of each record is an ANSI control character to be used for printer carriage control. A cannot be coded alone. It must follow F,V,FB,VB or U.

E.g DCB=(LRECL=80,RECFM=FB,BLKSIZE=800)

If RECFM is not supplied through any means, U is the default.

DEN – Identifies the density of the tape. DEN=3(or 4) indicates 1600 (or 6250 ) BPI density.

BUFNO – Identifies the number of buffers to be allocated in virtual storage by the OPEN routines, which will contain the blocks to be rean in or written out. If omitted, default is 5. The maximum is 255. Coding for BUFNO a number greater than 5 may require that the REGION parameter be increased.

EROPT – Specifies what action to take if an unrecoverable I/O error occurs while reading or writing a block.
• ABE – Cause an ABEND failure (S001-1).

• SKP – Skip the block containing the error.

• ACC – Accept the block containing the error

The default is ABE

DSORG – Identifies the organization of the dataset
• PS – Specifies physical sequential organization. Mostly QSAM and sometimes BSAM.

• PO - Specifies partitioned organization (or BPAM)

• DA- Specifies direct organization (or BDAM)

• IS – Specifies indexed sequential organization(or ISAM)

ABEND failures due to inconsistent DCB values :
• S013-20 ABEND when RECFM=FB is used but the BLKSIZE is not an exact multiple of LRECL. Note that SYSOUT is an exception.

• S013-34 ABEND when RECFM=FB is used and the LRECL is greater than the BLKSIZE.

• S013-34 ABEND when RECFM=VB is used and the LRECL is greater than the BLKSIZE-4.

Remark :
If values for BLKSIZE or LRECL are not supplied by any source (hard-coded or the DCB parameter or DSCB), the result will be an S013-34 ABEND failure.

• S001-04 ABEND when BLKSIZE in the DCB parameter is smaller than the actual blocksize and is a multiple of the LRECL in the DSCB of the dataset.

It is important to understand which of these often-used parameters are normally hard-coded and which are not :
• BLKSIZE - Seldom hard-coded. The BLKSIZE is unrelated to the logic of the program and hard-coding its value would cause unnecessary changes whenever the BLKSIZE is changed. In COBOL, BLOCK CONTAINS 0 RECORDS must be coded to avoid hard-coding the BLKSIZE. Omitting this clause will cause a default of 1 to be used. The result will be a hard-coded BLKSIZE is equal to LRECL. Many installation standards disallow hard-coding the BLKSIZE for sequential and partitioned datasets.

• LRECL – Frequently hard-coded. The logic of any ordinary program is dependent on the LRECL and, as a result, the LRECL cannot be changed without changing the logic of the program. Many high-level languages like COBOL always hard-code the LRECL.

• RECFM – Frequently hard-coded. The logic of any ordinary program is dependent on the RECFM and, as a result, the RECFM cannot be changed without changing the logic of the program. Many high-level languages like COBOL always hard-code the RECFM.

Instream Data

The input stream submitted to the system for execution consists of two possible parts :
• JCL mandatory part of the input stream

• Data mixed in with JCL in the input stream. This data is known as sysin data or input stream data. It is optional part of the input stream and always has a logical record length of 80. Any records encountered in the input stream which are not JCL statements will be treated as sysin data.

Sysin data must be preceded by a DD statement such as :
//name dd *
data
/*

Sysin data encountered by JES2 or JES3 following a DD * statement will be saved on the SPOOL volume for future use. This is known as input spooling The sysin is delimited (the spooling stops) by :
• A /* (delimiter) statement found.
• A valid JCL statement.
• An end-of-file condition on reading device.

The asterisk (*) is a positional parameter. The DD * is a special statement which is under complete JES2 or JES3 control.

SYSIN is a very common ddname used by many vendor-written programs to pass control information to the utility. E.g SORT,IEBGENER,IDCAMS utilities.

In user writtem programs, if you use COBOL ACCEPT statement. In your run JCL one of the DD statements will be SYSIN dd statement.
//sysin dd *
1234
/*

With the above type of DD statement, one complication arises if the sysin data must consist of JCL statement. Because any JCL statement delimits sysin data. To accomplish this, DD DATA instead of DD * must be used.

//sysut1 dd data
1234
abcd
//dd1 dd dsn=da0001t.empfile,disp=shr
/*

A /* must be used to delimit a DD DATA statement. A word of caution: Failure to supply a /* will cause serious problems. JCL statements following DD DATA will unintentionally become part of sysin data. However, If you want /* to be part of sysin data, code DLM parameter.

//sysut1 dd data,dlm=’)(‘
1234
abcd
//dd1 dd dsn=da0001t.empfile,disp=shr
/*
xyz
)(

The two characters that are coded in the DLM parameter (apostrophes must be used for special characters) will act as a delimiter and /* will be treated as data. Any two characters can be used. However, characters that are likely to appear in the first two positions of any record must be avoided to prevent premature delimiting sysin data.

DD parameter Function
* For reading data without // or /* in columns 1 and 2.
DATA For reading data with // but not /* in columns 1 and 2 containing JCL or statements.
DLM For reading data with either // or /* in columns 1 and 2.

* and DATA are positional parameters whereas DLM is a keyword parameter.

Remark :
If sysin data is not preceded by DD *, the system will generate a statement and place it in front of the sysin data .

E.g
//da0001ta job la2719,…..
//s1 exec pgm=ass1
//steplib dd …
1234
//dd1 dd …

is equivalent to

//da0001ta job la2719,…..
//s1 exec pgm=ass1
//steplib dd …
//sysin dd * (generated statement)
1234
//dd1 dd …

Note : A line with blanks is the most common offender. It is invisible to the user but it will be treated as data by the system This may or may not cause problem. Let us look at the following example.
//da0001ta job la2719,…..
//s1 exec pgm=ass1

//steplib dd …
//sysin dd *
1234
//dd1 dd …

The system will interpret the above JCL in the following way :
//da0001ta job la2719,…..
//s1 exec pgm=ass1
//sysin dd *

//steplib dd …
//sysin dd * (generated statement)
1234
//dd1 dd …

Conclusion : If there are two or more DD statements by the same name in the same step. This is not an error condition. When the program opens for SYSIN the first of the two be used. The other will be allocated and ignored.

Remark :
Generically, each DD statement must have a unique ddname except in special cases viz concatenation. In JES2, if a step contains identical ddnames, the system allocates devices and space and does disposition processing for both the DD statements. However, the systen directs all references to the first DD statement with that name in the step. In JES3, if a step contains identical ddnames, the job ABEND’S during allocation.

The SYSOUT Parameter

Print records generated by a program are not normally routed directly to a physical printer(theoretically it is possible, but in practice it is seldom done). Instead, they are written on the SPOOL pack and saved there for later viewing on a terminal or printing (or both). This is called output spooling, and is under the control of JES2 or JES3 which later can use one of their print routines to print the dataset. These print routines must schedule the datasets for printing, and msgclasses are used for this purpose. All print routines (called printers or writers) are associated with one or more classes (in all 36 classes) and each dataset to printed must also be assigned classes. The printer routines selects datasets for printing in a very similar way as initiators selects jobs for executions. Use S.ST option of ISPF menu to view the output dataset.

The SYSOUT parameter can assign this class, known as sysout or output class, to a dataset. Such datasets are called sysout or output datsets.

General Syntax

SYSOUT=(class| *) keyword parameter

Class – Identifies the sysout class of the dataset from A to Z and 0 to 9.
*- Indicates that the same class used in the MSGCLASS parameter of the JOB statement (or the installation-defined default, if MSGCLASS parameter is omitted) is to be used.
E.g 1. sysout=a
E.g 2 //sysprint dd sysout=*

This DD statement is used for printing system messages generated by JES2 or JES3. Each step must have SYSPRINT DD statement. Absence will cause “ SYSPRINT DD STATEMENT MISSING” message in the sysout.

E.g 3 //sysout dd sysout=* (or any sysout class may be assigned)
This DD statement is used when you have COBOL DISPLAY clause in your program.

Concatenation

Concatenating Datasets

At times, program may have to read in sequence several input datasets as if they were one. This can accomplished without physically putting the data in one datasets. This is done by concatenating the datasets in JCL code with comparable DCB characteristics without programming changes.

Note that only sequential and partitioned datasets can be concatenated. For sequential datasets, the maximum number of concatenations is 255 and for PDS it is 16. Concatenation has meaning only for sequential processing.

E.g 1. Concatenation of physical sequential files.

//dd1 dd dsn=da0001t.pcs.group1,disp=shr
// dd dsn=da0001t.pcs.group2,disp=shr
// dd dsn=da0001t.pcs.group3,disp=shr

E.g 2. Concatenation of partitioned datasets.

//dd1 dd dsn=da0001t.pds1.group1,disp=shr
// dd dsn=da0001t.pds2.group2,disp=shr
// dd dsn=da0001t.pds3.group3,disp=shr

There are number of rules and restrictions for concatenations :
1. The first concatenation is the only one with a ddname.
2. The logical record length and the record format of concatenated datasets must be the same. However, the blocksizes need not be.
3. The blocksize of the first concatenation must be greater than or equal to blocksizes of all subsequent concatenation. Violation of this rule results in S001-04 ABEND failure. This is true for DFP Version 2.3. For version DFP 2.4, one can concatenate datasets in any sequence, but for the first concatenation code the DCB parameter with the largest blocksize of all the concatenations.

E.g. Assume that in the JCL below, the first concatenation has a blocsize of 800, the second a blocksize of 800- and the third a blocksize of 23400.
//infile dd dsn=da0001t.pcs.group1,disp=shr,dcb=23400
// dd dsn=da0001t.pcs.group2,disp=shr
// dd dsn=da0001t.pcs.group3,disp=shr

4. Both sequential datasets and partitioned datasets can be concatenated, but not with each other – sequential with sequential and partitioned with partitioned only. Member of a PDS is treated as sequential dataset and thus can be concatenated with sequential dataset.
E.g
//in dd dsn=da0001t.empfile,disp=shr
// dd dsn=da0001t.pcs.data(emp),disp=shr

5. Disk as well as tape datasets can be concatenated but not with each other. Only like devices should be concatenated, disk with disk and tape with tape.

DUMMY Parameter

The DUMMY parameter is a positional parameter. At times, one might want to execute a program but suppress read or write operations in certain jobs, For example., not print a report. At other times, one might want to test a program without actually processing data.

The DUMMY parameter specifies that :
• No device or external storage be allocated.

• No disposition processing is performed.

• No input or output operations are performed for sequential access methods.

Remark :
1 DCB information is established. Generally used during testing process and in procedures. Instead of using DUMMY, one may use DSN=NULLFILE. It differs from DUMMY by virtue of its position. It is a keyword parameter.
E.g //DD1 DD DSN=NULLFILE

2 When an attempt to dummy a PDS is made will cause an S013-64 ABEND failure.

3 The DCB parameter may be required while coding DUMMY. Failure to do so may cause an S013-10 ABEND failure.

4 DUMMY provides a safe way to eliminate I/O activity when required.

The JOBLIB DD Statement

The JOBLIB statement identifies the program library (load library) where the programs to be executed throughout the job resides. It must be placed between the JOB and the first EXEC statement.
E.g :
//da0001ta job,la2719,……
//joblib dd dsn=da0001t.lib.loadlib,disp=shr
//s1 exec pgm=proga
//s2 exec pgm=progb

Expanation : PROGA (and PROGB) is expected to reside in DA0001T.LIB.LOADLIB as a member of a library and the system searches the directory. If not found will search certain predefined libraries and the S806-04 ABEND failure occurs.

Remark :
A JOBLIB DD statement can have several concatenations (max: 16)
E.g
//da0001ta job,la2719,……
//joblib dd dsn=da0001t.lib.loadlib,disp=shr
// dd dsn=da0001t.lib1.loadlib,disp=shr
// dd dsn=da0001t.prod.loadlib,disp=shr
//s1 exec pgm=proga

Explanation : All concatenations may be searched to locate a program. If, however, the program is found in a concatenation other than the last one, other concatenations will not be used. Note that, if a duplicate names exist in different concatenations, the user can decide which one is to be executed by determining the sequence of the concatenations.

The STEPLIB STATEMENT

The STEPLIB statement identifies the program library (load library) where the program to be executed for the step where STEPLIB resides. It can be placed anywhere after the EXEC statement.

E.g 1:
//da0001ta job,la2719,……
//s1 exec pgm=proga
//steplib dd dsn=da0001t.lib.loadlib,disp=shr
//s2 exec pgm=progb
//steplib dd dsn=da0001t.lib.loadlib1,disp=shr

Explanation : Program PROGA is expected to reside in DA0001TA.LIB.LOADLIB as a member of the library. If not found, will search certain predefined libraries and the S806-04 ABEND failure occurs.

E.g 2:
//da0001ta job,la2719,……
//joblib dd dsn=da0001t.lib.loadlib1,disp=shr
//s1 exec pgm=proga
//s2 exec pgm=progb
//steplib dd dsn=da0001t.lib.loadlib,disp=shr
//s3 exec pgm=progc

A STEPLIB DD statement has the effect of negating the JOBLIB DD statement for a particular step.

STORAGE DUMP

When a step encounters an ABEND failure, it is often advantageous to request a virtual storage dump, which can then be helpful in determining the cause of an ABEND. To request a storage dump, one of the following three DD statements must be included in the step :
• A SYSUDUMP DD statement

• A SYSMDUMP DD statement

• A SYSABEND DD statement

//sysudump dd sysout=*

All virtual storage allocated to your program i.e user region of job’s address space. It is a formatted dump. SYSUDUMP usually writes to sysout. It can, however, write to a disk dataset, providing a way to preserve the SYSUDUMP information for later viewing and analysis.

//sysudump dd dsn=da0001t.dumpfile,space=(trk,(0,5),rlse),
// disp=(,delete,catlg),unit=sysda

No DCB is required.

Remark :
SYSUDUMP DD statement is more often used.

//sysmudump dd sysout=*

This is same as SYSUDUMP DD statement except for the fact that the dump is nonformatted. This type of dump is very difficult to analyze unless it is saved on a disk and then processed by the PRDUMP service aid.
SYSMDUMP is seldom used.

//sysabend dd sysout=*

When a SYSUDUMP DD statement is included in a step which ABEND’s, a formatted virtual storage dump will be provided. This dump will also include information about the failed step, as well as most of the MVS storage-resident information which is of no use to the average user. SYSABEND is intended for system programmer.

Remark :
1 If neither a SYSUDUMP nor a SYSMDUMP nor a SYSABEND statement is coded wihin a JCL of an ABENDing step, a small amount of information is provided. This information is seldom useful in resolving the problem that caused the ABEND failure.

2 If more than one of the above statements is included in the JCL of a step, only the last one will be used. The previous ones will be ignored.

//s1 exec pgm=ass1
//sysabend dd sysout=*
//sysudump dd sysout=*

Note that SYSUDUMP will be in use.

Back to JCL Index
Back to home page

5. PROCEDURE

2010-03-08T07:05:00.000-08:00

• There are two types of procedures :
- Catalogue Procedures
- InStream Procedures

• CATALOGUED PROCEDURE is a member of a PDS which is often refered to as procedure library or PROCLIB.

• INSTREAM PROCEDURES contained within job's input stream.

INVOKING A PROCEDURE

//PR EXEC ABC
OR
//PR EXEC PROC = ABC

RESTRICTIONS

- max 255 steps

• The following are not permitted to reside in a procedure :
- JOB Statement
- An EXEC statement invoking a procedure
- JOBLIB
- JOBCAT
- DD * or DATA
- // null statement
- A PEND statement

Common Rules for EXEC & DD Statement to Override for JCL Procedures

• A parameter can be replaced, added or nullified

• When replacing an existing parameter, the overriding parameter must be specified in its complete format. DCB is an exception

• An overriding parameter replaces the same parameter, if it exists. It is added to the statement if it does not exist.

• A syntactical JCL error inside a procedure cannot be corrected by overriding the erroneous parameter.

• To nullify an existing parameter "parameter" = must be coded

• To override any parameters in an concatenation other than the first one, the following must be coded :

//stepname.ddname DD
// DD
// .
// .
// DD overriding parameters

• To add an entire DD statement
// stepname.ddname DD complete parameter field.

RULES FOR EXEC STATEMENT OVERRIDING

• To override any parameter in a DD statement an independent DD statement must be supplied in the following format :

• The sequence of overriding DD statements must be the same as the sequence of the corresponding overridden statements. However, parameters within a DD statement need not be overridden in sequence.

• An additional DD statement must be the last one in a step's overriding statements.

• To override an EXEC parameter, " parameter.stepname=value" must be coded when adding or replacing a parameter and "parameter.stepname=" must be coded when nullifying a parameter.

• The PGM parameter cannot be overridden

• All overriding EXEC parameters must be coded in the EXEC statement that invokes the procedure.

• All overrides to EXEC parameters must be completed before overriding parameters in a subsequent step.

procedure lam

//S1 EXEC PGM=ED, PARM=(A,B,C,E)
// REGION=900K, TIME = (5,30)
//STEPLIB DD DSN=DEV.LOADLIB,DISP=SHR
//IN1 DD DSN=USER1.FILE2,DISP=SHR
//IN2 DD DSN=USER1.FILEX,DISP=OLD
// UNIT=TAPE, VOL=SER=000101
//REP DD SYSOUT =*,
//OUT DD DSN=USER1.PLA,DISP=(,CTLG,DELETE),
// UNIT=SYSDA, VOL=SER=BS3003
// SPACE=(CYL,(20.5),DCB=(BLKSIZE=4000,
// LRECL=80, RECFM=FB)

Required in step S1:

a) PARM must be (A,B,C,D) and TIME nullified
b) In IN1, DSN must be USER1.FILE3
c) IN2 must retrieve USER1.FILEX as a cataloged dataser
d) In OUT, BLKSIZE must be 23440

//S2 EXEC PGM=FORM, REGION=900K
//INA DD DSN=USER1.PLA,DISP=SHR
// DD DSN=USER1.F226,DISP=SHR
// DD DSN=USER1.F232,DISP=SHR
// DD DSN=USER1.F118,DISP=SHR
//OUTA DD DSN=USER.F323,DISP=(,CATLG,DELETE),
// UNIT=TAPE, VOL=SER=001110
// DCB=BLKSIZE=32700, LRECL=100,
// RECFM=FB)
//PRNT DD SYSOUT=*

Required in Step S2 :

a) COND = (0,LT) must be coded
b) In INA DSN in the third concatenation must be USER1.F228
c) In DD statement OUTA, UNIT be SYSDA
d) An entire DD statement :
//STEPLIB DD DSN=DEV.LOADLIB,DISP=SHR
must be coded.

//S3 EXEC PGM=REPO,REGION = 400K, COND=(O,LT)
//1N3 DD DSN=USER1.F333, DISP=OLD
//OUT3 DD DSN=USER1.F111,DISP=(,CRLG,DELETE),
// UNIT=SYSDA, VOL=SER=DEVO12,
// SPACE=(CYL,(50,15),RLSE),
// DC3=(BLKSIZE=23440,LRECL=80,RECFM=FB)
//PRINT DD SYSOUT =*
//

Required in Step S3 :

a) EVEN must be added to the COND parameter
b) In DD statement OUT3, RLSE must be removed from the SPACE parameter must be nullified.

SOME TYPICAL EXAMPLES

Example 1:

//S1 EXEC PGM=ONE
//OUT1 DD DSN=U1.S1,
// DISP=(,CTLG, DELETE),
// UNIT=TAPE
// DCB=(BLKSIZE=32700)

Required
OUT1 must be dummied

Override
//S.OUT1 DD DUMMY

Regardless of the contents, no other parameters are needed.

SOME TYPICAL EXAMPLES

Example 2 :

//S1 EXEC PGM=ONE
//IN1 DD DSN=U1.B1,DISP=SHR
// DD DSN=U2.B2,DISP=SHR
// DD DSN=U3.B3,DISP=SHR

Required
Second concatenation of INI must be dummy

Override
//S1.INI DD
DD DSN=U1.B3
DD DUMMY

Example 3:

//S1 EXEC PGM=ONE
//CNTL DD DSN=U1.CNTLIB(S1), DISP=SHR

Required
DD statement CNTL must be //CNTL DD*

Override
//S1.CNTL DD*

Regardless of the contents DD * will override all.

Example 4 :

//S1 EXEC PGM = ONE
//OVT4 DD DSN=U1.D1,DISP=NEW
// DISP=SYSDA,VOL=SER=TEST26,
// SPACE=CTRK,(500,50)),
// DCB=(BLKSIZE=23400,
// LRECL=100,RECFM=FB)

Required
DCB parameter must be eliminated

Override
//S1.OUT4 DD DCB=(BLKSIZE=LRECL=RECFM)

SYMBOLIC PARAMETERS & SYMBOLIC OVERRIDES

• Symbolic overrides can be used only when symbolic parameters have been coded inside the procedure

• A symbolic parameter is a name preceded by an ampersand (&)

• A symbolic parameter can be coded in place of any parameter, part of a parameter in the parameter field of an EXEC, DD or OUTPUT statement.

SYMBOLIC PARAMETER

Example 1 :

//S1 EXEC PGM=BL
//IN DD DSN=&H1..INFILE,DISP=SHR
//OUT DD DSN=&HQ..OUTFILE,DISP=,CATLG,DELETE),
// UNIT=SYSDA, DCB=(BLKSIZE=32700)

//PSK EXEC BLTX,HQ=PROD

- First period works as delimiter

Example 2 :

Procedure BLTX

//S1 EXEC PGM=BL
//IN DD DSN=&HQ…INFILE,DISP=SHR
//OUT DD DSN=&HQ…OUTFILE,DISP=,CATLG,DELETE
// UNIT=SYSDA,DCB(=BLKSIZE=32700)

//PSK EXEC BLTX,HQ='PROD.'

SYMBOLIC OVERRIDING

RULES FOR SYMBOLIC OVERRIDING

• An EXEC statement keyword (TIME, REGION etc.) cannot be used as a symbolic parameter.

• A symbolic override in either the EXEC or PROC statement that has no corresponding parameter in the procedure will result in a 'SYMBOL NOT DEFINED' JCL error.

• If a symbolic and a regular override conflict, the regular override always prevails.

• A symbolic parameter which is immediately followed by an alphabetic, numeric or national character must have a period at its end.

• A symbolic parameter can be coded many times in a procedure. When substitution occurs, all the occurrences will receive the same value.

• When nothing must be substituted for a symbolic parameter, "symbolic-override=' must be coded in the EXEC or PROC statement.

PROCEDURE SSP

//S1 EXEC PGM = P1, PARM = &PEL

Assume possible values that the PARM parameter can assume are ALD, BLD, CLD, etc.

//S1 EXEC PGM=P1, PARM = &PELLD

This will not work
Procedure SSP can be coded as

//S1 EXEC PGM=P1, PARM = PEL.LD

Now if the procedure is invoked

//A EXEC SSP, PEL=F

Substitution results in

//S1 EXEC PGM=P1, PARM = FLD

//S1 EXEC PGM = P1, PARM = &PEL

Example 1 :

//A EXEC SSP, PEL=FLD

Substitution results in

//S1 EXEC PGM=P1, PARM=FLD

Example 2 :

//B EXEC SSP, PEL = FLD, TIME = (5, 10)

substitution results in

//S1 EXEC PGM = P1, PARM=FLD, TIME = (5,10)

PROCEDURE SWP

//ABC PROCR=800K, Q=AUX, U=TAPE
//S1 EXEC PGM=P2, REGION=&R
//IN DD DSN=&Q..FILEX, DISP=SHR
//OUT DD DSN=&Q..FILEY, DISP=(,CATLG)
// UNIT = &U

//A EXEC SWP, Q=MAX

Substitution results in

//S1 EXEC PGM=P2, REGION=800K
//IN DD DSN=MAX.FILEX, DISP=SHR
//OUT DD DSN=MAX.FILEY, DISP=(,CATLG),
// UNIT =TAPE

THE PROC STATEMENT

• The purpose of the PROC statement is to contain symbolic override defaults.

• When a procedure is executed, the system will substitute symbolic parameters using symbolic overrides coded in the EXEC statement.

• For those symbolic overrides not found in the EXEC statement, the default symbolic overrides in the PROC statement will be used.

IN-STREAM PROCEDURES

• An in-stream procedures is a part of a job's input stream and exists only for the duration of the job.

• The PROC statement in an in-stream procedure is mandatory and serves two functions -
a) It signals the beginning of in-stream procedure
b) It contains default symbolic overrides.

• The PEND statement must be coded in an in-stream procedure to provide a delimiter

Remark :
1) A PROC statement in a catalogued procedure is optional. The only reason it is required is to contain default symbolic overrides.

Example :

//da0001ta JOB la2719,pcs,msgclass=A,
// msglevel=(1,1,),notify=da0001t
//* Instream prosedure
//procbr14 proc
//s1 exec pgm=iefbr14
//sysprint dd sysout=*
//dd1 dd dsn=da0001t.temp,
// disp=(old,delete)
// pend
//*
//step1 exec proc=procbr14
//s1.dd1 dd dsn=da0001t.temp1,
// disp=(,catlg,delete), unit=sysda,
// space=(trk,(2,1)),
// dcb=(1recl=80,recfm=fb,blksize=800)
//

Back to JCL Index
Back to home page

6. UTILITY

2010-03-08T07:02:00.000-08:00

IEFBR14 UTILITY

This Utility is commonly used to delete, allocate and to uncatalog dataset

Example 1 :

//DELETE EXEC PGM=IEFBR14
//* TO DELETE A FILE
//DD1 DD DSN=DA0001T.EMPLOYEE,
// DISP=(MOD,DELETE,DELETE),
// UNIT=SYSDA, SPACE=(TRK,0)

Example 2

//CREATE EXEC PGM=IEFBR14
//*TO ALLOCATE A NEW FILE
//DD1 DD DSN=DA0001T.EMPLOYEE,
// DISP=(NEW,CATLG,DELETE),
// UNIT=SYSDA,
// SPACE=(TRK,(2,1)),
// DCB=(BLKSIZE=800,LRECL=80,
// RECFM=FB,DSORG=PS)

An excerpt of a code illustrating, the deletion of a dataset, before COBRUN1 step is executed.

//DA000ITA JOB LA2719,PCS,NOTIFY=DA0001T,
// MSGCLASS=X, MSGLEVEL=(1,0)
//DELETE EXEC PGM=IEFBR14
//LOGFILE DD DSN=DA0001T.MYFILE2,
// SPACE=(TRK, (0),),UNIT=SYSDA
//COBRUN1 EXEC PGM=PROG2V1,PARM='AAAA'
//STEPLIB DD DSN=DA00021T,PVDB2.LOADLIB,
// DISP=SHR
//INFILE DD DSN=DA00021T, EMPLOYEE
DISP=OLD
//OUTFILE DD DSN=DA00021T.MYFILE2,
// DISP=(NEW,CATLG,DELETE),
// DCB=(LRECL=80, DSORG=PS,
// BLKSIZE=80, RECFM=FB),
// VOL=SER=BS3011,
// SPACE=(TRK, (45,15))
//SYSOUT DD SYSOUT=*

IEBGENER UTILITY

• This utility is commonly used to copy, concatenate and to empty sequential datasets

************************************************************************
* USING THE IEBGENER UTILITY TO COPY DATASETS
* SYSSUTI PROVIDING THE INPUT AND SYSUT2 BEING
* THE OUTPUT
************************************************************************

//DA0001TA JOB LA2719, PCS, NOTIFY=DA000IT,
// MSGCLASS=X
//CPYSTEP EXEC PGM=IEBGENER
//SYSSUT1 DD DSN=DA000IT.INDATA3, DISP=SHR
//SYSUT2 DD DSN=DA0001T.NEW,DISP=MOD
//SYSIN DD DUMMY
//SYSPRINT DD SYSOUT=*
//

************************************************************************
* USING THE IEBGENER UTILITY TO CONCATENATE DATASETS
* SYSSUT1 PROVIDING THE INPUT AND SYSUT2 BEING
* THE OUTPUT
************************************************************************
//DA0001TA JOB LA2719,PCS,NOTIFY=DA000IT,
// MSGCLASS=X
//CPYSTEP EXEC PGM=IEBGENER
//SYSUT1 DD DSN=DA000IT.INDATA1,DISP=SHR
// DD DSN=DA000IT.INDATA3,DISP=SHR
//SYSUT2 DD DSN=DA0001T.MYOUT,
// DISP=(NEW, CATLG, DELETE),
// UNIT=SYSALLDA,
// SPACE=(TRK,(5,1),RLSE)

************************************************************************
* USING THE IEBGENER UTILITY TO EMPTY EXISTING DATASET
************************************************************************
//DA0001TA JOB LA2719,PCS,NOTIFY=DA00IT,
// MSGCLASS=X
//CPYSTEP EXEC PGM=IEBGENER
//SYSPRINT DD SYSOUT=*
//SYSUT1 DD DUMMY, DCB=(BLKSIZE=800,
// LRECL=80, RECFM=FB)
//SYSUT2 DD DSB=DA000IT.MYOUT,
// DISP=SHR
//SYSIN DD DUMMY
//

SORT UTILITY

• The utility is commonly used to sort data, copy selective data, remove duplicates, change data throughout the file.

• This is the utility provided by MVS

USAGE : It reorders the Physical Sequential dataset as per requirement on given
field(s)
: These fields are called control fields or key fields.

WORKING : It assumes that all input records are out of sequence and it puts them in sequence you request.

Eg. Employee data is sorted in the sequence of Emp. No., Emp. Name or Salary etc.

SORT UTILITY

Syntax

Sort fields = (position, length, format, sequence) or
Sort fields = (position, length, sequence….), format = format

This syntax is used if all the fields on which the dataset to be sorted are of same type.

Position : Location of the 1st byte of the key field, in the input record

Length : Length in bytes of the key field. Sum of all key fields (their lengths) should not exceed 4092

Format : Two characters code that identifies the format (type) of the data

Sequence : A - Ascending
D - Descending

MERGE UTILITY

• This assumes that record are in proper sequence but at different locations i.e. in different files. It merges those files into one, in the given sequence.

Eg. : General ledger transactions for different months, in the sequence of a/c no. to be merged in one file.

SORT UTILITY

SORT JCL 1

//DA001TA JOB LA2719,PCS, NOTIFY=DA0001T.MSGCLASS=X
//*******************************************************
//*SORT ON THE EMPLOYEE NAME IN ASCENDING ORDER
//*******************************************************
//SRTSTEP EXEC PGM = SORT
//SYSIN DD *
SORT FIELDS = (1,5,CH,A)
/*
//SORTIN DD DSN=DA0001T.EMPLOYEE,DISP=SHR
//SORTOUT DD DSN=DA0001T.OUT SORT,
// SPACE=(TRK,(3,3)), UNIT=SYSDA
//SORTWK01 DD SPACE=(TRK,(10,5)),UNIT=SYSALLDA
//SORTWK02 DD SPACE=(TRK,(10,5)),UNIT=SYSALLDA
//SORTWK03 DD SPACE=(TRK,(10,5)),UNIT=SYSALLDA
//SORTWK04 DD SPACE=(TRK,(10,5)),UNIT=SYSALLDA
//SYSPRINT DD SYSOUT=*
//SYSOUT DD SYSOUT=*
//SORTMSG DD SYSOUT=*
//

SORT JCL 2

//DA001TA JOB LA2719,PCS, NOTIFY=DA0001T.MSGCLASS=X
//*******************************************************
//*SORTS ON ASCENDING DEPTNO & DESCENDING ENAME
//*******************************************************
//SRTSTEP EXEC PGM=SORT
//SYSIN DD *
SORT FIELDS = (17,2,PD,A,2,6,CH,D)
//SORTIN DD DSN=DA000IT.DEPT,DISP=SHR
//SORTOUT DD DSN=DA000IT.SORTOUT2
// DISP=NEW,CATLG,DELETE)
// SPACE=(TRK,(3,3)),UNIT = SYSDA
//SORTWK01 DD SPACE(TRK,(10,5)), UNIT=SYSALLA
//SORTWK02 DD SPACE(TRK,(10,5)), UNIT=SYSALLA
//SORTWK03 DD SPACE(TRK,(10,5)), UNIT=SYSALLA
//SORTWK04 DD SPACE(TRK,(10,5)), UNIT=SYSALLA
//SYSPRINT DD SYSOUT=*
//SYSOUT DD SYSOUT=*
//SORTMSG DD SYSOUT=*
//

SORT JCL 3

TO COPY SELECTIVE DATA

a) INCLUDE COND copies data that matches the condition given for e.g. in this case it will copy data where one character in 19th position equals 'M' or 'S'.

//DA001TA JOB LA2719,PCS, NOTIFY=DA0001T.MSGCLASS=X
/***********************************************************************
* SORTS ON THE INPUT FILE ON JOB AND SELECTS JOB BEGINNING WITH M
OR S INTO A DATA SET
//**********************************************************************
//SRTSTEP EXCE PGM=SORT
//SYSIN DD *
OPTION EQUALS
SORT FIELDS = (19,6,A), FORMAT=CH
INCLUDE COND = (19,1,CH,EQ,C'M', OR, 19, 1, CH, EQ, C 'S')
/*
//SORTIN DD DSN=DA0001T.INDATA3,DISP=SHR
//SORTOUT DD DSN=DA0001T.SORTOUT3,DISP=(NEW, CATLG)
// SPACE=(TRK,(3,3)), UNIT = SYSDA,
// DCB=(BLKSIZE=800, LRECL=80, RECFM=FB,
// DSORG=PS)
//SORTWK01 DD SPACE=(TRK,(10,5)), UNIT=SYSALLDA
//SORTWK02 DD SPACE=(TRK,(10,5)), UNIT=SYSALLDA
//SORTWK03 DD SPACE=(TRK,(10,5)), UNIT=SYSALLDA
//SORTWK04 DD SPACE=(TRK,(10,5)), UNIT=SYSALLDA
//SYSOUT DD SYSOUT=*
//

SORT JCL 4 (Sorts on Job and selects Jobs beginning with M and Deptno beginning with 1)

//DA001TA JOB LA2719,PCS, NOTIFY=DA0001T.MSGCLASS=X
//********************************************************
//*SORTS ON JOB INCLUDES JOBS BEGINNING WITH M AND DEPTNO
*BEGINNING WITH 1
//********************************************************
//SRTSTEP EXEC PGM=SORT
//SYSIN DD *
OPTION EQUALS
SORT FIELDS = (19,6,A),FORMAT=CH
INCLUDE COND=(19,1,CH,EQ,C'M',AND,51,1,CSF,EQ,1)
/*
//SORTIN DD DSN=DA0001T.INDATA3,DISP=SHR
//SORTOUT DD DSN=DA0021T.SORTOUT4,DISP=NEW,CATLG),
// SPACE=(TRK,(3,3,)), UNIT = SYSDA,
// DCB=(BLKSIZE=800, LRECL=80, RECFM=FB,
// DSORG=PS)
//SORTWK01 DD SPACE=(TRK,(10,5)),UNIT=SYSALLDA
//SORTWK02 DD SPACE=(TRK,(10,5)),UNIT=SYSALLDA
//SORTWK03 DD SPACE=(TRK,(10,5)),UNIT=SYSALLDA
//SORTWK04 DD SPACE=(TRK,(10,5)),UNIT=SYSALLDA
//SYSOUT DD SYSOUT=*
//

SORT UTILITY

SORT JCL 5 (Sorts on Job and omits Jobs beginning with M or S

OMIT COND: INCLUDE and OMIT are mutually exclusive

Records which do not satisfy the condition are sorted and copies into the output dataset

//DA001TA JOB LA2719,PCS, NOTIFY=DA0001T,MSGCLASS=X

//********************************************************
//*SORTS ON JOB *OMITS JOBS BEGINNING WITH M OR S
//********************************************************
//SRTSTEP EXEC PGM=SORT
//SYSIN DD *
OPTION EQUALS
SORT FIELDS = (19,6,A),FORMAT=CH
OMIT COND = (19,1,CH,EQ,C,'M',OR, 19,1,CH,EQ,C'S')
/*

Back to JCL Index
Back to home page

COBOL Tutorial

2010-02-17T16:33:00.000-08:00

1. Introduction
2. Working with data
3. ACCEPT/DISPLAY verbs
4. MOVE statements
5. Arithmetic verbs
6. Decision Making
7. Iterations
8.File Handling
9.Sorting and merging files
10.Trapping Runtime errors
11.CONTROL BREAK PROCESSING
12.Indexed Files
13.Table Handling
14.Call statement
15.String Handling

1. Introduction

2010-02-17T16:32:00.001-08:00

COBOL was developed in 1959 by a group called the CODASYL Committee. CODASYL is an abbreviation for Conference on Data Systems Languages. This committee included representatives from academia, user groups, and computer manufacturers. The ultimate objective of this committee was to develop a standard business-oriented language for which all major manufacturers would provide compilers. The Department of Defense convened this conference since it, as well as other government agencies, was particularly dissatisfied with the lack of standards in the computing field.

Features of COBOL

1. Business-Oriented Language
As a business-oriented language COBOL is designed specifically for commercial applications, such as payroll and inventory, that typically operate on a large volume of data.

2. A Standard Language
COBOL compilers are available for most computers. The same COBOL program may be compiled and run on a variety of different machines.
The universality of COBOL allows computer uses greater flexibility than they would have with many other languages. A company is free to acquire different brands of computers while using a single programming language. Similarly, conversion from one model computer to a more advanced or newer one presents no great problem as long as there is a COBOL compiler for each model.

3. An English-like Language
COBOL is an English-like language. All instructions can be coded using English words rather than complex codes. To add two numbers together, for example, we use the word ADD. Similarly, the rules for programming in COBOL conform to many of the rules for writing in English, making it a relatively simple language to learn.

4. Self Documenting
One advantage of COBOL computer programs is that they can be substantially self-documenting. Self-documentation is a characteristic of a language that allows a reader of a program to understand its function and follow its processing steps. The language instructions are very English-like, but the programmer has substantial choice as to whether to make a program self-documenting or obscure.

Structure of COBOL programs
COBOL programs are written according to a special structure which is organized into a hierarchy of parts.

A character is the lowest form in the program structure

A word is made up of one or more characters.

A clause consists of characters and words and is used to specify an attribute of an entry.

A statement is a syntactically valid combination of words and characters written in the PROCEDURE DIVISION of a COBOL program and beginning with a verb.

A sentence is a sequence of one or more statements, the last of which is terminated by a period followed by a space.

A paragraph consists of one or more sentences.

A section consists of one or more paragraphs.

A division consists of one or more paragraphs or sections. Every COBOL program consists of four divisions in the following order : IDENTIFICATION DIVISION, ENVIRONMENT DIVISION, DATA DIVISION and PROCEDURE DIVISION.

COBOL Words
A sequence of continuous characters from the character set can form a word. There are two types of COBOL words, reserved words and user-defined words.

COBOL words are formed by using the following character set :

Digits 0-9
Letters A-Z
Space (blank)
Special characters ( ) . “ + - * / = $ , ; < >

Reserved words are words that are defined both syntactically and semantically by the COBOL language. The programmer cannot use any of these words except in the form specified by the language.

User-defined words (data names) are words supplied by the programmer in order to satisfy the format of a clause or statement in the language.

Rules for forming user-defined words

· 1 to 30 characters.
· Letters, digits, and hyphens (-) only.
· No embedded blanks.
· At least one alphabetic character.
· May not begin or end with a hyphen.
· No COBOL reserved words such as DATA, DIVISION, etc.

Valid datanames Invalid datanames
HOURS DISCOUNT-
SALES-TOTAL AUTHOR
SUBJECT1 BASIC+HRA
AMOUNT-OF-TRANSACTION-OUT 123

Divisions
· IDENTIFICATION DIVISION
The IDENTIFICATION DIVISION is the first division of a COBOL program. It supplies the information about the program to others who may read or use the program. The IDENTIFICATION DIVISION is divided into the following paragraphs :

PROGRAM-ID. Program-name.
Ø Used to specify the program name. Use names of eight characters or less, letter and digits only, because such names are accepted on all systems.

AUTHOR. author-name.
Ø Used to specify the programmer’s name.

DATE-WRITTEN. Date.
Ø Specify the date the program was coded.

DATE-COMPILED. Date.
Ø Can be coded with an actual date. But if it is coded without a date entry, the compiler itself will automatically fill in the actual date of compilation.

· ENVIRONMENT DIVISION
The ENVIRONMENT DIVISION is the only machine-dependent division of a COBOL program. It is composed of two sections :

CONFIGURATION SECTION.
SOURCE-COMPUTER. Computer.
Ø Computer used for compiling the program.
OBJECT-COMPUTER. Computer.
Ø Computer used for executing the program.

INPUT-OUTPUT SECTION.
Ø Supplies information concerning the input and output devices used. This section is required only if the program uses files or prints reports.
FILE-CONTROL.

· DATA DIVISION
The DATA DIVISION defines and describes fields, records, and files in storage. Commonly, it consists of the following sections :

FILE SECTION.
Ø Defines all input and output files.

WORKING-STORAGE SECTION.
Ø Reserves storage for fields not part of input or output but nonetheless required for processing. These include constants, end-of-file indicators, and work areas.

LINKAGE SECTION.
Ø Used to identify items that will be passed to the called program from the calling program and vice-versa.

· PROCEDURE DIVISION
The PROCEDURE DIVISION is divided into paragraphs. Each paragraph is an independent module or routine that includes a series of instructions designed to perform specific set of operations. Paragraph names are coined by the programmer following the rules for forming data-names.
A PROCEDURE DIVISION may also consist of several sections. A section may contain several paragraphs.

Coding a COBOL program
A COBOL program file will have an extension .CBL. A COBOL program needs to be coded following the below mentioned coding rules.
Columns
Use
Explanation
1-6
Sequence numbers or Page and Line numbers (optional)
Used for sequence-checking
7
Indicator column
Denotes
* comments
/ page break
- continue strings
8-11
Area A
DIVISION, SECTION, paragraph names and level 01, 77 entries
12-72
Area B
Statements and sentences
73-80
Comment
Ignored by the compiler
Note : Division, Section, Paragraph Names and Sentences must end with a period followed by at least one space.

A Sample COBOL Program – Eg. 1.1

IDENTIFICATION DIVISION.
PROGRAM-ID. SAMPLE1.
AUTHOR. XYZ.
DATE-WRITTEN. 1-JUN-2000.
DATE-COMPILED.

ENVIRONMENT DIVISION.
CONFIGURATION SECTION.
SOURCE-COMPUTER. IBM-PC.
OBJECT-COMPUTER. IBM-PC.

DATA DIVISION.

PROCEDURE DIVISION.
0000-MAIN.
STOP RUN.

Back to COBOL Index

2. Working with data

2010-02-17T16:31:00.000-08:00

Hierarchical representation of data
Level numbers
The record description specifies the format of a record . Record description entries indicate :
The items or fields to appear in the record
The order in which the fields appear
How these fields are related to one another

Data is grouped in COBOL using the concept of a level. Records are considered the highest level of data in a file, and are coded on the 01 level. There can be only one data-name at the 01 level for each record, as it is the all-inclusive data-name. A field of data within the record is coded on a level subordinate to 01, i.e 02, 03 and so on. Any level number between 02 and 49 may be used to describe fields within a record.

Elementary and Group Items
An elementary item has no subordinate parts. A group item may consist of one or more group items. In the code below :
FIRST-NAME, ZIP-CODE are elementary items
CUSTOMER-ADDRESS, STREET are group items

Eg 2.1:

01 CUSTOMER-ADDRESS
02 NAME
03 FIRST-NAME
03 LAST-NAME
02 STREET
03 S-NUMBER
03 STREET-NAME
02 ZIP-CODE

PICTURE Clauses
Group items are defined by a level number and a name, which is followed by a period. Elementary items must be described with a PICTURE (or PIC, for short) clause.

Functions of the PICTURE Clause
Specifies the type of data contained within an elementary item.
Indicates the size of the field.

Types of data fields

Type
Picture clause
Explanation
Alphabetic
A
A field that may contain only letters or blanks. E.g. a name or item description field.
Alphanumeric
X
A field that may contain any character i.e. letters, digits, blanks and/or special characters. E.g. an address field.
Numeric
9
Any signed or unsigned field that will contain only digits is considered numeric.

Size of data fields
The size of the field is denoted by the number of A’s, X’s, or 9’s used in the PICTURE.

Eg 2.2:
05 AMT PIC 99999.

AMT is an elementary field consisting of five positions of numeric data. Alternatively, the same can be coded as follows :

Eg 2.3:
05 AMT PIC 9(5).

At least one space must follow the word PIC. All A’s, X’s, or 9’s should appear consecutively with no spaces between the characters. Similarly, if parentheses are used to denote the size of a field, no spaces should appear within the parentheses.

Eg 2.4:
01 CUSTOMER-ADDRESS.
02 NAME.
03 FIRST-NAME PIC X(10).
03 LAST-NAME PIC X(15).
02 STREET.
03 S-NUMBER PIC 9(3).
03 STREET-NAME PIC X(20).
02 ZIP-CODE PIC 9(6).

WORKING-STORAGE SECTION
Defines and describes all data storage fields required for Processing (Including constants).
These fields are not part of any input/output file.

Can be used for storing
Intermediate results
Counters, Flags
Input/Output Records
Tables etc.

Types of data
Variable
Data entered by the user at run-time.

Constant
Data required for processing that is not dependent on the input to the system. There are 3 types of literals.

1. Numeric Literals
A numeric literal is a constant used primarily for arithmetic operations.

Rules for forming numeric literals
a) 1 to 18 digits
b) A + or – sign may be used, but it must appear to the left of the number.
c) A decimal point is permitted within the literal. The decimal point, however may not be the rightmost character of the literal.

Eg 2.5:
+34
-8.6
.008

2. Nonnumeric Literals
A nonnumeric literal is a constant that is used in the PROCEDURE DIVISION for all operations except arithmetic.

Rules for forming nonnumeric literals
a) The literal must be enclosed in quotation marks.
b) A maximum of 120 characters are permitted.
c) Any character permitted in the COBOL character set may be used except the quotation mark.

Eg 2.6:
‘CODE’
‘$ 123’

3. Figurative Constants
A figurative constant is a COBOL reserved word that has special significance to the compiler.

The figurative constants are
ZERO, ZEROS, ZEROES - references the value of zeros
SPACE, SPACES - reference the value of blank
QUOTE, QUOTES -references the quotation mark
-used in nonnumeric literals to include a
quote.
e.g ‘D’Quote’Souza will store the value D’Souza.
LOW-VALUE , LOW-VALUES - references the lowest value in the collating
sequence for the particular computer system.
HIGH-VALUE, HIGH_VALUES - references the highest value in the collating
sequence for the particular computer system.
ALL - references one or more occurrences of the
single character nonnumeric literal.
e.g. MOVE ALL “A” TO HEAD-1, will
result in the field HEAD-1 being filled with A’s.

Special Characters (Numeric Field) :
Implied decimal point
The symbol V denotes an implied decimal point, which does not occupy a storage position. In the code below, AMOUNT occupies 5 positions.

Eg 2.7:
05 AMOUNT PIC 999V99.

Eg 2.8:
PIC Description Value Stored as
99V9 38.50 385
9(4)V99 452.39 045239
999 550 550

Signed numbers
If a numeric field can have negative contents, then it must have an S in its PIC clause. It must be the leftmost character. It does not take any storage space.

Eg 2.9:
02 BALANCE PIC S999.

Edited fields

The purpose of editing is to make data more suitable for human reading. Thus editing in its most common use is associated with printing data on the printer. For example, we may suppress leading zeros, we may use commas to make long numeric values more legible, we may insert a dollar sign in front of a value, etc.

The editing characters are Z * $ - + CR DB . , B 0 /

Z - Suppressing leading zeros

The Z PICTURE character is used to replace leading zeros by blanks and thus performs a function identical to that of the floating . Zero suppression terminates when the first nonzero digit or the . character is encountered, whichever occurs first. When Z’s have been designated for all positions in a field and the value to be inserted in that field is zero, in that case the entire field is blanked. Z’s can appear before as well as after the decimal point. The number of Z’s representing integers in the report-item should be equal to the number of integers or 9’s in the sending field.

Eg 2.10:
PIC Description Value Printed as
Z99 25 b25
ZZZV99 25 b2500
ZZZV99 0.10 bbb10
ZZZVZZ 0.052 bbb05
ZZZVZZ 0.00 bbbbb

* - Check Protection
The * character is referred to as a check-protect character and is normally used to protect dollar amounts written on checks or other negotiable documents. Asterisks are zero-suppression characters that replace each non-significant zero and comma with * instead of a space.

Eg 2.11:
PIC Description Value Printed as
**999 04678 *4678
***99 00052 ***52

$ - Dollar Sign
By use of the $ PICTURE character the dollar sign is written in the position in which it is to appear in the output. Since the $ sign is counted in the size of the field, the field should be assigned at least one more position than the maximum number of significant digits expected. The $ may also be floated, by which we mean that it will be entered to the left of the first significant digit in the field and be preceded by blanks. The $ float stops when wither the first nonzero digit or the . or V is encountered. When the $ sign appears in all positions and the value is zero, the effect is to blank the entire field (including any . and ,).

Eg 2.12:
PIC Description Value Printed as
$999V99 125.13 $12513
$9(5)V99 100.00 $0010000
$$99V99 12.49 b$1249
$$$$9V99 150.10 $15010
$$$$V99 0.15 bbb$15
$$$$V$$ 0.0 bbbbb

. - (Decimal Point)
The . (decimal) PICTURE character indicates the position of the decimal point and serves to align the actual decimal values in the field, only one such character may appear in a field. Further, a field cannot contain both a V and a . PICTURE character. It cannot be the rightmost character. If all the digits before and after the decimal point are zero, the resulting field will be blank.

Eg 2.13:
PIC Description Value Printed as
$9,999.99 2,350.22 $2,350.22
$9,999.99 150.31 $0,150.31
$$,999.99 150.31 bb$150.31
$$,$$$.99 24.40 bbb$25.40
$$,$$$.999 0.019 bbbbb$.019
$$$$$.$$$ 0.0 bbbbbbbbb

, - (Comma)
The comma is placed in the positions in which it is desired. A field may include more than one , (comma) PICTURE character if the size of the field warrants it. A comma will be appropriately suppressed if no significant digit precedes it. It cannot appear as the leftmost or rightmost character.

Eg 2.14:
PIC Description Value Printed as
$9,999.99 2,350.22 $2,350.22
$9,999.99 150.31 $0,150.31
$$,999.99 150.31 bb$150.31
$$,$$$.99 24.40 bbb$25.40
$$,$$$.999 0.019 bbbbb$.019

$$,$$$.$$$ 0.009 bbbbb$.009
$$,$$$.$$$ 0.0 bbbbbbbbbb
$$,$$9.999 2,210.2 $2,210.200
$$,999.9 2,210.2 $2,210.2
$$,999.9 2,210.256 $2,210.2
$9,999.9999 23 $0,023.0000

- (Minus) and + (Plus)
The – PICTURE character prints a minus sign only if the quantity is negative and omits a sign for all other quantities. It can appear as the leftmost or rightmost character. The – PICTURE insertion character differs from the S character in that the use of the S character identifies a field as a signed one for computational purposes, but the sign does not occupy a position. Use of the – PICTURE character leads to a field in which the sign occupies a character position.

The + PICTURE character is used to print wither a plus sign or a minus sign for all values. A + sign will be generated for positive or unsigned quantities, and a – sign will be generated for negative quantities. The sending field should have an $ in its PICTURE clause for it to be interpreted as a signed number.

The + or – PICTURE character can appear as the leftmost or rightmost character. They can also be floated, similar to the $ character. However , the +, -, and $ are mutually exclusive as floating characters. If we want to have both $ float and + or – sign representation, we write the + or – to the right of the field.

Eg 2.15:
PIC Description Value Printed as
+999.9 35.2 +035.2
999.9+ 35.2 035.2+
999.9+ -35.2 035.2-
++9.9 -001.3 b-1.3
+++9.99 .05 bb+0.05
+++9.99 -.05 bb-0.05
++++.++ .01 bbb+.01

----.-- 0.0 bbbbbbb
--99.99 -10.25 b-10.25
--999.99 100.25 b100.25
999.9- -10.2 010.2-

DB/CR
In accounting applications there is often need to identify values that represent debits or credits. The COBOL language facilitates such differentiation by means of the DB (debit) and CR (CR) editing characters. The DB or CR symbol is written only to the right of a field in the PICTURE clause, and in both cases it is represented in storage for the purpose of subsequent output only when the value is negative.

Summary for use of + - DB CR
PIC Storage when Storage when
Character data positive data negative

+ + -
- Blank -
DB Blank DB
CR Blank CR

Eg 2.16:
PIC Description Value Printed as
$999.99DB 135.26 $135.26bb
$999.99DB -135.26 $135.26DB
$,$$99.99CR -10.50 bb$10.50CR

B – (blank)
The B insertion editing character results in blanks being entered in the designated positions.

Eg 2.17:
05 NAME PIC ABABA(10) VALUE ‘RBSMITH’.
NAME = RbBbSMITHbbbbb

0 - (Zero)
The zero insertion character causes zeros to be inserted in the positions in which it appears.

Eg 2.18:
05 AMOUNT PIC 9(4)000 VALUE 1365.
AMOUNT = 1365000

/ - (stroke)
Each / (stroke) in the PICTURE character string represents a character position into which the stroke character will be inserted.

Eg 2.19:
05 PRINT-DATE PIC 99/99/99 VALUE 040798.
PRINT-DATE = 04/07/98

VALUE Clause
In addition to defining storage fields using the PICTURE clause it is often desirable to assign initial values to elementary items in the WORKING-STORAGE SECTION. Such a value may remain unchanged throughout the program, or it may change in the course of program execution. Such initial values are generally not assigned to FILE SECTION items, since such fields either receive their data from the external medium or from other storage location as the result of program execution.

Eg 2.20:
02 PAGE-TITLE PIC A(14) VALUE “SAMPLE PROGRAM”.
02 TAX-RATE PIC V99 VALUE IS 0.03.

Continuation of Literals from one line to the next
A nonnumeric literal may contain up to 120 characters. The same applies to a nonnumeric literal in a VALUE clause. Sometimes a nonnumeric literal may not fit on a single line, hence it is necessary to continue this literal.

Rules for continuation of nonnumeric literals
Begin the literal in the VALUE clause with a quotation mark.
Continue the literal until position 72, the end of the line, is reached. Do not end with a quotation mark on this line.
Place a hyphen on the next line in the position beginning in Area B of the second line. Begin with a quotation mark.
End the literal with a quotation mark.

Eg 2.21:
01 PAGE-HEADING PIC X(36) VALUE “MONTHLY TRANSACTIONS FOR AP
- “RIL 2000”.

USAGE clause
Numeric data in a computer may be represented in one of two basic modes. They may be represented as character data or as numeric data. The arithmetic registers of computers perform arithmetic with numeric data that is in numeric, not character mode. If numeric data is represented in character mode, it must first
be converted to numeric mode before arithmetic computations can be performed.
In COBOL, data in character mode is described in DISPLAY mode, while data in numeric mode is described as being COMPUTATIONAL MODE. All data items are assumed to be in DISPLAY mode unless they are declared to be COMPUTATIONAL. The declaration is done in the DATA DIVISION with the USAGE clause.

Eg 2.22:
02 AMOUNT-1 PIC 99.
02 AMOUNT-2 PIC 99 USAGE DISPLAY.
02 AMOUNT-3 PIC 99 USAGE COMPUTATIONAL.
02 AMOUNT-4 PIC 99 USAGE COMP.

REDEFINES Clause
The REDEFINES clause can be used to allow the same storage location to be referenced by different data-names or to allow a regrouping or different description of the data in a particular storage location.

Restrictions

The REDEFINES clause cannot be used
- at the 01 level in the FILE SECTION.
- when the levels of data-name-1 and data-name-2 are different.
- When the level number is 66 or 88.

Eg 2.23:
01 SAMPLE.
02 RECEIVABLE.
03 CUSTOMER-NUMBER PIC 9(8).
03 CUSTOMER-NAME PIC X(11).
03 AMOUNT PIC 9(4)V99.
02 PAYABLE REDEFINES RECEIVABLE.
03 VENDOR-NUMBER PIC 9(6).
03 VENDOR-NAME PIC X(12).
03 VENDOR-OWED-AMT PIC 9(5)V99.

RENAMES Clause
The RENAMES clause provides the programmer with the capability of regrouping elementary data items. It resembles the REDEFINES clause, except that it can form a new grouping of data items which combines several items. Use of the RENAMES clause is always signaled by the special 66 level number.

Eg 2.24:
01 TAX-RECORD.
02 SOC-SEC-NUMBER PIC X(9).
02 NAME.
03 FIRST-NAME PIC X(10).
03 LAST-NAME PIC X(15).
02 TOTAL-YTD.
03 GROSS-PAY PIC 9(8)V99.
03 NET-PAY PIC 9(8)V99.
03 TAX PIC 9(5)V99.
66 LAST-GROSS RENAMES LAST-NAME THRU NET-PAY.

Qualification of names
A data name that is not unique must be qualified in COBOL verbs.

Eg 2.25:

01 IN-REC
05 NAME PIC X(10).
05 AGE PIC 99.
01 OUT-REC.
05 NAME PIC X(10).
05 B-DATE PIC 9(6).

MOVE NAME OF IN-REC TO NAME OF OUT-REC.

Back to COBOL Index

3. ACCEPT/DISPLAY verbs

2010-02-17T16:30:00.001-08:00

The PROCEDURE DIVISION contains all the instructions required for processing. It is divided into various paragraphs or modules. Each module consists of sentences.

The ACCEPT and DISPLAY verbs are used for input and output in conjunction with storage fields that are not part of any files.

ACCEPT
The instruction ACCEPT identifier enable the user to enter input data directly from a keyboard.

Eg 3.1:
ACCEPT MY-NAME.

DISPLAY
DISPLAY can reference a series of identifiers or literals.

Eg 3.2:
DISPLAY MY-NAME.
DISPLAY “HELLO”.

STOP RUN
The verb STOP RUN terminates program execution. A program may contain more than one STOP RUN statement, depending on the logic of the program. STOP RUN signifies the logical end of the program.

A program using DISPLAY and ACCEPT.
Eg 3.3:
IDENTIFICATION DIVISION.
PROGRAM-ID. SAMPLE2.
*This program accepts the user’s name and displays a message.
AUTHOR. XYZ.
DATE-WRITTEN. 1-JUN-2000.
DATE-COMPILED.

ENVIRONMENT DIVISION.
CONFIGURATION SECTION.
SOURCE-COMPUTER. IBM-PC.
OBJECT-COMPUTER. IBM-PC.

DATA DIVISION.
WORKING-STORAGE SECTION.
01 USER-NAME PIC X(15).
PROCEDURE DIVISION.
0000-MAIN.
DISPLAY “Enter your name : “.
ACCEPT USER-NAME.
DISPLAY “HELLO “ USER-NAME.
STOP RUN.

Back to COBOL Index

4. MOVE statements

2010-02-17T16:28:00.000-08:00

A value can be moved from one storage location to another by the move statement. Contents of receiving field are changed after the operation.

Verb

Sending field
Receiving field

MOVE AMT-IN TO AMT-OUT.

The contents of AMT-In will be copied to the second field, AMT-OUT, as a result of the MOVE operation.

Eg 4.1:
MOVE TOTAL TO PRINT-TOTAL
MOVE ‘INVALID’ TO MESSAGE.
MOVE ZEROS TO TOTAL

Types of MOVE :
The MOVE statement can be categorized based on the receiving field : numeric MOVEs and non-numeric MOVEs.

Numeric MOVE
A numeric move is one in which a numeric field or literal is moved to a numeric receiving field.

When Sending and Receiving fields have the same PIC clauses
If the PIC clauses of both fields are identical, the contents of identifier-2 will be replaced with the contents of identifier-1 and the sending field will be unchanged.

When Sending and Receiving fields have different PIC clauses
Rule 1 : Moving integer portions of numeric fields
When moving an integer sending field or an integer portion of a numeric sending field to a numeric receiving field, move, movement is from right to left. All nonfilled high-order (leftmost) integer positions of the receiving field are replaced with zeros.

Eg 4.2:
05 AMT-IN PIC 999 VALUE 123.
05 AMT-OUT PIC 9(4) VALUE 4567.
MOVE AMT-IN TO AMT-OUT.
Result :
AMT-OUT = 0123

Avoiding truncation
In a numeric move, if the receiving field has fewer integer positions than the sending the field, the most significant digits will be truncated.

Eg 4.3:
05 AMT-IN PIC 999 VALUE 123.
05 AMT-OUT PIC 9(2) VALUE 45.

MOVE AMT-IN TO AMT-OUT.

Result :
AMT-OUT = 23

Rule 2: Moving decimal portions of numeric fields
When moving a decimal portion of a numeric sending field to the decimal portion of a numeric receiving field, movement is from left to right, beginning at the implied decimal point. Low-order (rightmost) non-filled decimal portions of the receiving field are replaced with zeros.

Eg 4.4:
a. When receiving field has more decimal positions than the sending field
05 AMT-IN PIC 99V99 VALUE 12.34.
05 AMT-OUT PIC 99V999 VALUE 56.789.

MOVE AMT-IN TO AMT-OUT.

Result :
AMT-OUT = 12.340

b. When receiving field has fewer decimal positions than the sending field
05 AMT-IN PIC V99 VALUE.34.
05 AMT-OUT PIC V9 VALUE .5.

MOVE AMT-IN TO AMT-OUT.

Result :
AMT-OUT = .3

Note : The same rules apply to numeric literals moved to numeric fields

Non-numeric MOVE
A non-numeric MOVE operation occurs in the following cases :
1. Moving an alphanumeric or alphabetic field, defined by a PICTURE of X’s or A’s, to another alphanumeric or alphabetic field.
2. Moving a non-numeric literal to an alphanumeric or alphabetic field.
3. Moving a numeric field or numeric literal to an alphanumeric field or to any group item.

Rule :
In a non-numeric move, data is transmitted from the sending field to the receiving field from left to right. Low-order or rightmost positions of the receiving field that are not replaced with sending field characters are filled with spaces.

Eg 4.4:
a. When receiving field is larger than the sending field

05 NAME-IN PIC XXX VALUE “ABC”.
05 NAME-OUT PIC X(5) VALUE “DEFGH”.

MOVE NAME-IN TO NAME-OUT.

Result :
NAME-OUT = ABCbb

b. When receiving field is smaller than the sending field

05 NAME-IN PIC XXX VALUE “ABC”.
05 NAME-OUT PIC XX VALUE “PQ”.

MOVE NAME-IN TO NAME-OUT.

Result :
NAME-OUT = AB

c. When the sending field is numeric integer and the receiving field is non-numeric

05 NAME-IN PIC 999 VALUE 321
05 NAME-OUT PIC X(5) VALUE “DEFGH”.

MOVE NAME-IN TO NAME-OUT.

Result :
NAME-OUT = 321bb

d. When the sending field is a non-numeric literal

05 NAME-OUT PIC X(5) VALUE “DEFGH”.

MOVE “XYZ” TO NAME-OUT.

Result :
NAME-OUT = XYZbb

e. When the sending field is a figurative constant

05 NAME-OUT PIC X(5) VALUE “DEFGH”.

MOVE SPACES TO NAME-OUT.

Result :
NAME-OUT = bbbbb

A group move is considered a non-numeric move
All group items, even those with numeric subfields, are treated as alphanumeric fields.

Eg 4.5:
05 DATE-OUT.
10 MONTH-OUT PIC 99 .
10 YEAR-OUT PIC 99.

a. MOVE 1 TO MONTH-OUT.MOVE 99 TO YEAR-OUT.

Result :
DATE-OUT = 0194

b. MOVE 194 TO DATE-OUT.

Result :
DATE-OUT = 194b

Permissible MOVE operations

Sending Field
Receiving Field
Numeric
Alphabetic
Alphanumeric
Group item
Numeric

* Numeric integer fields can be moved to alphanumeric fields but numeric fields with a V in the PIC clause cannot be moved to alphanumeric fields.

The MOVE CORRESPONDING statement
In the MOVE CORRESPONDING statement, all elementary items within the sending group-item that have the same names as corresponding elementary items in the receiving group-item will be moved. The same-named fields in the receiving group-item need not be in any specific order. Any fields of the sending record, that are not matched by the same-named fields in the receiving record are ignored.

Back to COBOL Index

5. Arithmetic verbs

2010-02-17T16:27:00.000-08:00

All the basic arithmetic operations of ADD, SUBTRACT, MULTIPLY, and DIVIDE require that the fields operated on (1) have numeric PIC clauses and (2) actually have numeric data when the program is executed.
In all cases, the resultant field must be an identifier or data-name, not a literal.

ADD statement
The result, or sum, of an ADD operation is always placed in the last field mentioned. The only field that is altered as a result of the ADD operation is this last field, which is the one directly following the word TO.
When using the TO format in an ADD statement, all the data-names and literals are added together, and the result placed in the last field specified.
When using the GIVING format, all fields and literals preceding the word GIVING are added together and the sum is placed in the field following the word GIVING.

Eg 5.1:
05 EMP-BASIC PIC 9(5) VALUE 4000.
05 EMP-HRA PIC 9(3) VALUE 650.
05 EMP-TOTAL PIC 9(6) VALUE 100.

a. ADD EMP-BASIC TO EMP-TOTAL.

Result :
EMP-TOTAL = 4100

b. ADD EMP-BASIC EMP-HRA GIVING EMP-TOTAL.

Result :
EMP-TOTAL = 4650

SUBTRACT statement
All fields and literals preceding the word FROM will be added together and the sum subtracted from the field following the word FROM. The result, or difference, will be placed in this same field if no GIVING option is used. All other fields will remain unchanged.

Eg 5.2:
05 EMP-GROSS PIC 9(5) VALUE 4250.
05 EMP-PF PIC 9(3) VALUE 250.
05 EMP-ITAX PIC 9(3) VALUE 100.
05 EMP-NET PIC 9(6) VALUE 100.

a. SUBTRACT EMP-PF FROM EMP-BASIC.

Result :
EMP-BASIC = 4000

b. SUBTRACT EMP-PF EMP-ITAX FROM EMP-GROSS.

Result :
EMP-GROSS = 3900

c. SUBTRACT EMP-PF EMP-ITAX FROM EMP-GROSS GIVING EMP-NET.

Result :
EMP-GROSS = 4250
EMP-NET = 3900

MULTIPLY and DIVIDE statements
With each MULTIPLY or DIVIDE statement specified, only two operands can be multiplied or divided. Always make sure the receiving fields is large enough to store the result. The preposition used with the MULTIPLY verb is always BY. In the DIVIDE operation, the preposition is either BY or INTO.

Eg 5.3:
05 EMP-GROSS PIC 9(5) VALUE 4000.
05 EMP-ANN-SAL PIC 9(5) VALUE ZERO.
05 EMP-NEW-SAL PIC 9(5) .
05 EMP-REM PIC 9(3).

a. MULTIPLY 12 BY EMP-GROSS.
Result :
EMP-GROSS = 48000

b. MULTIPLY EMP-GROSS BY 12 GIVING EMP-ANN-SAL.
Result :
EMP-GROSS = 4000
EMP-ANN-SAL=48000

c. DIVIDE 4 INTO EMP-GROSS.
Result :
EMP-GROSS = 1000

d. DIVIDE 4 INTO EMP-GROSS GIVING EMP-NEW-SAL.
Result :
EMP-GROSS = 4000
EMP-NEW-SAL = 1000

e. DIVIDE EMP-GROSS BY 4 GIVING EMP-NEW-SAL.
Result :
EMP-NEW-SAL = 1000

Use of the REMAINDER clause in the DIVIDE operation
When performing a division operation, the result will be placed in the receiving field according to the PIC specifications of that field.

Eg 5.4:
DIVIDE 130 BY 40 GIVING WS-TOTAL.

After the operation is performed, 03 is placed in WS-TOTAL.
It is sometimes useful to store the remainder of a division operation for additional processing. The DIVIDE can be used for this purpose by including a REMAINDER clause.

ROUNDED Option
A frequent need exists for rounding numeric values.

Eg 5.5:
05 AMT1 PIC 99V999 VALUE 12.857.
05 AMT2 PIC 99V999 VALUE 25.142.
05 AMT3 PIC 99V99 VALUE 37.99.

ADD AMT1 AMT2 GIVING AMT3.

In the code given above, the result 37.999 is placed in an accumulator. When this value is move to the field AMT3 , the low-order decimal position is truncated and 37.99 is stored in the field. A more desirable result would be 38.00 since 38 is closer to the sum of 37.999. We consider results more accurate if they are rounded to the nearest decimal position.
To obtain rounded results, the ROUNDED option may be specified with any arithmetic statement. In all case, it directly follows the resultant data-name.

Eg 5.6:
ADD AMT1 AMT2 GIVING AMT3 ROUNDED.

If the ROUNDED option is not specified, truncation of decimal positions will occur if the resultant field cannot accommodate all the decimal positions in the result. With the ROUNDED option, the computer will always round the result to the PICTURE specification of the receiving field.

If ROUNDED and REMAINDER are to be used in the same DIVIDE statement, ROUNDED must appear first.

ON SIZE ERROR
Consider the following :

Eg 5.7:
05 AMT1 PIC 999 VALUE 800.
05 AMT2 PIC 999 VALUE 150.
05 AMT3 PIC 999 VALUE 050.

ADD AMT1 AMT2 TO AMT3.

The effect of the above statement would be the same as coding MOVE 1000 TO AMT3. In this case, the resultant field is not large enough to store the accumulated sum. In other words , an overflow or size error condition has occurred. This will produce erroneous results.

Eg 5.8:
ADD AMT1 AMT2 TO AMT3
ON SIZE ERROR MOVE ZERO TO TOTAL-OUT.

In a divide, the size error condition has additional significance. If an attempt is made to divide by zero, a size error condition will occur. This is because division by zero yields a result of infinity which makes it impossible to define a sufficiently large receiving field.
If the ON SIZE ERROR option is employed along with the ROUNDED option, the word ROUNDED always precedes ON SIZE ERROR.

COMPUTE statement
If complex or extensive arithmetic operations are required in a program, the use of the four arithmetic verbs may prove cumbersome. The COMPUTE verb provides another method of performing arithmetic. The COMPUTE statement uses the following arithmetic symbols :
+ Add
- Subtract
* Multiply
/ Divide
** exponentiation

Eg 5.9:
COMPUTE TOTAL = AMT1 + AMT2 – AMT3.

To round the results in a COMPUTE statement to the specifications of the receiving field, use the ROUNDED option directly following the receiving field. If we need to test for a size error condition we may use the ON SIZE ERROR clause as the last one in the statement.

The sequence in which operations are performed in a COMPUTE statement
**
* or / (whichever appears first from left to right)
+ or - (whichever appears first from left to right)
The use of parentheses overrides rules 1-3. That is, operations with parentheses are performed first.

Back to COBOL Index

6. Decision Making

2010-02-17T16:26:00.000-08:00

A conditional statement is one that performs operations depending on the existence of some condition. In COBOL, such statements generally begin with the word IF and are called IF-THEN-ELSE or selection structures.
An imperative statement , as opposed to a conditional statement, is one that performs an operation regardless of any existing condition.
A condition may test for a specific relation. A simple condition may be a single relational test of the following form :

Eg 6.1:
IF AMT1 IS EQUAL TO AMT2
DIVIDE QTY INTO TOTAL
ELSE
ADD UNIT-PRICE TO FINAL-TOTAL.

The following symbols for simple relational conditions are valid within a COBOL statement :
<> IS GREATER THAN
= IS EQUAL TO

The NEXT SENTENCE or CONTINUE clause
There are times when you might want to execute a series of steps only if a certain condition does not exist. The COBOL expression NEXT SENTENCE will enable you (1) to avoid performing any operation if a condition exists and (2) to execute instructions only if the ELSE condition is met.

Eg 6.2:
IF AMT1 = AMT2
NEXT SENTENCE
ELSE
ADD 1 TO TOTAL.

Compound conditional
The compound conditional offers even greater flexibility for selection and enables the IF statement to be used for more complex problems. The compound conditionals are as follows :

OR
Performs an operation or a series of operations if any one of several conditions exists.

AND
If a statement or statements are to be executed only when all of several conditions are met.

Negating conditionals
NOT
All simple relation, class or sign tests may be coded using a negated conditional (NOT).

Eg 6.3:
IF AMT1 IS NOT EQUAL TO AMT2
PERFORM 200-NOT-EQUAL-RTN.

Hierarchy rules for compound conditionals
1. NOT is evaluated first.
2. Conditions surrounding the word AND are evaluated first.
3. Conditions surrounding the word OR are evaluated last.
4. When there are several AND or OR connectors, the AND conditions are evaluated first, as they appear in the statement, from left to right. Then the OR conditions are evaluated, also from left to right.
5. To override Rules 1-3, use parentheses around conditions you want to be evaluated first.

Sign test
We can test whether a field is POSITIVE, NEGATIVE, or ZERO with a sign test.
If a numeric field contains an amount less than zero, it is considered negative. If it has an amount greater than zero, then it is considered positive.

Eg 6.4:
IF AMT IS POSITIVE
PERFORM 200-CALC-RTN.

Class test
We can test for the type of data (ALPHABETIC or NUMERIC) using the class test.

Eg 6.5:
IF AMT-IN IS NUMERIC
PERFORM 300-CALC-RTN.

Condition names
A condition-name is a user-defined word established in the DATA DIVISION that gives a name to a specific value that an identifier can assume. An 88-level coded in the DATA DIVISION is a condition-name that denotes a possible value for an identifier. A condition-name is always coded on the 88 level and has only a VALUE clause associated with it. Since a condition-name is not the name of a field, it will not contain a PICTURE clause.

Eg 6.6:
05 MARITAL-STATUS PIC X.
88 SINGLE VALUE “S”.

Either of the following tests may be used in the PROCEDURE DIVISION .

Eg 6.6a:
IF MARITAL-STATUS = “S”
PERFORM 1000-SINGLE-ROUTINE.

or

Eg 6.6b:
IF SINGLE
PERFORM 1000-SINGLE-ROUTINE.

Back to COBOL Index

7. Iterations

2010-02-17T16:25:00.000-08:00

PERFORM statement
The simple PERFORM statement, is used to execute a specified routine from one or more points in a program.

The PERFORM statement will :
1. Execute all instructions in the named paragraph.
2. Transfer control to the next instruction in sequence, after the PERFORM.

Eg 7.1:
PROCEDURE DIVISION.
100-MAIN-MODULE.
:
PERFORM 400-HEADING-RTN.
:
200-CALC-RTN.
:
:
400-HEADING-RTN.
:
:

PERFORM..THRU
The PERFORM executes all statement beginning at pargraph-name-1 until the end of paragraph-name-2 is reached. Control is then transferred to the statement directly following the PERFORM.

Eg 7.2:
100-MAIN.
PERFORM 300-PARA THRU 500-PARA.
:
200-PARA.
:
300-PARA.
:
400-PARA.
:
500-PARA.
EXIT.
600-PARA.
:

The EXIT statement
EXIT is a COBOL reserved word that performs no operation. It is used to allow execution to pass over other statements or to transfer control back to the statement following the original PERFORM. It is used, when necessary, as an end point in a paragraph.

PERFORM..UNTIL
Iteration may be performed in COBOL using a PERFORM..UNTIL statement. The contents of the identifiers used in the UNTIL clause should be changed within the paragraph(s) being performed. The condition in a PERFORM .. UNTIL is tested before the named paragraph is executed even once. If the condition indicated in the UNTIL clause is met at the time of execution, then the name paragraph(s) will not be executed.

Procedure used in Looping
Paragraph containing the PERFORM that “Loops”
1. Initialize the field to be tested (e.g., MOVE 0 TO COUNTER1).
2. Code a PERFORM..UNTIL using a separate paragraph. For example, PERFORM UNTIL COUNTER1 = 5.

Loop to be performed
1. Code the steps required in the loop as a separated paragraph.
2. Increase or decrease the value in the field to be tested (e.g., ADD 1 TO COUNTER1).

Eg 7.3:
* This program displays Hello 3 times.
MOVE 1 TO COUNTER1.
PERFORM 200-DISP-RTN UNTIL COUNTER1 = 4.
:
STOP RUN.
200-DISP-RTN.
DISPLAY “HELLO”.
ADD 1 TO COUNTER1.

PERFORM..TIMES
The PERFORM..TIMES construct is used to execute a sequence of steps a fixed number of times. It is not necessary to establish a counter that must be incremented each time through the loop. When using the TIMES format (PERFORM paragraph-name-1 identifier-1 TIMES) : (1) the identifier must be specified in the DATA DIVISION; (2) it must have a numeric PICTURE clause; and (3) it must contain only integers or zeros.

Eg 7.4:
* This program displays the Hello 3 times.
MOVE 3 TO COUNTER1.
PERFORM 200-DISP-RTN COUNTER1 TIMES.
:
STOP RUN.
200-DISP-RTN.
DISPLAY “HELLO”.

GO TO
A GO TO permanently transfers control to another paragraph. It does not return control to the paragraph from where it was issued.

Back to COBOL Index

8. File Handling

2010-02-17T16:24:00.000-08:00

File Organization methods
It is important that file be so organized that efficient processing can be accomplished by matching the file data characteristics, processing method and file organization. Basically, three methods of file organization are available on disk systems: sequential, indexed sequential, and relative file organization.

Sequential file organization
Sequential file organization indicates that the records in the file are positioned in a sequential order, such as according to part number.

Indexed sequential file organization
Indexed sequential file organization is one in which the records are filed sequentially, but a table (index is available which identifies the location of groups of records, thereby reducing access time.

Relative file organization
Relative file organization is such that the logical order and physical order of the records do not necessarily correspond with one another. For such a file, a technique, or rule, is required to determine the location of the record in the disk system.

This chapter shows you how to process sequential files in COBOL.

Any program that (1) reads data from input files or (2) produces output files, requires an INPUT-OUTPUT SECTION and a FILE SECTION to describe the input and output areas.

INPUT-OUTPUT SECTION
The INPUT-OUTPUT SECTION of the ENVIRONMENT DIVISION follows the CONFIGURATION SECTION and supplies information concerning the input and output devices used in the program. In the FILE-CONTROL paragraph, a file-name is selected for each file to be used in the program; in addition, each file-name selected is assigned to a device. The SELECT statement is coded in Area B.

Eg 8.1:
ENVIRONMENT DIVISION.
:
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT EMPLOYEE-FILE
ASSIGN TO “EMP.DAT”
ORGANIZATION IS LINE SEQUENTIAL.

FILE SECTION.
Each file is described in the FILE SECTION with an FD sentence that may consist of a series of clauses. After the clauses are specified, the FD sentence ends with a period. FD is an abbreviation for File Description. Each FD entry will describe a file defined in a SELECT statement in the ENVIRONMENT DIVISION.
The two entries, DATA DIVISION and FILE SECTION, are coded in Area A. FD is also coded in Area A. The file-name, however, is typically coded in Area B.

Eg 8.2:
DATA DIVISION.
FILE SECTION.
FD EMPLOYEE-FILE
LABEL RECORDS ARE STANDARD
RECORD CONTAINS 70 CHARACTERS
BLOCK CONTAINS 10 RECORDS.

Label Records
Label records are usually created as the first and last records of a disk or tape to provide identifying information about the file on disk or tape. Labels are created on output files so that, when the same file is later read as input, the labels may be checked to ensure that the file being accessed is the correct one. Labels are created on output files and checked on input files. The COBOL compiler will supply the routine for writing labels on output files or for checking labels on input file if the entry LABEL RECORDS ARE STANDARD is included.

This LABEL RECORDS clause will result in the following :
For output files, the first record on disk or tape file will be created as a standard 80-position header label identifying the file to the system; similarly, the last record on the disk or tape will be created as a trailer label.
For input files, these labels will be computer-checked to ensure that the file being processed is the correct one.

The clause LABEL RECORDS ARE STANDARD is permitted for disk and tape files only. Devices such as printers do not use label records, since identifying information is unnecessary where data is visible to the human eye. The clause LABEL RECORDS ARE OMITTED is used for such files.

RECORD CONTAINS clause
The RECORD CONTAINS clause indicates the size of each record. For printer files the RECORD CONTAINS clause may include one extra position that is used to control the spacing of the form (e.g., single spacing, double spacing). Thus, for 132 character printers, a record size is sometimes set as 133 characters. In such cases, the first or leftmost position in these 133-position print records is the form control position; it is not actually printed.

BLOCK CONTAINS clause
The BLOCK CONTAINS clause is included in the File Description entry only for files in which disk or tape records have been blocked. Blocking is a technique that increases the speed of input/output operations and makes more effective use of storage space on disk and tape. A group of logical records is included within one block to maximize the efficient use of a disk or tape area. For example, reading in a block of 10 disk records, is more efficient than reading in each disk record separately. Even if blocking is used, the program processes records in the standard way, that is, one logical record at a time.

Record Description entries
A record is a unit of information consisting or related data items within a file. Most often, a file consists of records that all have the same length and format. These are called fixed-length records.
For each file defined, we have one record format.

Eg 8.3:
01 EMPLOYEE-REC.
05 EMP-NAME.
10 EMP-FIRST-NAME PIC X(10).
10 EMP-LAST-NAME PIC X(15).
05 EMP-DEPT PIC X(4).
05 EMP-SALARY PIC 9(5)V99.
05 EMP-DOJ PIC 9(6).

Input/output verbs
There are 4 input/output verbs : OPEN, READ, WRITE, CLOSE.

OPEN statement
Before an input or an output file can be used by the program it must be opened. An OPEN statement, designates files as either input or output. It also accesses the specific devices, and makes the files available for processing. It performs header label routines if label records are STANDARD. The OPEN statement checks the header label to determine if the correct file has been accessed.

Eg 8.4:
OPEN INPUT EMPLOYEE-FILE.
OPEN OUTPUT REPORT-FILE.

The order in which files are opened is not significant. The only restriction is that a file must be opened before it may be read or written; a file must be accessed before it may be processed. Since the OPEN statement accesses the files, it is generally on of the first instructions coded in the PROCEDURE DIVISION.

READ statement
After an input file has been opened, it may be read. A READ statement transmits data from the input device, assigned in the ENVIRONMENT DIVISION, to the input storage area, defined in the FILE SECTION of the DATA DIVISION.
The primary function of the READ statement is to transmit one data record to the input area reserved for that file. That is, each time a READ statement is executed, one record is read into primary storage.
The READ statement has, however, several other functions. Like the OPEN statement, it performs certain checks. It checks the length of each input record to ensure that it corresponds to the length specified in a RECORD CONTAINS clause in the data DIVISION. If a discrepancy exists, an error message prints, and a program interrupt occurs.
The READ statement will also use the BLOCK CONTAINS clause, if specified, to perform a check on the blocking factor.
The AT END clause in the READ statement tests to determine if there is any more input. An AT END clause of the READ statement tells the computer what to do if there is no more data to be read.

Eg 8.5:
READ EMPLOYEE-FILE
AT END
MOVE “YES” TO END-OF-FILE.

WRITE statement
The WRITE instruction takes data in the output area defined in the DATA DIVISION and transmits it to the device specified in the ENVIRONMENT DIVISION.
Note that although files are read, we write records. The record-name appear on the 01 level and is generally subdivided into fields. The record description specifies the format of the output.

Eg 8.6:
WRITE EMPLOYEE-REC.

CLOSE statement
A CLOSE statement is coded at the end of the job after all records have been processed to release these files and deactivate the devices. All files that have been opened at the beginning of the program are closed at the end of a program. The CLOSE statement, like the OPEN, will perform additional functions. When creating disk or tape records, for example, the CLOSE will create trailer labels; it will also rewind a tape.

Eg 8.7:
CLOSE EMPLOYEE-FILE.

COPY statement
A COPY statement is used to bring into a program a series of prewritten COBOL entries that have been stored in a library. Copying entries from a library, rather than coding them, has the following benefits : (1) it could save a programmer a considerable amount of coding and debugging time; (2) it promotes program standardization since all programs that copy entries from a library will be using common data-names and/or procedures; (3) it reduces the time it takes to make modifications and reduces duplication of effort; if a change needs to be made to a data entry, it can be made just once in the library without the need to alter individual programs; and (4) library entries are extensively annotated so that they are meaningful to all users; this annotation results in better-documented programs and systems.
Most often, the COPY statement is used to copy FD and 01 entries that define and describe files and records. In addition, standard modules to be used in the PROCEDURE DIVISION of several programs may also be stored in a library and copied as needed.

Contents of EMP.REC
Eg 8.8a:
01 EMPLOYEE-REC.
05 EMP-NAME.
10 EMP-FIRST-NAME PIC X(10).
10 EMP-LAST-NAME PIC X(15).
05 EMP-DEPT PIC X(4).
05 EMP-SALARY PIC 9(5)V99.
05 EMP-DOJ PIC 9(6).

The DATA DIVISION entry using a COPY statement
Eg 8.8b:
DATA DIVISION.
FILE SECTION.
FD EMPLOYEE-FILE
LABEL RECORDS ARE STANDARD
RECORD CONTAINS 70 CHARACTERS
BLOCK CONTAINS 10 RECORDS.
COPY “EMP.REC”.

A program to create the employee file.

Eg 8.9:
IDENTIFICATION DIVISION.
PROGRAM-ID. FILE-CRT.
* This program creates a sequential EMPLOYEE file.

ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT EMPLOYEE-FILE ASSIGN TO "EMP.DAT"
ORGANIZATION IS LINE SEQUENTIAL.

DATA DIVISION.
FILE SECTION.
FD EMPLOYEE-FILE
LABEL RECORDS STANDARD.
01 EMPLOYEE-REC.
05 EMP-NO PIC 9(4).
05 EMP-NAME.
10 EMP-FIRST-NAME PIC X(10).
10 EMP-LAST-NAME PIC X(15).
05 EMP-DEPT PIC X(4).
05 EMP-SALARY PIC 9(5)V99.
05 EMP-DOJ PIC 9(6).

WORKING-STORAGE SECTION.
01 WS-ANS PIC X(01) VALUE "Y".
88 ANS-NO VALUE "N" "n".

PROCEDURE DIVISION.
0000-MAIN.
OPEN OUTPUT EMPLOYEE-FILE.
PERFORM 1000-ACPT-PARA UNTIL ANS-NO.
CLOSE EMPLOYEE-FILE.
STOP RUN.

1000-ACPT-PARA.
DISPLAY "ENTER YOUR EMP CODE : " WITH NO ADVANCING.
ACCEPT EMP-NO.
DISPLAY "ENTER YOUR FIRST NAME : " WITH NO ADVANCING.
ACCEPT EMP-FIRST-NAME.
DISPLAY "ENTER YOUR LAST NAME : " WITH NO ADVANCING.
ACCEPT EMP-LAST-NAME.
DISPLAY "ENTER YOUR DEPARTMENT : " WITH NO ADVANCING.
ACCEPT EMP-DEPT.
DISPLAY "ENTER YOUR SALARY : " WITH NO ADVANCING.
ACCEPT EMP-SALARY.
DISPLAY "ENTER YOUR DATE OF JOINING : " WITH NO ADVANCING.
ACCEPT EMP-DOJ.
WRITE EMPLOYEE-REC.
DISPLAY "DO YOU WANT TO ADD MORE RECORDS : "
WITH NO ADVANCING.
ACCEPT WS-ANS.

Back to COBOL Index

9. Sorting and merging files

2010-02-17T16:22:00.002-08:00

Sorting
Records in files frequently must be sorted into specific sequences for updating, answering inquiries, or generating reports. Sorting is a common procedure used for arranging records into a specific order so that sequential processing can be performed.
COBOL has a SORT verb, which can make it very useful as part of a COBOL program.
The programmer must specify whether the key field is to be an ASCENDING KEY or a DESCENDING KEY, depending on which sequence is required :
ASCENDING : From lowest to highest
DESCENDING : From highest to lowest
The SORT verb may be used to sequence records with more than one key field. For example, to sort an employee file so that it is in alphabetic sequence by name within each department.

Eg 9.1:
SORT SORT-FILE
ON ASCENDING KEY S-EMP-DEPT
ON ASCENDING KEY S-EMP-NAME
USING EMPLOYEE-FILE
GIVING SORT-EMPLOYEE-FILE.

There are three major files used in a sort :
Input file : File of unsorted input records.
Work or sort file : File used to store records temporarily during the sorting process.
Output file: File of sorted output records.

All these files would be defined in the ENVIRONMENT DIVISION using standard ASSIGN clauses, which are system dependent. The SORT-FILE is actually assigned to a temporary work area that is used during processing but not saved. Only the unsorted disk file and the sorted output disk file are assigned standard file-names so that they can be permanently stored.
FDs are used in the DATA DIVISION to define and describe the input and output files in the usual way. The sort or work file is described with an SD (sort file description) entry. The only difference between SD and FD entries is that an SD must not have a LABEL RECORDS clause. Note, too, that the field(s) specified as the KEY field(s) for sorting purposes must be defined as part of the sort record format.

Eg 9.2:
ENVIRONMENT DIVISION.
:
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT SORT-FILE
ASSIGN TO DISK.
:
DATA DIVISION.
FILE SECTION.
SD SORT-FILE.
01 SORT-REC.
05 S-EMP-NAME.
10 S-EMP-FIRST-NAME PIC X(10).
10 S-EMP-LAST-NAME PIC X(15).
05 S-EMP-DEPT PIC X(4).
05 FILLER PIC 9(13).

The SORT statement can, however, be used in conjunction with procedures that process records just before they are sorted and/or process records after they are sorted.

INPUT PROCEDURE
The INPUT PROCEDURE processes data from the incoming file prior to sorting. An INPUT PROCEDURE may be used to perform the following operations prior to sorting : (1) validate data in the input records, (2) eliminate records with blank fields, (3) count input records.

With COBOL 74, the procedure-name of an INPUT PROCEDURE must be a section-name and not a paragraph-name. A section is a series of PROCEDURE DIVISION paragraphs that is treated as a single entry or unit. Rule for forming section-names are the same as rules for forming paragraph-names. The word SECTION, however, follows a section-name (e.g., A000-ERROR SECTION). The end of a section is recognized when another section-name is encountered, or when the end of the program is reached.

Code for an INPUT PROCEDURE
Eg 9.3:
SORT SORT-FILE
ON ASCENDING KEY S-EMP-DEPT
ON ASCENDING KEY S-EMP-NAME
INPUT PROCEDURE A000-TEST-IT
GIVING SORT-EMPLOYEE-FILE.
STOP RUN
A000-TEST-IT SECTION.
A100-PARA-1.
OPEN INPUT IN-FILE.
READ IN-FILE
AT END MOVE “NO” TO ARE-THERE-MORE RECORDS.
PERFORM A200-TEST-RTN
UNTIL THERE-ARE-NO-MORE-RECORDS.
CLOSE IN-FILE.
GO TO A300-TEST-IT-EXIT.
A200-TEST-RTN.
IF QTY = ZEROS
NEXT SENTENCE
ELSE
MOVE IN-REC TO SORT-REC
RELEASE SORT-REC.
READ IN-FILE
AT END MOVE “NO” TO ARE-THERE-MORE RECORDS.
A300-TEST-IT-EXIT.
EXIT.

Explanation
The first section in the PROCEDURE DIVISION contains the SORT instruction, any processing to be performed before or after the SORT verb is executed, and a STOP RUN.
The second section begins with the main module of the INPUT PROCEDURE. It opens the input file, reads the first record, and then performs a process routine (in a separate paragraph within this second section) until there is no more data.
After the separate paragraph is executed until ARE-THER-MORE-RECORDS = “NO”, control returns to the main module of the second section to be terminated, control must pass to the last statement within the section. This means that a GO TO is required. We code GO TO A300-TEST-IT-EXIT as the last sentence. Since no operations are required in this last paragraph, EXIT is coded, which passes control back to the SORT statement, where the file is then sorted.

OUTPUT PROCEDURE
The OUTPUT PROCEDURE is used to process the sorted records prior to, or perhaps even instead of, placing them in the output file. The OUTPUT PROCEDURE can be used instead of the GIVING option. The OUTPUT PROCEDURE is similar to the INPUT PROCEDURE. When the INPUT PROCEDURE is complete, the file is then sorted. An OUTPUT PROCEDURE processes all sorted records in the sort file and handles the transfer of these records to the output file.
In an INPUT PROCEDURE we RELEASE records to a sort file rather than writing them. In an INPUT PROCEDURE we RETURN records from the sort file rather than reading them.

Merging
The MERGE statement combines two or more files into a single file. Its format is similar to the SORT. The file to be merged is a work file designated as an SD. At least two file-names must be included for a merge, but more than two are permitted. Unlike, the SORT, however, an INPUT PROCEDURE may not be specified with the MERGE statement. That is, using the MERGE statement, you may only process records after they have been merged, not before. The OUTPUT PROCEDURE has the same format as with the SORT.

Eg 9.4:
MERGE MERGE-FILE
ON ASCENDING KEY M-EMP-DEPT
USING OLD-PAYROLL
NEW-PAYROLL
GIVING EMPLOYEE-FILE.

Back to COBOL Index

10. Trapping Runtime errors

2010-02-17T16:22:00.001-08:00

The FILE clause
The clause can be used with the SELECT statement to determine the exact type of input or output error that has occurred when either reading from or writing to a file. The SELECT statement could include FILE STATUS as its last clause. The data name specified with the FILE STATUS clause must appear in the WORKING-STORAGE as a two-position alphanumeric field.

Eg 10.1:
SELECT EMPLOYEE-FILE
ASSIGN TO “EMP.DAT”
ORGANIZATION IS LINE SEQUENTIAL
FILE STATUS IS WS-STATUS.
:
WORKING-STORAGE SECTION.
01 WS-STATUS PIC X(2).

The possible values that may be placed in the FILE STATUS field when an input or output operation is performed are listed in Appendix – E.

OPEN INPUT EMPLOYEE-FILE.
IF WS-STATUS NOT = “00”
DISPLAY “ERROR OPENING EMPLOYEE FILE”
STOP RUN.
READ EMPLOYEE-FILE ….
:
:

Back to COBOL Index

11. CONTROL BREAK PROCESSING

2010-02-17T16:20:00.000-08:00

What is a control break procedure ?
A control break procedure is used if records are in sequence by a control field and the number of records in each control field is variable.

Steps for a Control Break
1. Read the initial record.
Move the control field to a hold area in WORKING-AREA.
As long as the control field is equal to the hold area, execute the detail routine for the input record. This means : Add the appropriate amount to a control total, print the detail record and read the next record.
If the control field is not equal to the hold area :
Print the control total.
Initialize the control total field to zero.
Reinitialize the hold field with the new control field value if there are more records.
Process the detail record as in step 3.
Print headings on a new page if each control total is to appear on a separate page.
If required, after all records have been processed perform a control break to print the last control group.

Back to COBOL Index

12. Indexed Files

2010-02-17T16:17:00.000-08:00

An indexed file is really two files – the data file, which is created in sequence but can be accessed randomly, and the index file, which contains the value of each key field and the disk address of the record with that corresponding key field. To access an indexed record randomly, the key field is looked up in the index file to find the disk address of the record; then the record is accessed in the indexed data file directly.

The index on a disk is similar to a book’s index, which has unique subjects (keys) and their corresponding page numbers (addresses). There would be two ways to find a topic in the book. You can read the book sequentially, from the beginning, until that topic is found, but this would be very time consuming and inefficient. The best method would be to look up the topic in the index, find the corresponding page number, and go directly to that page. This is precisely how records can be accessed on a disk file that has an index.

With an indexed file, records can be accessed either sequentially or randomly, depending on the user’s needs. The term random access implies that records are to be processed or accessed in some order other than the one in which they were physically written on the disk.

Creating an Indexed File
Indexed files are created in sequence; that is, reading each record from an input file, in sequence by the key field, creates the indexed file and writing the output indexed disk records in the same sequence. Note, however, once the indexed file is created, it can be accessed randomly.

The ORGANIZATION clause
The clause ORGANIZATION IS INDEXED indicates that the file is to be created with an index.

The ACCESS clause
Since indexed files may be accessed either sequentially or randomly, the ACCESS clause is used to denote which method will be used in the specific program. If the ACCESS clause is omitted, the compiler will assume that the file is being processed in SEQUENTIAL mode.

The RECORD KEY clause
The RECORD KEY clause names the key field within the disk record that will be used to form the index. This field must be in the same physical location in each index record. Usually, it is the first field. It must have a unique value for each record.

Eg 12.1:
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT IND-EMP-FILE
ASSIGN TO “INDEMP.DAT”
ORGANIZATION IS INDEXED
ACCESS IS SEQUENTIAL
RECORD KEY IS I-EMP-NO.
DATA DIVISION.
FILE SECTION.
FD IND-EMP-FILE
LABEL RECORDS STANDARD.
01 IND-EMP-REC.
05 I-EMP-NO PIC 9(4).
05 I-EMP-NAME PIC X(25).
05 I-EMP-DEPT PIC X(4).
05 I-EMP-SAL PIC 9(5)V99.

The INVALID KEY clause
With WRITE
The INVALID KEY clause is used with a WRITE instruction to test for two possible errors: (1) a key field that is not in sequence or (2) a key field that is the same as one already on the indexed file. If any of these conditions exist, we call this an INVALID KEY condition. The computer checks for an INVALID KEY prior to writing the record.
Thus, if you use an INVALID KEY clause with the WRITE statement and a record has an erroneous key, the record is not written and the statement(s) following INVALID KEY would be executed.

Eg 12.2:
WRITE IND-EMP-REC
INVALID KEY
PERFORM 2000-ERROR-PARA.

With READ
When reading a disk file randomly, we do not test for an AT END condition because we are not reading the file in sequence; instead, we include an INVALID KEY test. If there is no record in the INDEXED-FILE with a RECORD KEY equal to T-EMP-NO, the INVALID KEY clause will be executed.

Eg 12.3:
DISPLAY “ENTER EMPLOYEE CODE :”
ACCEPT T-EMP-EMP-NO.
MOVE T-EMP-NO TO I-EMP-NO.
READ IND-EMP-FILE
INVALID KEY
PERFORM 600-ERR-RTN.

DELETE verb
The DELETE verb can be used to delete records from indexed files. Note that we use the file-name with the DELETE verb, but the word RECORD can be specified as well. That is, both the statements DELETE INDEXED-FILE and DELETE INDEXED-FILE RECORD can be used to delete the record in the INDEXED-FILE storage area.
To delete a record from an indexed file, you should first read the record into storage and then instruct the computer to delete it.

Eg 12.4:
MOVE “Y” TO WS-FOUND.
MOVE 1001 TO I-EMP-NO.
READ IND-EMP-FILE
INVALID KEY
MOVE “N” TO WS-FOUND.
IF WS-FOUND = “Y”
DELETE IND-EMP-FILE
INVALID KEY
DISPLAY “ERROR DELETING RECORD”.

Using ALTERNATE RECORD KEYs
Indexed files may be created with, and accessed by, more than one identifying key field. That is, we may want to access employee records using the name as the key field. To enable a file to be accessed randomly using more than one key field, we would need to establish an ALTERNATE RECORD KEY.
To establish multiple key fields for indexing, we use an ALTERNATE RECORD KEY clause in the SELECT statement.

Note:
1. More than one ALTERNATE record key can be used.
2. WITH DUPLICATES means than an ALTERNATE RECORD KEY need not be unique. Thus, fields like EMP-DEPT can be used as a key even though numerous records may have the same department no.
3. A record can be accessed by its RECORD KEY or any of its ALTERNATE RECORD KEYs.

Eg 12.5:
SELECT IND-EMP-FILE
ASSIGN TO “INDEMP.DAT”
ORGANIZATION IS INDEXED
ACCESS IS SEQUENTIAL
RECORD KEY IS I-EMP-NO
ALTERNATE RECORD KEY IS I-EMP-DEPT WITH DUPLICATES.

Accessing records randomly by alternate record key
The program that accesses the file by key field has the same SELECT clause except that ACCESS IS RANDOM rather than SEQUENTIAL. In the PROCEDURE DIVISION , we can access records by either I-EMP-NO , the record key, or I-EMP-DEPT, the alternate key.
The KEY clause is used with the READ statement when an indexed file has ALTERNATE RECORD KEYs that we want to use to randomly access a record. If the KEY clause is omitted when accessing a file randomly, the RECORD KEY is assumed to be the KEY used for finding the record.
Suppose ALTERNATE RECORD KEY WITH DUPLICATES was specified in the ENVIRONMENT DIVISION and there is more than one record with the same ALTERNATE RECORD KEY. The first one that was actually placed on the disk will be the one retrieved by the READ.

The START statement
The START statement enables a program to begin processing an indexed file sequentially but at a record location other than the first or next physical record in the file. The access of the file is to be in sequence (ACCESS IS SEQUENTIAL) if we use the RECORD KEY for finding a record, even though we want to start the access at some point other than the beginning. The ACCESS IS DYNAMIC clause is used if we want to begin the processing an indexed file based on the contents of the ALTERNATE RECORD KEY.
When the record to be accessed has a key equal to the one placed in the RECORD KEY, the KEY clause in the START statement is not required. The INVALID clause is executed only if no such record is found.
Note that the START locates the desired record but it does not READ it into storage. The record must always be brought into storage with a READ statement.

Eg 12.6:
MOVE “Y” TO WS-FOUND.
MOVE 1001 TO I-EMP-NO.
START IND-EMP-FILE
KEY > I-EMP-NO
INVALID KEY DISPLAY “THERE IS NO EMP NO > 1001”
MOVE “N” TO WS-FOUND.
IF WS-FOUND = “Y”
READ IND-EMP-FILE
AT END
MOVE “Y” TO WS-EOF.

Suppose we wish to begin processing with an I-EMP-NO greater than 006. We must include a KEY clause with the START because we wish to position the file at allocation greater than the value of a RECORD KEY. The KEY clause can be omitted only if the record to be located has a RECORD KEY equal to the one stored.

The ACCESS IS DYNAMIC clause
Sometimes we wish to access an indexed file both randomly and sequentially in a single program. For this, we say that ACCESS IS DYNAMIC.
In addition to using ACCESS IS DYNAMIC for combining sequential and random access techniques in a single program, we can use this clause to access records by ALTERNATE RECORD KEY. Also, when records are to be accessed by both RECORD KEY and ALTERNATE RECORD KEY, use ACCESS IS DYNAMIC.

Rules for using the START statement
The file must be accessed with (a) ACCESS IS SEQUENTIAL for reading records in sequence by the RECORD KEY or (b) ACCESS IS DYNAMIC for reading records in sequence by an ALTERNATE RECORD KEY.
The file must be opened as either input or I-O.
If the KEY phrase is omitted, the relational operator “IS EQUAL TO” is implied and the primary record key is assumed to be the key of reference.
We use KEY =, >, NOT <>, NOT <>, NOT

Back to COBOL Index

13. Table Handling

2010-02-17T16:16:00.000-08:00

Use of OCCURS clause
An OCCURS clause is used in COBOL to indicate the repeated occurrence of fields with the same format.
Defining a series of totals in WORKING-STORAGE to which amounts are added; after all data is accumulated, the total can be printed.
Defining a table in WORKING-STORAGE to be accessed by each input record. For example, using the contents of some input field to “look up” the required data in the table.

Eg 13.1:
01 TEMP-REC.
05 TEMPERATURE OCCURS 24 TIMES PIC S9(3).

Subscript
A subscript is used in the PROCEDURE DIVISION to indicate which specific item within the array we wish to access.
The subscript is used along with the identifier that is defined with an OCCURS, to refer to an item within an array.

Eg 13.2:
MOVE TEMPERATURE (2) TO TEMP-OUT.

Rules for OCCURS and subscripts
There must be at least one space between the identifier and the left parenthesis that precedes the subscript. Similarly, the subscript must be enclosed in parentheses with no spaces within the parentheses.
A subscript may be a numeric literal or a data-name with a numeric PICTURE clause.
An OCCURS clause may be used on levels 02-49 only, because 01 level is used for defining records not fields.
COBOL 74 permits only upto three levels of OCCURS clauses

Using OCCURS with VALUE and REDEFINES clauses
Sometimes we want to initialize elements in a table or an array with specific values.
With COBOL 74, we cannot use a VALUE clause with an entry defined by an OCCURS clause. Instead we can define the field with one value and then redefine that storage area into separate array elements. As a result, each array element will have a different value.

Eg 13.3:
01 MONTH-NAMES.
05 STRING-1 PIC X(36) VALUE
‘JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC’.
05 MONTH REDEFINES STRING-1 OCCURS 12 TIMES PIC XXX.

The SEARCH statement
The best method for searching a table is with the use of a SEARCH statement. The identifier used with the SEARCH verb is the table entry name specified on the OCCURS level, not on the 01 level. The WHEN clause indicates what action is to be taken when the condition specified is actually met. Additional comparisons between search and table arguments can be made using other WHEN clauses. The AT END clause specifies what should be done if the table has been completely searched and no match is found.
To use a SEARCH statement, two additional entries are required : the INDEXED BY clause along with OCCURS, and the SET statement in the PROCEDURE DIVISION.
Table entries must be specified with an index rather than a subscript. An index is similar to a subscript, but it is defined along with the table entries as part of the OCCURS description.

Eg 13.4:
01 SALES-TAX-TABLE,
05 TABLE-ENTRIES OCCURS 1000 TIMES INDEXED BY X1.
10 WS-ZIPCODE PIC 9(5).
10 WS-TAX-RATE PIC V999.

However, unlike a subscript, an index is not defined separately in WORKING-STORAGE. The compiler automatically provides an appropriate PICTURE clause. An index is processed more efficiently than a subscript, because the index contains the displacement from the start of the table.
A SEARCH statement does not automatically initialize the index at 1 because sometimes we may want to begin searching a table at some point other than the beginning. Initializing an index at 1 must be performed by a SET statement prior to the SEARCH.

Eg 13.5:
SET X1 TO 1.
SEARCH TABLE-ENTRIES
AT END MOVE 0 TO WS-SALES-TAX
WHEN ZIP-IN = WS-ZIPCODE (X1)
COMPUTE ........

An index can be used to reference an element only in the table or array for which it was defined.
With 2 WHEN clauses, the computer begins by performing the first comparison. Only if the condition in the first WHEN is not met does it test the second WHEN.
To search for multiple matches in a table, it is better to use a PERFORM rather than a SEARCH statement for processing the entire table.
If you have parallel table with CUST-NO-TABLE storing 25 customer numbers and CUST-ARRAY storing the corresponding BAL-DUE for each. In such a case the SEARCH... VARYING can be used.

Eg 13.6:
SET X1, X2 TO 1.
SEARCH EACH-CUST-NO VARYING X2
AT END PERFORM 300-ERR-RTN
WHEN CUST-NO-IN = EACH-CUST-NO (X1)
ADD AMT-IN TO BAL-DUE (X2).

Binary search
When table entries are arranged in sequence by some field, such as T-CUSTOMER-NO, the most efficient type of look-up is a binary search. The SEARCH ALL verb is used to perform a binary search. A SET statement is not necessary with the SEARCH ALL, since the computer sets the index to the appropriate point initially when each binary search begins.

Limitations of the SEARCH ALL
The condition following the word WHEN can test only for equality.
If the condition following the word WHEN is a compound conditional :
Each part of the conditional can only consist of a relational test that involves an equal condition.
The only compound condition permitted is with ANDs, not Ors.
Only one WHEN clause can be used with a SEARCH ALL.
The VARYING option may not be used with the SEARCH ALL.
The OCCURS item and its index, which define the table argument, must appear to the left of the equal sign.

Eg 13.7:
WHEN S-AMT (X1) = AMT1 .....

To use the SEARCH ALL statement, we must indicate which table entry will serve as the
field. The identifier used in the ASCENDING KEY clause must be an entry within the table and it must appear before the INDEXED BY clause.

Eg 13.8:
01 TABLE-1.
05 DISCOUNT-TABLE OCCURS 50 TIMES
ASCENDING KEY T-CUSTOMER-NO
INDEXED BY X1.
10 T-CUSTOMER-NO PIC 9(4).
10 T-DISCOUNT-PCT PIC V999.

Eg 13.9:
01 INVENTORY-TABLE.
05 WAREHOUSE OCCURS 50 TIMES INDEXED BY X1.
10 ITEM-X OCCURS 100 TIMES INDEXED BY X2.
15 PART-NO PIC 9(4).
15 UNIT-PRICE PIC 999V99.

The identifier used with the SEARCH refers to the lowest-level OCCURS entry.
e.g. SEARCH ITEM-X.
Note that SEARCH ITEM-X increments the lowest-level index only. Hence if X1 is set to 1 initially, the SEARCH will perform a look-up on items in warehouse 1 only, that is (1,1) to (1,100).
To search all warehouses, the major index X1 must be incremented.

Back to COBOL Index

14. Call statement

2010-02-17T16:15:00.001-08:00

Structured programs should consist of a series of independent modules that are executed from the main module.
When programs are properly structured :
1. Each module may be written, compiled, and perhaps even tested independently.
2. The modules may be written in different stages, in atop-down manner. They may even be coded by different programmers.
3. If a specific module needs to be modified, the entire logical flow should still function properly without the need for extensive revision to other parts of the program.

Modules within a program can be viewed as subroutines that are called or executed from the main module. But a program may also CALL or reference independent subprograms stored in a library that are entirely separate from the main program itself. The main program that references or calls a subprogram is referred to as the calling program. The subprogram that is linked and executed within the main program is referred to as the called program.
The called program would need to be compiled so that it may be called when needed.
When the CALL is performed, data is passed from the calling to the called program (if the calling program has assigned values to fields used in the called program). The entire called program is executed, data is passed from the called program back to the calling program, and control return to the calling program.

Called Program Requirements
PROGRAM-ID.
The literal used in the CALL statement of the main program to extract a subprogram or routine from a library and execute it must be identical to the called program’s PROGRAM-ID. Note that the literal is enclosed in quotation marks when used in the CALL statement.

LINKAGE SECTION
A LINKAGE SECTION must be defined in the called program for identifying those items that (1) will be passed to the called program from the calling program and (2) passed back from the called program to the calling program. The LINKAGE SECTION of the called program, then, describes all items to be passed between the two programs.
The LINKAGE SECTION, if used, is coded after the FILE and WORKING-STORAGE SECTIONs of the called program. This section is similar to WORKING-STORAGE except that VALUE clauses from initializing fields are not permitted in the LINKAGE SECTION.

EXIT PROGRAM
The last executed statement in the called program must be the EXIT PROGRAM. It signals the computer to return control back to the calling program. With COBOL 74, EXIT PROGRAM must be the only statement in the last paragraph.

Calling Program Requirements
PROCEDURE DIVISION USING
The identifiers specified in the USING clause in the PROCEDURE DIVISION entry include all fields defined in the LINKAGE SECTION; these identifiers will be passed from one program to the other. They are passed to and from corresponding identifiers in the CALL … USING of the main program.
The USING clause of the CALL statement is required if the subprogram performs any operations in which data is to be passed from one program to another. The CALL … USING identifies fields in the main or calling program that will be either passed to the called program before it is executed, or passed back to the calling program after the called program has been executed.

Sample Program

Calling Program : MAIN.CBL
Eg 14.1a:
IDENTIFICATION DIVISION.
PROGRAM-ID. MAIN.
ENVIRONMENT DIVISION.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 MY-NAME PIC X(20).
PROCEDURE DIVISION.
MAIN.
DISPLAY "ENTER NAME ".
ACCEPT MY-NAME.
CALL "DISP" USING MY-NAME.
STOP RUN.

Called Program : DISP.CBL
Eg 14.1b:
IDENTIFICATION DIVISION.
PROGRAM-ID. DISP.
ENVIRONMENT DIVISION.
DATA DIVISION.
LINKAGE SECTION.
01 NM PIC X(20).
PROCEDURE DIVISION USING NM.
MAIN.
DISPLAY "HELLO " NM.
EXIT PROGRAM.

Back to COBOL Index

15. String Handling

2010-02-17T16:12:00.000-08:00

The STRING Statement
A STRING statement may be used to combine several fields to form once concise field. This process is called concatenation.

05 NAME.
10 LAST-NAME PIC X(10) VALUE “EDISON”.
10 FIRST-NAME PIC X(10) VALUE “THOMAS”.
10 MIDDLE-NAME PIC X(10) VALUE “ALVA”.
01 NAME-OUT PIC X(33).

STRING
FIRST-NAME DELIMITED BY ‘ ‘
‘ ‘ DELIMITED BY SIZE
MIDDLE-NAME DELIMITED BY ‘ ‘
‘ ‘ DELIMITED BY SIZE
LAST-NAME DELIMITED BY ‘ ‘
‘ ‘ DELIMITED BY SIZE
INTO NAME-OUT.

Output

NAME-OUT = THOMAS ALVA EDISON

OVERFLOW Option
The OVERFLOW option specifies the operation(s) to be performed if the receiving field is not large enough to accommodate the result.

POINTER Option
We may count the number of characters actually moved to the receiving field if it is initialized at zero.

01 WS-COUNT PIC 99 VALUE 0.

MOVE 1 TO WS-COUNT.
STRING FIRST-NAME DELIMITED BY ‘ ‘
INTO NAME-OUT
WITH POINTER WS-COUNT.

Output

WS-COUNT = 6

Rules for using the STRING statement
1. The DELIMITED BY clause is required. It can indicate :
SIZE : The entire sending field is transmitted.
Literal : The transfer of data is terminated when the specified literal is encountered; the literal itself is not moved.
Identifier : The transfer of data is terminated when the contents of the identifier is encountered.
2. The receiving field must be an elementary data item with no editing symbols or JUSTIFIED RIGHT clause.
3. All literals must be described as non-numeric.
4. The identifier specified with the POINTER clause must be an elementary numeric item.
5. The STRING statement move data from left to right just like alphanumeric fields are moved, but a STRING does not pad data from left to right just like alphanumeric fields are moved, but a STRING does not pad with low-order blanks, unlike an alphanumeric MOVE.

The UNSTRING statement
The UNSTRING statement may be used to convert keyed data to a more compact form for storing it on disk. For example, we can instruct the computer to separate the NAME-OUT into its components and store them without the commas.

MOVE “THOMAS,ALVA,EDISON” TO NAME-OUT.
UNSTRING NAME-OUT
DELIMITED BY ‘,’
INTO FIRST-NAME
MIDDLE-NAME
LAST-NAME.

Output

FIRST-NAME = THOMAS
MIDDLE-NAME = ALVA
LAST-NAME = EDISON

Rules for using the UNSTRING statement
1. The sending field must be non-numeric. The receiving fields may be numeric or non-numeric.
2. Each literal must be non-numeric.
3. The [WITH POINTER identifier] and [ON OVERFLOW imperative-statement] clauses may be used in the same way as with the STRING.

The INSPECT statement
The INSPECT statement may be used for replacing a specific character in a field with another character. It can also be used for counting the number of occurrences of a given character.

01 CTR-1 PIC 9 VALUE 0.
01 WS-NAME PIC X(10).

ACCEPT WS-NAME.
INSPECT WS-NAME TALLYING CTR-1 FOR ALL SPACES.

This code will check for the number of spaces in the field WS-NAME and store the value in the field CTR-1.

Applications of the INSPECT statement
1. To count the number of occurrences of a given character in a field.
2. To replace specific occurrences of a given character with another character.

Back to COBOL Index

1. INTRODUCTION TO VSAM

2009-05-27T09:31:00.000-07:00

VSAM stands for Virtual Storage Access Method, is IBM high performance access method which allows you to access files of different organization such as sequential, indexed, relative record and linear datasets.Features of VSAM
VSAM is one coherent file storage system used to store and retrieve data. It is not a database management system like IDMS or DB2. It does not provide for relationships among the data. The existing databases like IMS or DB2 may be implemented using VSAM.
VSAM is not a programming language. But you can access VSAM dataset through programming languages like COBOL or PL/I. It is not a communication system like VTAM or CICS. It has no equivalent for a ‘PDS’ type of file organization.Advantages of VSAM
Provides protection of Data against unauthorized access through password facility.
Cross-system (MVS & VSE) Cmpatibility. VSAM datasets can be imported and imported in MVS and VSE systems.
Device Independence (Access Via Catalog). The application programmer need not be concerned with Block size ,volume and other control information, as access to VSAM dataset it always through the Catalog and all control information are stored in the catalog entry of the dataset.
IDCAMS commands can be included in JCL to handle VSAM datasetsTypes of VSAM DatasetsClusters
VSAM files are often called clusters. A cluster is the set of catalog entries that represent a file. A cluster consists of one or two components. All VSAM datasets consist of a data component in which data records are placed . For KSDS , there is an additional index component, which contains the indexes used to access records in the data component. ESDS RRDS and LDS have data component only and no index component
VSAM clusters are categorized into 4 types based on the way we store and access the records:
ESDS Entry Sequenced dataset.
These are sequential datasets that can be read in the sequence in which they were created. Records can be added only to the end of the dataset.
KSDS Key Sequenced dataset.
These datasets are stored in sequence of some key field in the record. The data component and index component are separated. The keys are stored in a separate index and records are accessed through the index. Individual records can be accessed randomly on the basis of the record key. Locating the record is a two stage process.
• First search for the key in the index• Use the information in the index to locate the record.
RRDS Relative record dataset.
These datasets associate a number to each record. There is no key field but records are accessed by deriving the relative position of the record in the dataset.
LDS Linear dataset. These datasets consist of a stream of bytes which are accessed and written as 4k blocks accessed by Relative Byte Address
VSAM history
VSAM was introducted in 1973. This version had only Entry Sequence Datasets and Key Sequenced Datasets. In 1975 Relative Record Datasets and alternate indexes for KSDS was added. In 1979 DF/EF VSAM was introduced with Integrated Catalog Facility (ICF).
DFP/VSAM Ver 1 was introduced in 1987 to run under the MVS/XA architecture. DFP/VSAM version 2 introduced Linear Datasets (LDS)
DFP/VSAM version 3 was introduced to run under MVS/ESA architecture.In 1991 version 3.3 supported variable-length records for RRDS.

Back to VSAM index

2. VSAM Catalogs

2009-05-27T09:29:00.001-07:00

VSAM is totally catalog-driven. Catalogs are special purpose files residing on DASD (Direct Access Storage Device) serving as a central repository for information about all datasets under its control. There are two types of catalogs used • Master catalog • User catalog There’s only one Master catalog per system. The entries in the master catalog may point to VSAM or non-VSAM dataset, user catalogs, system datasets or other objects. User catalogs contain same type of information as master catalog. All user catalogs must be cataloged into master catalog. Access to a dataset can only be made through a master or user catalog. Therefore all VSAM datasets have to be cataloged. Non-VSAM datasets can also be cataloged. Catalogs are protected by RACF. Figure 2.1 VSAM Catalog Vsam catalog Catalogs maintain the following information • Name and physical location of datasets • password information required to access protected datasets • Statistics about datasets Example No. of records added, read, deleted or no. of Control Interval/Control Area splits • Information about dataset itself Example ESDS, KSDS, RRDS, CSIZE, KEYLENGTH • Location of catalog recovery area Vsam records VSAM records can be fixed or variable length. Records can also be spanned Vsam space allocation VSAM space allocation depends on whether the dataset is cataloged in an ICF or the older VSAM type catalog. For VSAM datasets cataloged in the newer ICF-type catalogs, dedicated space is allocated dynamically when the cluster is created with the DEFINE CLUSTER command Each VSAM dataset cataloged in an ICF catalog has its own VTOC entry. These VSAM datasets can have 1 primary and 122 secondary allocation unlike OS dataset which can have only 1 primary and 15 secondary extends on a volume. Vsam space management VSAM maintains detailed information in its catalogs about DASD space allocated to VSAM files. This allocation information stored in the catalog is more comprehensive and flexible than the equivalent information stored for a non-VSAM file in VTOC. Sub Allocation Once the space has been allocated, VSAM has complete control over subsequent allocations within that space. Within that space, VSAM can create suballocated files. Whenever a suballocated files need to be created, extended or deleted, VSAM uses it own space management facilities. Unique Allocation Alternatively an entire VSAM space can be allocated to single VSAM file. In that case allocation for the file called UNIQUE file, is managed by DADSM rather than by VSAM. Allocation information for the unique files is maintained in two places : the VSAM catalog entry for the file and the VTOC entry for the space that contains unique file. The figure below shows two DASD volumes. The first volume has a VSAM dataspace contains two sub-allocated files. Notice that there’s unused space within the dataspace too. However, that space is not available to non-VSAM files because it’s already under VSAM’s control. The second DASD volume contains two unique VSAM datasets. All of the unused space on the volume is available to both VSAM and Non-VSAM datasets. Under VSE/VSAM & OS/VS VSAM most VSAM datasets are sub-allocated. Under ICF, there is no VSAM space. All VSAM files are Unique Figure 2.2 Space Allocation

Back to VSAM index