Condition Codes

Introduction to Condition Codes

Condition codes (also called return codes) are numeric values that programs set when they finish execution. These codes indicate the outcome of the program's execution and can be used by JCL to make decisions about subsequent steps.

By checking condition codes, JCL can implement conditional logic, allowing jobs to adapt based on the success or failure of previous steps. This tutorial explores how condition codes work and how they're used within JCL.

Understanding Condition Codes

Condition codes are integer values that can range from 0 to 4095, although in practice most programs use a more limited range (typically 0-16). Each program defines its own condition codes, but there are commonly accepted conventions:

When a step completes, JCL captures its condition code and can use it to determine whether subsequent steps should execute, and how they should execute. This is the foundation of conditional processing in JCL.

How Programs Set Condition Codes

Viewing Condition Codes in Job Output

When a job runs, the condition code for each step is recorded in the job log. In most mainframe environments, you can see these codes in the job output by looking at the messages produced by the system:

1
2
3
IEF142I USERA JOB12345 STEP1 - STEP WAS EXECUTED - COND CODE 0000
IEF142I USERA JOB12345 STEP2 - STEP WAS EXECUTED - COND CODE 0004
IEF142I USERA JOB12345 STEP3 - STEP WAS EXECUTED - COND CODE 0008

In this example, STEP1 completed with condition code 0 (success), STEP2 with code 4 (warning), and STEP3 with code 8 (error). Understanding these codes helps you diagnose issues and understand the flow of your job.

Using Condition Codes in JCL

JCL provides several ways to use condition codes for conditional processing. The most common methods are:

1
2
//STEP2 EXEC PGM=PROGRAM2,COND=(4,LT)        // Run only if all previous steps had CC < 4
//STEP3 EXEC PGM=PROGRAM3,COND=(8,LE,STEP1)   // Run only if STEP1 had CC <= 8

1
2
3
4
5
6
7
//STEP1   EXEC PGM=PROGRAM1
//*
//         IF (STEP1.RC = 0) THEN
//STEP2A    EXEC PGM=PROGRAM2A
//         ELSE
//STEP2B    EXEC PGM=PROGRAM2B
//         ENDIF

1
2
3
4
5
6
//STEP1  EXEC PGM=PROGRAM1
//STEP2  EXEC PGM=PROGRAM2
//*
//       IF (STEP1.RC <= 4 & STEP2.RC = 0) THEN
//STEP3    EXEC PGM=PROGRAM3
//       ENDIF

Practical Example: Using Condition Codes

This practical example demonstrates how condition codes control the flow of a multi-step job:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
//JOBNAME  JOB (ACCT),'CONDITION CODE DEMO',CLASS=A
//*
//* STEP 1: COMPILE A COBOL PROGRAM
//*
//COMPILE  EXEC PGM=IKFCBL00,REGION=4M
//SYSIN    DD DSN=SOURCE.COBOL(PROGRAM1),DISP=SHR
//SYSLIN   DD DSN=&&OBJSET,DISP=(NEW,PASS),
//            UNIT=SYSDA,SPACE=(TRK,(5,5))
//SYSPRINT DD SYSOUT=*
//*
//* STEP 2: IF COMPILE WAS SUCCESSFUL (RC <= 4), LINK-EDIT THE PROGRAM
//*
//         IF (COMPILE.RC <= 4) THEN
//LKED      EXEC PGM=IEWL,REGION=4M
//SYSLIN    DD DSN=&&OBJSET,DISP=(OLD,DELETE)
//SYSLMOD   DD DSN=LOADLIB(PROGRAM1),DISP=SHR
//SYSPRINT  DD SYSOUT=*
//*
//* STEP 3: IF LINK-EDIT WAS SUCCESSFUL (RC = 0), RUN THE PROGRAM
//*
//          IF (LKED.RC = 0) THEN
//RUN        EXEC PGM=PROGRAM1
//STEPLIB   DD DSN=LOADLIB,DISP=SHR
//INPUT     DD DSN=INPUT.DATA,DISP=SHR
//OUTPUT    DD DSN=OUTPUT.DATA,DISP=(NEW,CATLG),
//             UNIT=SYSDA,SPACE=(TRK,(10,5))
//SYSOUT    DD SYSOUT=*
//          ENDIF
//         ENDIF
//*
//* STEP 4: ALWAYS RUN REGARDLESS OF PREVIOUS STEPS (CLEAN UP)
//*
//CLEANUP  EXEC PGM=IEFBR14
//TEMP     DD DSN=&&OBJSET,DISP=(MOD,DELETE),
//            UNIT=SYSDA

Best Practices for Condition Codes