Sunday, 4 August 2013

JCL Procedure | Instream Procedures | Catalog Procedure.

INSTREAM PROCEDURE
JCL Procedure

In today's tutorial, you will learn to code the JCL procedure. JCL procedure is categorized into two categories i.e. Instream Procedure or Catalog procedures. Also, you will learn various IBM supplied complex catalog procedures that let you interface easily with software products like compilers, CICS, and DB2, and you’ll use them all the time. So, let's start with the tutorial.

What is JCL Procedure?


A JCL procedure (or just procedure) is a pre-written segment of code consisting of one or more job steps that you can include in a job stream. By using procedures, the amount of JCL coding you have to do is reduced, resulting in fewer coding errors and greater productivity. Although you can code a procedure directly in a single job stream, you’re more likely to invoke cataloged procedures that are available throughout an installation.

The syntax for invoking a JCL procedure 


EXEC [PROC=]procedure-name

Note: The procedure-name Identifies the procedure to be called and executed. For cataloged procedures, it’s the member name of the procedure. For instream procedures, it’s the name on the PROC statement that begins the procedure.

For example, in the middle of the below code, you can see the JCL statements that make up a cataloged procedure named XMP3000. This procedure consists of two job steps that execute the programs XMP3000 and allocate seven different data sets.

//RC01TN  JOB (99992),'MAINFRAME',NOTIFY=MMTX01
//STEP01  EXEC XMP3000
//

The procedure is broadly categorized into two categories i.e. CATALOG PROCEDURE and INSTREAM PROCEDURE.

What is CATALOG PROCEDURE?


A cataloged procedure is a series of JCL statements that are stored in a partitioned data set and may be invoked by any job on the system (i.e. z/OS system). Whenever you invoke a cataloged procedure, the system looks for it in the system procedure library, SYS1.PROCLIB, unless you specify the library.

Although the PROC statement can be coded as the first statement in a cataloged procedure, it’s not required.

CATALOGED PROCEDURE in JCL Example:


The cataloged JCL procedure named EMP3000 that is invoked

 

//EMP3000 PROC  <--: name="" proc="" strong="">
//EMP3010 EXEC PGM=EMP3000
//SYSOUT  DD   SYSOUT=*
//EMPMAST DD   DSNAME=RCA2.PAYROL.MAST.FILE,DISP=SHR
//EMPSEL  DD   DSNAME=&&EMPSEL,DISP=(NEW,PASS,DELETE),
//         UNIT=SYSDA,SPACE=(CYL,(120,10))
//*
//SAL3030 EXEC PGM=SAL3030
//SYSOUT  DD   SYSOUT=*
//INVMAST DD   DSNAME=&&SALREP,DISP=(OLD,DELETE,DELETE)
//INVSLST DD   SYSOUT=*

A job that invokes a cataloged procedure 

//RC01TN  JOB (99992),'MAINFRAME',NOTIFY=MMTX01
//STEP01  EXEC EMP3000
//

What is INSTREAM PROCEDURE?


An instream procedure consists of a PROC statement, any number of procedure steps, and a PEND statement. Then, you place the instream procedure near the beginning of your job stream, before any EXEC statement that refers to it. In contrast to a cataloged procedure, an instream procedure is available only to the job that contains it.

A name is always required on the PROC statement for an instream procedure. You can also specify a name on the PEND statement, but it’s optional.

JCL statements falling between the PROC and PEND statements are not executed when first encountered. Instead, they’re scanned for errors and retained as a temporary procedure.

Any JCL statements after the PEND statement are recognized as normal statements and are executed.

An instream procedure should be placed near the beginning of a job stream, before any EXEC statement that refers to it. The maximum number of instream procedures you can code in any job is 15. 

Important Point: Before cataloging a procedure in a procedure library, it’s usually a good idea to test the JCL code it contains, and the easiest way to do that is with an instream procedure.

INSTREAM PROCEDURE in JCL Example:


A job that instream data in JCL 


//RC01TN  JOB (99992),'MAINFRAME',NOTIFY=MMTX01
//TAX4000 PROC 
//TAX3010 EXEC PGM=TAX3000
//SYSOUT  DD   SYSOUT=*
//TAXMAST DD   DSNAME=RCA2.TAX.DED.FILE,DISP=SHR
//TAXSAL  DD   DSNAME=&&TAXDED,DISP=(NEW,PASS,DELETE),
//         UNIT=SYSDA,SPACE=(CYL,(120,10))
// PEND
//EMP3030 EXEC PGM=TAX4000 <--:invoke instream="" procedure.="" strong="">
//*

SYMBOLIC PARAMETER in INSTREAM DATA.


To code a symbolic parameter in a procedure, you use a name that starts with an ampersand (&). The name can be any meaningful name you want as long as it isn’t a keyword parameter on an EXEC statement. For example, &TIME or &REGION would not be valid names because both are keyword parameters on an EXEC statement. But &SPACE and &CLASS are acceptable names.

You can use the same symbolic parameter in a procedure as many times as you like. For example, you can use a symbolic parameter called &CLASS as the value for the SYSOUT parameter in all of the SYSOUT DD statements in a procedure. That way, you can be sure that all SYSOUT data sets are processed using the same output class. If you need to assign different classes to the SYSOUT data sets, however, you have to use more than one symbolic parameter.

The syntax for assigning values to symbolic parameters in a procedure 
//[name] EXEC [PROC=]procedure-name,symbolic-parameter=value

Note:- A one- to seven-character name that is referenced by the procedure. The name can’t be a keyword parameter used by the EXEC statement.

A procedure that uses symbolic parameters in JCL.

//EMP3000 PROC  <--: name="" proc="" strong="">
//EMP3010 EXEC PGM=EMP3000
//SYSOUT  DD   SYSOUT=*
//EMPMAST DD   DSNAME=&HLQ..PAYROL.MAST.FILE,DISP=SHR
//EMPSEL  DD   DSNAME=&&EMPSEL,DISP=(NEW,PASS,DELETE),
//        UNIT=SYSDA,SPACE=(CYL,(&SPACE))
//*
//SAL3030 EXEC PGM=SAL3030
//SYSOUT  DD  SYSOUT=*
//INVMAST DD  DSNAME=&&SALREP,DISP=(OLD,DELETE,DELETE)
//INVSLST DD  SYSOUT=*

The invoking EXEC statement (jcl proc override examples)

//STEPA01  EXEC INV3000,CLASS=M,HLQ=RCA2,SPACE='10,10'

Rules for coding symbolic parameters in JCL statements 

  1. You can use the same symbolic parameter in a procedure as many times as you wish.
  2. Symbolic parameters can be mixed with text to form a final parameter value.
  3. If you want text to appear immediately after a symbolic parameter, you must code a period (.) as a delimiter between the symbolic parameter name and the text that follows it.
  4. If you want a period to appear immediately after a symbolic parameter, you have to code two periods in a row. The first one acts as a delimiter marking the end of the symbolic parameter and the second one becomes part of the JCL statement.
  5. To nullify the value of a symbolic parameter, you code the symbolic parameter’s name followed by an equals sign without a value. 

SET Parameter in JCL with example.


The SET statement is another way to assign values to symbolic parameters. In contrast to a PROC statement that assigns default values or a procedure-invoking EXEC statement that provides runtime values, the SET statement lets you set the values of symbolic parameters at any point or time within your JCL. Be aware, however, that SET values are overridden by any values that are assigned in subsequent PROC or EXEC statements in the job. 

The syntax for the SET statement 


//[name]  SET symbolic-parameter=value[,symbolic-parameter=value]…

Note - The name of a symbolic parameter you want to assign a value to.

//EMP3000 PROC  <--: name="" proc="" strong="">
//EMP3010 EXEC PGM=EMP3000
//SYSOUT  DD   SYSOUT=*
//EMPMAST DD   DSNAME=&HLQ..PAYROL.MAST.FILE,DISP=SHR
//EMPSEL  DD   DSNAME=&&EMPSEL,DISP=(NEW,PASS,DELETE),
//        UNIT=SYSDA,SPACE=(CYL,(&SPACE))
//*
//SAL3030 EXEC PGM=SAL3030
//SYSOUT  DD  SYSOUT=*
//INVMAST DD  DSNAME=&&SALREP,DISP=(OLD,DELETE,DELETE)
//INVSLST DD  SYSOUT=*

The invoking EXEC statement (jcl proc override examples)

//RC01TN  JOB (99992),'MAINFRAME',NOTIFY=MMTX01
//      SET SPACE='10,5'
//      SET HLQ=RCA2
//STEPA01  EXEC INV3000


Summary.


As you code JCL, you’ll discover that there are many job steps…and series of job steps…that are used over and over in an installation, often by different programmers. That’s why OS/390 provides for procedures that can be stored in libraries and made available to any programmer on the system. With this facility, you can usually code just a few JCL statements to execute procedures that contain dozens or even hundreds of JCL statements. In fact, IBM supplies complex procedures that let you interface easily with software products like compilers, CICS, and DB2, and you’ll use them all the time. In addition, in most shops, you’ll create and use procedures that are specific to your installation.
Created with Artisteer

No comments:

Post a Comment