CICS Tutorial

CICS – Customer Information Control System

Task – The fundamental unit of work scheduled by CICS such as Read from file, write to file, read from workstation, write to workstation, initiate another task, call another function and so on.

In CICS terms, a task is an instance of a transaction. When a transaction is initiated, a task gets created by OS and process the data/input provided by user/terminal. A task gets ended once the process is completed. 

A task can be viewed using CICS execute master terminal transaction (CEMT)

CEMT INQ TASK(task-id)

Transaction – An entity to initiate/invoke a task for execution. A transaction is 1 to 4 characters long.

A transaction is a piece of processing initiated by single request, usually by end user at a terminal.

A single transaction will consist of one or more application programs that, when run, will carry out the processing needed.

A transaction in CICS is a unit of work and is represented by a 4 character TRANSID. Generally, one transaction executes on or more programs.

Program – Set of instructions to achieve a task.

LUW (Logical unit of work) tells that the piece of work should be done either completely or not done at all.

NON AID keys – Alphabets, numbers, punctuation etc. CICS will NOT even know if user presses any NON AID key which means it can’t detect NON AID keys when pressed.

AID Keys – Attention Identifier keys are Function keys ( PF1 to PF24 ), Enter, CLEAR and PA1 to PA3 keys. CICS detect only AID keys when pressed.

After text is typed, CICS takes the control once user presses any AID key.

PA1 -> Alt + PF1

MDT – Modified Data Tag

FRSET – Flag ReSET

Control Programs –

CICS nucleus is constructed by control programs

Terminal Control Program (TCP) is used to receive messages from the terminal. It also maintains hardware communication requirements.

Task Control Program (KCP) is used to simultaneously control the execution of tasks and its related properties. It also handles all issues related to Multitasking.

Program Control Program (PCP) is used to locate and load programs for execution. It transfers the control between two programs and at the end, it returns the control to CICS.

File control Program (FCP) provides an application program with the services like read, write, insert, update or delete records in a file.

Storage Control Program (SCP) is used to allocate or de-allocate the memory in CICS region.

Control Tables –

The control tables needs to be updated accordingly with application information for the successful execution of CICS application program.

Terminal Control Table (TCT) contains the terminal IDs connected to the current CICS region. Whenever we login to CICS terminal, an entry is made in TCT.

Program control table (PCT) contains Transaction ID and the program associated with it.

Processing Program table (PPT) contains the program name or mapset name, task use counter, main storage address, load library address etc. When CICS receives the transaction, corresponding program name is picked up from PCT and gets loaded.

File Control Table (FCT) contains the information about file names, file types, record length etc. All the files names used in CICS must be declared in FCT.

How a transaction processing is done?

Once the user enters transaction ID(eg., TN01) on the CICS terminal, first corresponding program name will be checked in PCT. Once the program is found in PCT, it checks the main storage address/ Load library address to get the program loaded into the memory for execution. 

CICS system transactions -

CESN (CICS Execute SigNon) – This transaction is used to sign on into the CICS region.

CEDA (CICS Execute Definition and Administration) – This transaction is used by CICS administrators to define CICS table entries and other Admin activities.

CEMT (CICS Execute Master Terminal) – Used to inquire and update the status of CICS environments. This is also used to load a new program, load a copy of the old program into CICS after changes to program.

CECI (CICS Execute Command Interpreter) – Used to check the syntax of CICS commands. Here the command gets executed only if the syntax is correct.

CEDF (CICS Execute Debug Facility) – Used for debugging the program step-by-step which helps finding the errors.

CEAC (CICS Execute Abend Codes) – Used to find the explanation for the CICS abend codes.

CESF (CICS Execute Sign oFf) – Used to sign off from CICS region.

Multitasking is a feature of OS where multiple tasks can execute simultaneously. CICS supports multitasking.

Multithreading is a feature of OS where multiple tasks (created by OS for several transactions) executes the same program but with different data. Here, each task gets different copy of the same program. Multithreading requires that all CICS application programs must be quasi-reetrant; that is, they must be serially reusable between entry and exit points. 

Reentrancy: The reentrant program does not modify by itself when it is reentered after an interruption by the OS.

The program should not be in modified state, when CICS starts using the copy of that program.

For instance, when CICS receives first request to process a program, it starts executing that program. If, at the same time CICS another request of higher priority then the first one, then CICS halts the processing of the first request and preserve its state ( all changed variable data, or changed application logic for the 1st request) in a separate storage area and initialize the program (to get fresh copy of that program), start executing the second request. Once it is done, it initializes the program again and restores its first request's state and start executing the request from where it has stopped.   

Quasi-Reentrancy – A reentrant program in CICS environment.

                         BMS (BASIC MAPPING SUPPORT)

BMS helps to develop formatted screens which are used to communicate between Terminal and CICS program.

MAP – It is a screen representation of a functionality where users can access it. A map can have name from 1 to 7 chars. 

Example : A customer enquiry screen where bank employees/users can access to check customer details by providing customer number as input.

MAPSET – Collection of maps which are link edited together to form a load module. It should have a PPT entry and can have name from 1 to 7 chars.

CICS provides BMS to make an application program device independent and format independent.

BMS Macros:

DFHMSD – Used to define MAPSET and its characteristics.

DFHMSD – used to define a MAPSET or Generates MAPSET definition. MAPSET name is a load module name which should have an entry in PPT.

Parameters:

TYPE -> used to define the map and the type.

MAP- Physical map is created

DSECT – Symbolic map is created

&&SYSPARM – Both Physical and Symbolic maps are created

Final – end of the mapset coding.

MODE -> Specifies whether the mapset is to be used for input, output or both.

IN – For Input only

OUT – For Output only

INOUT – For both Input and Output

LANG -> Specifies the language of the application program into which symbolic description maps in the mapset are copied.

This parameter will be coded only when DFHMSD TYPE=DSECT

STORAGE ->

AUTO – Both Physical and Symbolic maps will use separate memory locations.

BASE –

CTRL -> used to define device control requests.

FREEKB – to unlock keyboard

FRSET – to reset MDT to zero status

ALARM – To display alarm at screen display time

PRINT – sends the map to printer

TERM – type -> ensure device independence and need to be coded only when the terminal is not 3270.

TIOAPFX (Terminal Input Output Area PreFiX) -> Specifies whether BMS should include filler in symbolic map.

TIOAPFX = YES – to reserve the prefix space of 12 bytes for BMS commands to access TIOA properly. It should always be used for command level application programs.

If TIOAPFX=YES is specified, all maps within the mapset have the filler

TIOAPFX = NO - default option. It specifies that filler should not be included in symbolic maps. 

DFHMDI – Used to define a MAP within the Mapset.

SIZE =(Rows,Columns) - > specifies the size of the map to be displayed to the user. The standard size is 24 rows 80 columns

LINE – Row number where the map actually starts

COLUMN – Column number where the map actually starts

JUSTIFY – specifies entire map or map fields are left or right justified.

CTRL,TIOAPFX are same as DFHMSD

DFHMDF – used to define new field on the map. We have to code DFHMDF macro for every field present on the map.

POS (row, col) - specifies the position of the field on the map by specifying row and col#.

INITIAL specifies the initial value of the field. Same as value clause in cobol. i.e 
FLDNAME contains value ‘I LOVE CICS’.

LENGTH specifies the length of the field.

ASKIP means Auto skip.

Data cannot be entered in this field. The cursor skips to next field.

IC (Insert Cursor) specifies the cursor needs to be placed on this field when the map is displayed. If IC is specified more than once, the cursor is placed in the last field.

PROT specifies to protect this field from entering or editing the data

UNPROT specifies to unprotect the field to edit or enter the data

BRT displays the field with bright intensity

DARK displays the field with dark intensity

NORM specifies normal display

COLOR is used to specify the color for this field

PICIN, PICOUT are used to specify the length of data fields used as input/output. (used to specify the picture clause for input and output Cobol variables in the symbolic map)

Here is the complete BMS Macro Source Code for the Customer Inquiry Screen, with all the DFHMSD, DFHMDI and DFHMDF Macros. 

----+----1----+----2----+----3----+----4----+----5----+----6----+----7--

        PRINT  NOGEN

INQSET1 DFHMSD TYPE=&SYSPARM,                                          X

               LANG=COBOL,                                             X

               MODE=INOUT,                                             X

               TERM=ALL,                                               X

               DSATTS=COLOR,                                           X

               CTRL=FREEKB,                                            X

               STORAGE=AUTO,                                           X

               TIOAPFX=YES

INQMAP1 DFHMDI SIZE=(24,80),                                           X

               LINE=1,                                                 X

               COLUMN=1

        DFHMDF POS=(1,1),                                              X

               LENGTH=8,                                               X

               ATTRB=(NORM,PROT),                                      X

               COLOR=TURQUOISE,                                        X

               INITIAL='CUSTINQ1'

        DFHMDF POS=(1,32),                                             X

               LENGTH=16,                                              X

               ATTRB=(NORM,PROT),                                      X

               COLOR=TURQUOISE,                                        X

               INITIAL='Customer Inquiry'

TRANSID DFHMDF POS=(1,76),                                             X

               LENGTH=04,                                              X

               ATTRB=(NORM,PROT),                                      X

               COLOR=TURQUOISE,                                        X

               INITIAL='INQ1'

        DFHMDF POS=(3,01),                                             X

               LENGTH=42,                                              X

               ATTRB=(NORM,PROT),                                      X

               COLOR=TURQUOISE,                                        X

               INITIAL='Type a customer number. Then press ENTER.'

        DFHMDF POS=(5,01),                                             X

               LENGTH=24,                                              X

               ATTRB=(NORM,PROT),                                      X

               COLOR=TURQUOISE,                                        X

               INITIAL='Customer number. . . . .'

CUSTNO  DFHMDF POS=(5,26),                                             X

               LENGTH=06,                                              X

               ATTRB=(NORM,UNPROT),                                    X

               COLOR=TURQUOISE,                                        X

               INITIAL='______'

        DFHMDF POS=(5,33),                                             X

               LENGTH=01,                                              X

               ATTRB=ASKIP

        DFHMDF POS=(7,01),                                             X

               LENGTH=24,                                              X

               ATTRB=(NORM,PROT),                                      X

               COLOR=TURQUOISE,                                        X

               INITIAL='Name and Address . . . :'

LNAME   DFHMDF POS=(7,26),                                             X

               LENGTH=30,                                              X

               ATTRB=(NORM,PROT),                                      X

               COLOR=TURQUOISE

FNAME   DFHMDF POS=(8,26),                                             X

               LENGTH=20,                                              X

               ATTRB=(NORM,PROT),                                      X

               COLOR=TURQUOISE

ADDR    DFHMDF POS=(9,26),                                             X

               LENGTH=30,                                              X

               ATTRB=(NORM,PROT),                                      X

               COLOR=TURQUOISE

CITY    DFHMDF POS=(10,26),                                            X

               LENGTH=20,                                              X

               ATTRB=(NORM,PROT),                                      X

               COLOR=TURQUOISE

STATE   DFHMDF POS=(10,47),                                            X

               LENGTH=02,                                              X

               ATTRB=(NORM,PROT),                                      X

               COLOR=TURQUOISE

ZIPCODE DFHMDF POS=(10,50),                                            X

               LENGTH=10,                                              X

               ATTRB=(NORM,PROT),                                      X

               COLOR=TURQUOISE

MESSAGE DFHMDF POS=(23,01),                                            X

               LENGTH=79,                                              X

               ATTRB=(BRT,PROT),                                       X

               COLOR=TURQUOISE

        DFHMDF POS=(24,01),                                            X

               LENGTH=20,                                              X

               ATTRB=(NORM,PROT),                                      X

               COLOR=TURQUOISE,                                        X

               INITIAL='PF3=Exit PF12=Cancel'

        DFHMSD TYPE=FINAL

               END

                                    CICS MAP 

Physical Map

Physical map is a load module in the load library which contains the information about how the map should be displayed.

TYPE=MAP in MAPSET definition creates Physical map

A map without any values is considered as Physical map.

CUSTOMER MAINTENANCE                              CUST010

      CUST ID : -------

      CUST NAME :

      ADDRESS:

              ADDRESS LINE 1 :

              ADDRESS LINE 2 :

              ADDRESS LINE 3 :

              CITY           :

              STATE          :

                                                        LAST UPD DATE:        BY

                    ENTER=INQUIRE PF1=HELP PF3=EXIT PF4=UPDATE

Physical map is coded with BMS Macros. This is primarily used by CICS and ensures device independence in the application program.

BMS macros are assembled separately and link edited into the CICS load library

Symbolic Map

Symbolic map is a copybook in the library which is used by CICS application program to send and receive messages from the terminal.

TYPE=DSECT in MAPSET definition creates Symbolic map

Represents a variable portion of a map, that is an area where user can enter data.

Once the input is given, all the symbolic map variables get populated on to the screen to give the customer details as below:

CUSTOMER MAINTENANCE                          CUST010

         CUST ID : 990123

         CUST NAME : REDDY

         ADDRESS:

                ADDRESS LINE 1 : FLAT NO 990

                ADDRESS LINE 2 : RD NO 46

                ADDRESS LINE 3 : AREA 1

                CITY           : HYDERABAD

                STATE          : TELANGANA

                                                   LAST UPD DATE: 28/06/19     BY MAHY

                ENTER=INQUIRE PF1=HELP PF3=EXIT PF4=UPDATE

Symbolic map ensures device and format independence to the application program

Symbolic map contains all the variable data which is copied into program’s working storage section.

Symbolic map is included in the program by using COBOL COPY statement.

If TYPE=&SYSPARM, both physical and symbolic maps are created.

SKIPPER and STOPPER fields:

Suppose I have coded the length of a field as 10 which means ideally we are able to enter the data on this field for up to 10 chars. But, when we display the map and try to enter the data on the same field, it allows us to enter the data of more than 10 chars. So, to avoid this situation we use skipper and stopper fields.

Skipper and stopper fields are unnamed fields with length of 1 which needs to be specified after actual field.

Skipper field – When we code the skipper field after an unprotected field and start entering the value on the field, once the specified length is reached then the cursor moves to the next unprotected field.

NUMBER DFHMDF POS=(01,01),

              LENGTH=5,

              ATTRB=(UNPROT,IC)

              DFHMDF POS=(01,07),

              LENGTH=1,

              ATTRB=(ASKIP)

Stopper field – When stopper field is coded after an unprotected field and start entering the value on this field, then once the limit is reached the cursor stops its positioning.

NUMBER DFHMDF POS=(01,01),

              LENGTH=5,

              ATTRB=(UNPROT,IC)

              DFHMDF POS=(01,07),

              LENGTH=1,

              ATTRB=(PROT)

Attribute Byte:

The attribute byte of any field stores information about the physical properties of the field.

0&1 – determined by contents of bit 2 to 7

2&3 – Protection and shift

      00 unprotected alphanumeric

      01 unprotected numeric

      10 protected stop

      11 protected skip

4&5 – Intensity  00 – normal, 01 – normal, 10 – bright, 11- No display (dark)

6 – Must be zero always

7 – Modified data tag. 0- field has not been modified, 1- field has been modified.

Modified Data Tag (MDT):

A flag which holds single bit and used to specify whether the data can be transferred to the system or not. This is the last bit in attribute byte.

If MDT = 0, the field is not modified and the data cannot be transferred.

If MDT = 1, the field is modified and the data can be transferred

CICS hardware transmits only those fields to the program whose MDT is 1 using RECEIVE macro. If program needs more fields to process, those field's MDT needs to be set to 1 programmatically before sending them to terminal using SEND macro. In this case, even if user don't make any changes to those fields then their MDT will still be 1.

MDT is useful to avoid MAPFAIL error. If none of the fields are modified, then program tries to RECEIVE map with no updated fields which results to MAPFAIL error.

FSET in ATTRB (can be seen in field definition macro DFHMDF) sets the MDT to 1
To reset, use FRSET in CTRL (can be seen in Map definition Macro DFHMDI).

SEND MAP:

This command sends output data to the terminal

EXEC CICS SEND

    MAP('map-name')

    MAPSET('mapset-name')

    [FROM(data-area)]

    [LENGTH(data_value)]

    [DATAONLY]

    [MAPONLY]

    [CURSOR]

    [ERASE/ERASEAUP]

    [FREEKB]

    [FRSET]

END-EXEC  

Parameters in SEND MAP

MAP – Name of the map which we want to send

MAPSET – Name of the mapset which contains the map

FROM – specifies the data area containing the data to be processed

MAPONLY – specifies that only default data from the map is to be written

DATAONLY – specifies that only application program data is to be written

ERASE – To erase the complete screen before displaying what we send to terminal

ERASEUP – To erase the values in unprotected fields

FRSET – Flag ReSET turns off the MDT in attribute byte of all the fields before      placing the data which is sending.

CURSOR – to specify the cursor position on the terminal. We move -1 to the L part of the field and then send map to the terminal.

ALARM,FREEKB,PRINT are same

FORMFEED – Makes the printer to restore to the top of the next page before output is printed.

Receive Map:

This command is used to receive input from terminal.

EXEC CICS RECEIVE 

       MAP('map-name')

       MAPSET('mapset-name')

       [INTO(data-area)]

       [FROM(data-area)]

       [LENGTH(data_value)]

END-EXEC        

Restricted COBOL verbs:

File i/o statements like READ, WRITE, REWRITE, CLOSE, OPEN, DELETE and START.

File section and Environment division.

System functions like ACCEPT, DATE/TIME

Verbs like DISPLAY, MERGE, STOP RUN, GO BACK

Execute Interface Block (EIB):

EIB lets the program communicate with the execute interface program which process CICS commands. This contains terminal ID, time of day and response codes.

List of fields in EIB

EIBAID X(1) Aid key pressed

EIBCALEN S9(4) COMP – Length of communication area

EIBDATE S9(7) COMP-3 – Contains current system date

EIBTASKN S9(7) COMP-3– Contains task number

EIBRCODE X(6)– Return code of the last transaction

EIBTRMID X(4)– contains terminal id

EIBTRNID X(4)– contains transaction id

EIBTIME S9(7) COMP-3– contains current system time

CICS programs classification

1.  Non conversion programs: Human intervention is not required. All the required inputs need to be provided before we start executing the program.

Example - Below program displays “Hello World” on the terminal

IDENTIFICATION DIVISION.                                

PROGRAM-ID. HELLO.                                      

DATA DIVISION.                                          

WORKING-STORAGE SECTION.                                

01 WS-MESSAGE          PIC X(30).                       

PROCEDURE DIVISION.                                     

********************************************************

* SENDING DATA TO SCREEN                               * 

********************************************************

        MOVE 'HELLO WORLD' TO WS-MESSAGE                

        EXEC CICS SEND TEXT                             

             FROM (WS-MESSAGE)                          

        END-EXEC                                        

********************************************************

* TASK TERMINATES WITHOUT ANY INTERACTION FROM THE USER* 

********************************************************

        EXEC CICS RETURN                                

        END-EXEC.

2.  Conversion Programs: Sending a message to the terminal and receiving the response from user is called conversation.

An online application allows conversation between user and application by a pair of SEND and RECEIVE messages.

• First system sends data to the terminal and waits for the user response.
• The time required for the user to respond to this message is called think     time which is very high.
• The user provides necessary input and presses AID key.
• The application processes the input and sends the output.
• The program loaded into the main storage until the task ends.

Drawback – Think time is very high for conversion programs.

Pseudo-conversation program:

Here the system will not wait for user response, instead terminates the transaction once it sends data to the terminal. The transaction will be started again when user presses any AID key.

After termination, the system allocates resources used by this transaction to other transactions which makes the best utilization of the resources.

COMMAREA is used to pass data between tasks. We declare WS-COMMAREA in working-storage section

DFHCOMMAREA is a special memory area allocated by CICS to every task. This is used to pass data between programs either of same transaction or different transactions. This should be declared in linkage-section under 01 level. The length of both ws-commarea and dfhcommarea must be same.

WORKING-STORAGE SECTION.

01 WS-COMMAREA.

   05 WS-DATA PIC X(10).  

LINKAGE SECTION.

01 DFHCOMMAREA.

   05 LK-DATA PIC X(10).

RETURN statement:

The two types are return statements are

1.  Return statement without condition, which terminates task and transaction.

EXEC CICS RETURN

END-EXEC

2.  Return statement with condition,

    When the return is issued with transaction id (TRNSID) statement, the               control returns to CICS with the next transaction ID.

EXEC CICS RETURN

          TRNSID(‘TRANSID’),

          [COMMAREA(WS-COMMAREA)]

END-EXEC

DFHAID is a CICS provided copybook which contains pre-coded set of variables used by application programs. This copybook can be included in the application program by the statement COPY DFHAID.

Dynamically Modifying attributes of a field:

To modify the attributes of a field we must include CICS provided copybook DFHATTR in the application program. The attribute can be chosen from the list of variables in that copybook and moved to the symbolic variable suffixed with A.

                            CICS File Handling

CICS allows users to access files in

Random order

Sequential Order

                                 Random access

Most file accesses are random in online because the transactions are not batched and sorted in any order.

The commands used for random processing

READ command reads a record from a file using primary key.

Syntax:

EXEC CICS READ

    FILE('name')

    INTO(data-area)

    RIDFLD(data-area)

    LENGTH(data-value)

    KEYLENGTH(data-value)

END-EXEC.

FILE - name of the file which is of 8 characters long and should be enclosed in             quotes. The file name should have an entry in FCT

INTO – a data-area (variable) into which record is to be read.

RIDFLD – contains key of the record that needs to read

LENGTH – the max number of characters that may be read into data-area specified

KEYLENGTH – Length of the key

Example:

IDENTIFICATION DIVISION.                                         

PROGRAM-ID. HELLO.                                               

DATA DIVISION. 

WORKING-STORAGE SECTION.

01 WS-STD-REC-LEN    PIC S9(4) COMP.

01 WS-STD-KEY-LEN    PIC S9(4) COMP.

01 WS-STD-REC-KEY    PIC 9(3).

01 WS-STD-REC        PIC X(70).

PROCEDURE DIVISION.

MOVE +70           TO WS-STD-REC-LEN.

MOVE ‘100’         TO WS-STD-REC-KEY.

MOVE 3             TO WS-STD-KEY-LEN.

EXEC CICS READ

    FILE ('FL001')

    INTO (WS-STD-REC)

    LENGTH (WS-STD-REC-LEN)

    RIDFLD (WS-STD-REC-KEY)

    KEYLENGTH (WS-STD-KEY-LEN)

END-EXEC.

Read command options:

GENERIC is used when we doesn’t know the complete key value.

UPDATE specifies the record is to be obtained for update or deletion. Skipping this option assumes read-only.

EQUAL specifies that we need the record whose key matches exactly with the one specified in RIDFLD

GTEQ specifies that we want the first record whose key is greater than or equal to the key specified

EXEC CICS READ

    FILE('name')

    INTO(data-area)

    RIDFLD(data-area)

    LENGTH(data-value)

    KEYLENGTH(data-value)

    GENERIC

    UPDATE

    EQUAL

    GTEQ

END-EXEC.

Read command exceptions

NOTOPEN – file not open

NOTFND – Record not found in the dataset

FILENOTFOUND – No file name entry in FCT

LENGERR – Length of the record doesn’t match with the specified in the command

NOTAUTH – Not authorized to use the file

DUPKEY – If more than one record satisfy the condition of key

WRITE command is used to write new records into a file

The parameters are same as for read except that “Data records will be picked FROM data area specified and writes into a file.

EXEC CICS WRITE

    FILE(name)

    FROM(data-area)

    RIDFLD(data-area)

    LENGTH(data-value)

    KEYLENGTH(data-value)

END-EXEC.

Following is the example to write a record in 'FL001' file where Student-id is the primary key and a new record with 101 student id will be written in the file:

IDENTIFICATION DIVISION.                                         

PROGRAM-ID. HELLO.                                               

DATA DIVISION. 

WORKING-STORAGE SECTION.

01 WS-STD-REC-LEN    PIC S9(4) COMP.

01 WS-STD-KEY-LEN    PIC S9(4) COMP.

01 WS-STD-REC-KEY    PIC 9(3).

01 WS-STD-REC        PIC X(70).

PROCEDURE DIVISION.

MOVE +70           TO WS-STD-REC-LEN.

MOVE ‘101’         TO WS-STD-REC-KEY.

MOVE 3             TO WS-STD-KEY-LEN.

MOVE '101Mohtahim M TutorialsPoint' TO WS-STD-REC.

EXEC CICS WRITE

    FILE ('FL001')

    FROM (WS-STD-REC)

    LENGTH (WS-STD-REC-LEN)

    RIDFLD (WS-STD-REC-KEY)

    KEYLENGTH (WS-STD-KEY-LEN)

END-EXEC.

Write command exceptions are same as read command exceptions

REWRITE command is used to modify existing record in the file.

Before REWRITE the record must be read with READ UPDATE command. The parameters are same as write

EXEC CICS REWRITE

    FILE (name)

    FROM (data-area) 

    LENGTH (data-value)

END-EXEC.

Example

IDENTIFICATION DIVISION.                                         

PROGRAM-ID. HELLO.                                               

DATA DIVISION. 

WORKING-STORAGE SECTION.

01 WS-STD-REC-LEN    PIC S9(4) COMP.

01 WS-STD-KEY-LEN    PIC S9(4) COMP.

01 WS-STD-REC-KEY    PIC 9(3).

01 WS-STD-REC        PIC X(70).

PROCEDURE DIVISION.

MOVE +70           TO WS-STD-REC-LEN.

MOVE ‘101’         TO WS-STD-REC-KEY.

MOVE 3             TO WS-STD-KEY-LEN.

EXEC CICS READ

    FILE ('FL001')

    INTO (WS-STD-REC)

    LENGTH (WS-STD-REC-LEN)

    RIDFLD (WS-STD-REC-KEY)

    KEYLENGTH (WS-STD-KEY-LEN)

    UPDATE

END-EXEC.

MOVE '100Mohtahim M TutorialsPnt' TO WS-STD-REC.

EXEC CICS REWRITE

    FILE ('FL001')

    FROM (WS-STD-REC)

    LENGTH (WS-STD-REC-LEN)

END-EXEC.

Rewrite command exceptions

NOTOPEN, LENGERR, NOTAUTH

INVREQ specifies rewrite without prior READ with UPDATE

NOSPACE specifies no enough space in the dataset

DELETE command is used to delete a record from a file.

Before Delete, we have to READ the record with UPDATE

EXEC CICS DELETE

    FILE('name')

    RIDFLD(data-value)

END-EXEC.

Delete command exceptions

NOTOPEN, NOTFOUND, NOTAUTH, INVREQ, FILENOTFOUND

                      Sequential Access

STARTBR(START Browse) tells the CICS from where to start reading the file.

FILE and RIDFLD are same as READ.

Only GTEQ and EQUAL are allowed.

File browsing is strictly Read-Only, so UPDATE is not allowed.

Syntax:

EXEC CICS STARTBR

    FILE ('name')

    RIDFLD (data-value)

    KEYLENGTH(data-value)

    GTEQ/EQUAL/GENERIC

END-EXEC.

READNEXT is to proceed reading the record starting from first record and in sequence one by one

READPREV is to proceed reading the file from backwards.

RIDFLD contains the key of the record which is currently read.

Syntax:

EXEC CICS READNEXT/READPREV

    FILE ('name')

    INTO (data-value)

    LENGTH (data-value)

    RIDFLD (data-value)

END-EXEC

RESETBR resets the starting point of the file in the middle of the browse

Syntax:

EXEC CICS RESETBR

    FILE ('name')

    RIDFLD (data-value)

    GTEQ

END-EXEC.

ENDBR allows us to end the browse once we finish reading the file sequentially

Syntax:

EXEC CICS ENDBR

    FILE ('name')

END-EXEC.

                     CICS – Error Handling

RESP and RESP2:

Every EXEC-CICS gives a response back after execution. Using RESP, user can validate the response received before proceeding further. RESP should be coded in the command as below:

EXEC CICS RECEIVE MAP(MAP01)
           MAPSET(MAP01S)
           INTO(WS-MAP)
           RESP(WS-RESPONSE)
END-EXEC


In EIB copybook. EIBRESP, EIBRESP2 contains details of an error.

CICS error handling commands are

Handle condition specifies the label (para) to which control is to be passed when the condition arises. We must include the name of the condition and a label to which control is to be passed.

It will NOT handle system abends like SOC4, SOC7 etc. 

Example:-

IDENTIFICATION DIVISION.                                         

PROGRAM-ID. HELLO.                                               

PROCEDURE DIVISION.

EXEC CICS HANDLE CONDITION

    DUPKEY(X0000-DUPKEY-ERR-PARA)

    NOTFND(X000-NOT-FOUND-PARA)

    ERROR(X0000-GEN-ERR-PARA)

END-EXEC.

X0000-DUPKEY-ERR-PARA.

DISPALY 'Duplicate Key Found'.

X0000-NOT-FOUND-PARA.

DISPLAY 'Record Not Found'.

X0000-GEN-ERR-PARA.

DISPLAY 'General Error'.

As per the above program, if DUPKEY condition arises, then the control will be passed to X0000-DUPKEY-ERR-PARA

Handle Abend:

On abnormal termination of a task,  it routes the errors to a specific program or a para given in HANDLE ABEND.

It also deactivates or reactivates previous HANDLE conditions.

Example:

EXEC CICS HANDLE ABEND

    PROGRAM(name)

    LABEL(para-name)  

    CANCEL|RESET

END-EXEC

Program - program name to which control is to be passed
Label - para-name to which control is to be passed.
Cancel - to cancel the active HANDLE ABEND request
Reset - to set the previously cancelled HANDLE ABEND requests

ABEND command terminates the task abnormally. We can define user defined abend codes using this command

EXEC CICS ABEND

     ABCODE(code)

END-EXEC

Example:

IDENTIFICATION DIVISION.                                         

PROGRAM-ID. HELLO.                                               

PROCEDURE DIVISION.

EXEC CICS ABEND

    ABCODE(D100) 

END-EXEC.

Ignore condition:  It is to instruct CICS that any exception(s) mentioned inside IGNORE CONDITION should be ignored and the program should give control to the next executable line of this condition.

Syntax:

EXEC CICS IGNORE CONDITION

     CONDITION(para)

END-EXEC

Example:

EXEC CICS
     IGNORE CONDITION
     MAPFAIL
END-EXEC

NOHANDLE option with any command specifies that no action to be taken for any exception condition occurs during the execution of that command

Syntax:

EXEC CICS SEND

    program statements

    NOHANDLE    

END-EXEC.

Example – Below program will not abend if the read statement fails

IDENTIFICATION DIVISION.                                         

PROGRAM-ID. HELLO.                                               

PROCEDURE DIVISION.

EXEC CICS READ   

    FILE('FILE1')                

    INTO(WS-FILE-REC)             

    RIDFLD(WS-STDID)             

    NOHANDLE                          

END-EXEC. 

HANDLE AID: To handle the aid keys received and it is invoked after every RECEIVE command.

EXECCICS      HANDLE AID      DFHENTR (PARA1)      DFHPF1 (PARA2)      ANYKEY (PARA3) END-EXEC

Commands used for program control services

XCTL transfers control from one application program to another at the same logical level. It doesn’t expect the control back (similar to goto statement).

Below example transfers control to the program ‘prog2’ with 100 bytes of data

IDENTIFICATION DIVISION.                                         

PROGRAM-ID. PROG1.  

WORKING-STORAGE SECTION.

01 WS-COMMAREA    PIC X(100).                                             

PROCEDURE DIVISION.

EXEC CICS XCTL

    PROGRAM ('PROG2')

    COMMAREA (WS-COMMAREA)

    LENGTH (100)

END-EXEC.

LINK transfers control from an application program at one logical level to an application program at next lower logical level.

IDENTIFICATION DIVISION.                                         

PROGRAM-ID. PROG1.  

WORKING-STORAGE SECTION.

01 WS-COMMAREA    PIC X(100).                                             

PROCEDURE DIVISION.

EXEC CICS LINK

    PROGRAM ('PROG2')

    COMMAREA (WS-COMMAREA)

    LENGTH (100)

END-EXEC.

LOAD makes a copy of application program, table or map available to the invoking task.

EXEC CICS LOAD

     PROGRAM(‘name’)

END-EXEC

RELEASE releases the program, table or mapset which was previous loaded by LOAD command. This means releasing all the resources of the task.

EXEC CICS RELEASE

     PROGRAM(‘name’)

END-EXEC

RETURN command returns control from an application program either to an application program at next higher logical level, or to CICS.

EXEC CICS RETURN

    PROGRAM ('name')

    COMMAREA (data-value)

    LENGTH (data-value)

END-EXEC.

Interval Control operations:

ASKTIME requests current date and time or timestamp. This can later be moved to working-storage variable in the program.

EXEC CICS ASKTIME

    [ABSTIME(WS-TIMESTAMP)]

END-EXEC.

FORMATTIME formats the timestamp into the required format.

XEC CICS FORMATTIME

    ABSTIME(WS-TIMESTAMP)

    [YYDDD(WS-DATE)]

    [YYMMDD(WS-DATE)]

    [YYDDMM(WS-DATE)]

    [DATESEP(WS-DATE-SEP)]

    [TIME(WS-TIME)]

    [TIMESEP(WS-TIME-SEP)]

END-EXEC.

Any transaction in the CICS region can access common work area and there is only one CWA for entire CICS region.

Transaction work area (TWA) is used to pass data between application programs which belong to same transaction. TWA exists only during the transaction.

Temporary Storage Queue (TSQ)

•  A queue of records which are created, read and deleted by different tasks or programs in the same CICS region.
• A record within a TSQ is identified by item number and can be read sequentially or directly.
•  The records in the TSQ are accessible until the TSQ is explicitly deleted.
•  The TSQs may be written in main storage or auxiliary storage in DASD.
•  TSQs can be accessed by programs and transactions from the same CICS region.

WRITEQ TS allows you to write records into a TSQ.

If no such queue exists, one will be created and writes records into it.

TSQ is identified by queue ID 1-8 bytes.

EXEC CICS WRITEQ TS

    QUEUE ('queue-name')

    FROM (queue-record)

    [LENGTH (queue-record-length)]

    [ITEM (item-number)]

    [REWRITE]

    [MAIN /AUXILIARY]

END-EXEC.

QUEUE specifies the name of the TSQ.

FROM specifies the record to be written into the queue

LENGTH specifies length of the record

ITEM specifies the item number to be assigned to the record

REWRITE is used to update the existing record in the queue

MAIN/AUXILIARY option is used to store record in MAIN/AUXILIARY

AUXILIARY is default

READQ TS allows you to read the data in TSQ

EXEC CICS READQ TS

    QUEUE ('queue-name')

    INTO (queue-record)

    [LENGTH (queue-record-length)]

    [ITEM (item-number)]

    [NEXT]

END-EXEC.

NEXT specifies the next logical data item to be read

DELETEQ TS allows you to delete an entire TSQ

EXEC CICS DELETEQ TS

    QUEUE ('queue-name')

END-EXEC.

Transient Data Queue (TDQ) is the queue which can be created and delete quickly.

The contents in the Queue can be read only once as they get destroyed after read is performed.

Allows only sequential access.

TDQ identified by 1 to 4 char name called destinationID which must be registered in DCT (Destination control table).

Intrapartition TDQ – Allows sequential access and once the record is read, it is deleted from queue.

Extrapartition TDQ – Once the record is read, record is not deleted from the queue.

WRITEQ TD – used to write into TDQ and they are always written to a file

EXEC CICS WRITEQ TD

    QUEUE ('queue-name')

    FROM (queue-record)

    [LENGTH (queue-record-length)]

END-EXEC.

READQ TD – used to read the TDQ

EXEC CICS READQ TD

    QUEUE ('queue-name')

    INTO (queue-record)

    [LENGTH (queue-record-length)]

END-EXEC.

DELETEQ TD – used to delete the TDQ

EXEC CICS DELETEQ TD

    QUEUE ('queue-name')

END-EXEC