PROCs, Symbols and Overrides

In the real world of mainframe execution, job control scripts can get massive. Imagine having a fifty-line script that compiles, binds, and executes a program, and you need to run it for twenty different datasets. Writing out a thousand lines of JCL would be an unmaintainable nightmare.

To solve this, JCL uses Procedures (PROCs). A PROC is a pre-written, reusable segment of JCL that can be invoked repeatedly from different calling jobs using a simple EXEC statement. You can think of a PROC as a function or method in a standard programming language, but for job control.

Symbolic Parameters

When you call a PROC, you often need to change a few details—like what dataset it reads from. JCL accomplishes this through symbolic parameters. A symbolic parameter is a placeholder name preceded by an ampersand (&).

Here is the whole mechanism in two short members. This is real JCL as it would be catalogued on z/OS; it cannot run here, because nothing off the mainframe reads it.

//* ---- the PROC, catalogued once and reused ----
//MYPROC   PROC INFILE='TEST.DATA.SET'
//PSTEP1   EXEC PGM=COBPROG
//STEPLIB  DD DSN=PROD.LOADLIB,DISP=SHR
//INFILE   DD DSN=&INFILE,DISP=SHR
//SYSOUT   DD SYSOUT=*
//         PEND
//*
//* ---- a job that calls it, overriding the symbol ----
//MYJOB    JOB (ACCT01),'NIGHTLY',CLASS=A
//STEP1    EXEC PROC=MYPROC,INFILE='PROD.DATA.SET'

The PROC line declares the symbol and gives it a default — TEST.DATA.SET. That default is the safety net: run the PROC with no override and it reads test data, not production. The calling job supplies INFILE='PROD.DATA.SET', which replaces &INFILE everywhere it appears before the step runs.

This is where the classic production incident comes from. Misspell the symbol on the EXEC line — INFIL= instead of INFILE= — and JCL does not stop. The override simply never matches, the default stands, and the nightly job quietly reads the test dataset. Nothing errors, the return code is zero, and the numbers are wrong. The habit that saves you is making the default obviously non-production, exactly as above, so a failed override looks wrong immediately instead of plausibly.

Running locally with GnuCOBOL there is no JCL, but the same shape exists: pass the value as an environment variable and read it with ACCEPT ... FROM ENVIRONMENT.

       IDENTIFICATION DIVISION.
       PROGRAM-ID. SYMBOL-DEMO.
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 INFILE-PARM PIC X(20).
       PROCEDURE DIVISION.
           ACCEPT INFILE-PARM FROM ENVIRONMENT "MY_PARM".
           IF INFILE-PARM = SPACES
               DISPLAY "No parameter passed!"
           ELSE
               DISPLAY "Processing dataset: " INFILE-PARM
           END-IF.
           STOP RUN.

No parameter passed!

DD Overrides

Sometimes, a PROC is 99% perfect, but you need to change one specific file definition for a single run without altering the reusable PROC itself. You can achieve this using a DD override.

By supplying a DD statement in your calling job that matches the stepname.ddname of the PROC, the mainframe will substitute your custom definition over the PROC’s default. Like symbolic parameters, this allows flexible execution of a single compiled program against many different data sources.

What happens if you use ACCEPT FROM ENVIRONMENT to simulate a numeric variable passing, and do arithmetic on it? Predict the output of this snippet. (Assume VAL is mapped to the string “05”).

       IDENTIFICATION DIVISION.
       PROGRAM-ID. PREDICT-DEMO.
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 INPUT-VAL PIC 99.
       01 RESULT    PIC 99.
       PROCEDURE DIVISION.
           ACCEPT INPUT-VAL FROM ENVIRONMENT "VAL".
           IF INPUT-VAL = 00 
               MOVE 05 TO INPUT-VAL
           END-IF.
           COMPUTE RESULT = INPUT-VAL * 3.
           DISPLAY RESULT.
           STOP RUN.

15

Because VAL was unassigned in this snippet’s simulated environment, ACCEPT pulls in blanks or zeroes (depending on compiler). The IF block catches the 00 value and assigns 05. 05 * 3 gives 15. This demonstrates how programs can provide fallback defaults when symbolic parameters or overrides are omitted.