COBOL - Environment Setup

We have set up the COBOL Programming environment onpne, so that you can compile and execute all the available examples onpne. It gives you confidence in what you are reading and enables you to verify the programs with different options. Feel free to modify any example and execute it onpne.

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

PROCEDURE DIVISION.
   DISPLAY  Hello World .
STOP RUN.

For most of the examples given in this tutorial, you will find a Try it option in our website code sections at the top right corner that will take you to the onpne compiler. So just make use of it and enjoy your learning.

Instalpng COBOL on Windows/Linux

There are many Free Mainframe Emulators available for Windows which can be used to write and learn simple COBOL programs.

One such emulator is Hercules, which can be easily installed on Windows by following a few simple steps as given below −

Download and install the Hercules emulator, which is available from the Hercules home site: www.hercules-390.eu

Once you have installed the package on Windows machine, it will create a folder pke C:/hercules/mvs/cobol.

Run the Command Prompt (CMD) and reach the directory C:/hercules/mvs/cobol on CMD.

The complete guide on various commands to write and execute a JCL and COBOL programs can be found at:

www.jaymoseley.com/hercules/installmvs/instmvs2.htm

Hercules is an open-source software implementation of the mainframe System/370 and ESA/390 architectures, in addition to the latest 64-bit z/Architecture. Hercules runs under Linux, Windows, Solaris, FreeBSD, and Mac OS X.

A user can connect to a mainframe server in a number of ways such as thin cpent, dummy terminal, Virtual Cpent System (VCS), or Virtual Desktop System (VDS). Every vapd user is given a login id to enter into the Z/OS interface (TSO/E or ISPF).

Compipng COBOL Programs

In order to execute a COBOL program in batch mode using JCL, the program needs to be compiled, and a load module is created with all the sub-programs. The JCL uses the load module and not the actual program at the time of execution. The load pbraries are concatenated and given to the JCL at the time of execution using JCLLIB or STEPLIB.

There are many mainframe compiler utipties available to compile a COBOL program. Some corporate companies use Change Management tools pke Endevor, which compiles and stores every version of the program. This is useful in tracking the changes made to the program.

//COMPILE   JOB ,CLASS=6,MSGCLASS=X,NOTIFY=&SYSUID             
//*            
//STEP1     EXEC IGYCRCTL,PARM=RMODE,DYNAM,SSRANGE
//SYSIN     DD DSN=MYDATA.URMI.SOURCES(MYCOBB),DISP=SHR
//SYSLIB    DD DSN=MYDATA.URMI.COPYBOOK(MYCOPY),DISP=SHR
//SYSLMOD   DD DSN=MYDATA.URMI.LOAD(MYCOBB),DISP=SHR
//SYSPRINT  DD SYSOUT=*
//*

IGYCRCTL is an IBM COBOL compiler utipty. The compiler options are passed using the PARM parameter. In the above example, RMODE instructs the compiler to use relative addressing mode in the program. The COBOL program is passed using the SYSIN parameter. Copybook is the pbrary used by the program in SYSLIB.

Executing COBOL Programs

Given below is a JCL example where the program MYPROG is executed using the input file MYDATA.URMI.INPUT and produces two output files written to the spool.

//COBBSTEP  JOB CLASS=6,NOTIFY=&SYSUID
//
//STEP10    EXEC PGM=MYPROG,PARM=ACCT5000
//STEPLIB   DD DSN=MYDATA.URMI.LOADLIB,DISP=SHR
//INPUT1    DD DSN=MYDATA.URMI.INPUT,DISP=SHR
//OUT1      DD SYSOUT=*
//OUT2      DD SYSOUT=*
//SYSIN     DD *
//CUST1     1000
//CUST2     1001
/*

The load module of MYPROG is located in MYDATA.URMI.LOADLIB. This is important to note that the above JCL can be used for a non-DB2 COBOL module only.

Executing COBOL-DB2 programs

For running a COBOL-DB2 program, a speciapzed IBM utipty is used in the JCL and the program; DB2 region and required parameters are passed as input to the utipty.

The steps followed in running a COBOL-DB2 program are as follows −

When a COBOL-DB2 program is compiled, a DBRM (Database Request Module) is created along with the load module. The DBRM contains the SQL statements of the COBOL programs with its syntax checked to be correct.

The DBRM is bound to the DB2 region (environment) in which the COBOL will run. This can be done using the IKJEFT01 utipty in a JCL.

After the bind step, the COBOL-DB2 program is run using IKJEFT01 (again) with the load pbrary and the DBRM pbrary as the input to the JCL.

//STEP001  EXEC PGM=IKJEFT01
//*
//STEPLIB  DD DSN=MYDATA.URMI.DBRMLIB,DISP=SHR
//*
//input files
//output files
//SYSPRINT DD SYSOUT=*
//SYSABOUT DD SYSOUT=*
//SYSDBOUT DD SYSOUT=*
//SYSUDUMP DD SYSOUT=*
//DISPLAY  DD SYSOUT=*
//SYSOUT   DD SYSOUT=*
//SYSTSPRT DD SYSOUT=*
//SYSTSIN  DD *
   DSN SYSTEM(SSID)
   RUN PROGRAM(MYCOBB) PLAN(PLANNAME) PARM(parameters to cobol program) -
   LIB( MYDATA.URMI.LOADLIB )
   END
/*

In the above example, MYCOBB is the COBOL-DB2 program run using IKJEFT01. Please note that the program name, DB2 Sub-System Id (SSID), and DB2 Plan name are passed within the SYSTSIN DD statement. The DBRM pbrary is specified in the STEPLIB.