Les procédures JCL sont un ensemble d’instructions à l’intérieur d’un JCL regroupées pour exécuter une fonction particulière.
Généralement, la partie fixe du JCL est codée dans une procédure. La partie variable du Job est codée dans le JCL.
Vous pouvez utiliser une procédure pour réaliser l’exécution parallèle d’un programme à l’aide de plusieurs fichiers d’entrée.
Un JCL peut être créé pour chaque fichier d’entrée, et une seule procédure peut être appelée simultanément en passant le nom du fichier d’entrée comme paramètre symbolique.
Syntaxe
Voici la syntaxe de base d’une définition de procédure JCL :
//*
//Nom-Step EXEC procedure nom Le contenu de la procédure est contenu dans le JCL pour une procédure instream.
Le contenu est conservé dans un membre différent de la bibliothèque de base pour une procédure cataloguée.
Ce chapitre va expliquer deux types de procédures disponibles en JCL et enfin nous verrons comment imbriquer différentes procédures.
Procédure Instream
Lorsque la procédure est codée dans le même membre JCL, elle est appelée procédure Instream.
Il doit commencer par une instruction PROC et se terminer par une instruction PEND.
//EXINST JOB 1,CLASS=6,MSGCLASS=Y,NOTIFY=&SYSUID //* //INSTPROC PROC//*DEBUT DE LA PROCEDURE //PROC1 EXEC PGM=SORT //SORTIN DD DSN=&DSNAME,DISP=SHR //SORTOUT DD SYSOUT=*MYINCL //SYSOUT DD SYSOUT=* //SYSIN DD DSN=&DATAC LRECL=80 // PEND//*FIN DE LA PROCEDURE //* //STEP001 EXEC INSTPROC,DSNME=MYDATA.URMI.INPUT1, // DATAC=MYDATA.BASE.LIB1(DATA1) //* //STEP002 EXEC INSTPROC,DSNME=MYDATA.URMI.INPUT2 // DATAC=MYDATA.BASE.LIB1(DATA1) //*
Dans l’exemple ci-dessus, la procédure INSTPROC est appelée dans STEP1 et STEP2 à l’aide de fichiers d’entrée différents.
Les paramètres DSNAME et DATAC peuvent être codés avec des valeurs différentes lors de l’appel de la procédure et ceux-ci sont appelés comme paramètres symboliques.
Les différentes entrées du JCL telles que les noms de fichiers, les cartes de données, les valeurs PARM, etc., sont transmises en tant que paramètres symboliques aux procédures.
Lors du codage des paramètres symboliques, n’utilisez pas KEYWORDS, PARAMETERS ou SUB-PARAMETERS comme noms symboliques.
Exemple : N’utilisez pas TIME=&TIME mais oui, vous pouvez utiliser TIME=&TM et cela est supposé être une bonne façon de coder les symboles.
Les paramètres symboliques définis par l’utilisateur sont appelés symboles JCL.
Il existe certains symboles appelés symboles système, qui sont utilisés pour les exécutions de tâches de connexion.
Le seul symbole système utilisé dans les travaux par lots par les utilisateurs normaux est &SYSUID et il est utilisé dans le paramètre NOTIFY de l’instruction JOB.
Procédure cataloguée
Lorsque la procédure est séparée du JCL et codée dans un magasin de données différent, elle est appelée procédure cataloguée. Une instruction PROC n’est pas obligatoire pour être codée dans une procédure cataloguée. Voici un exemple de JCL où il appelle la procédure CATLPROC :
//JCLINST JOB 1,CLASS=6,MSGCLASS=Y,NOTIFY=&SYSUID
//*
//STEP EXEC CATLPROC,PROG=CATPRC1,DSNME=MYDATA.URMI.INPUT
// DATAC=MYDATA.BASE.LIB1(DATA1)Ici, la procédure CATLPROC est cataloguée dans MYCOBOL.BASE.LIB1.
PROG, DATAC et DSNAME sont passés comme paramètres symboliques à la procédure CATLPROC.
//CATLPROC PROC PROG=,BASELB=MYCOBOL.BASE.LIB1
//*
//PROC1 EXEC PGM=&PROG
//STEPLIB DD DSN=&BASELB,DISP=SHR
//IN1 DD DSN=&DSNAME,DISP=SHR
//OUT1 DD SYSOUT=*
//SYSOUT DD SYSOUT=*
//SYSIN DD DSN=&DATAC
//*Au sein de la procédure, les paramètres symboliques PROG et BASELB sont codés.
Veuillez noter que le paramètre PROG dans la procédure est remplacé par la valeur dans le JCL et que PGM prend donc la valeur CATPRC1 lors de l’exécution.
Procédures imbriquées
L’appel d’une procédure à partir d’une procédure est appelé une procédure imbriquée.
Les procédures peuvent être imbriquées jusqu’à 15 niveaux. L’imbrication peut être entièrement instream ou cataloguée.
On ne peut pas coder une procédure instream dans une procédure cataloguée.
//SJCLINST JOB 1,CLASS=6,MSGCLASS=Y,NOTIFY=&SYSUID //* //SETNOM SET DSNM1=INPUT1,DSNM2=OUTPUT1 //INSTPRC1 PROC//* DEBUT DE LA PROCEDURE 1 //STEP001 EXEC PGM=SORT,DISP=SHR //SORTIN DD DSN=&DSNM1,DISP=SHR //SORTOUT DD DSN=&DSNM2,DISP=(,PASS) //SYSOUT DD SYSOUT=* //SYSIN DD DSN=&DATAC //* //STEP002 EXEC PROC=INSTPRC2,DSNM2=MYDATA.URMI.OUTPUT2 // PEND//* FIN DE LA PROCEDURE 1 //* //INSTPRC2 PROC//* DEBUT DE LA PROCEDURE 2 //STEP001 EXEC PGM=SORT //SORTIN DD DSN=*.INSTPRC1.STEP1.SORTOUT //SORTOUT DD DSN=&DSNM2,DISP=OLD //SYSOUT DD SYSOUT=* //SYSIN DD DSN=&DATAC // PEND//* FIN DE LA PROCEDURE 2 //* //JSTEP1 EXEC INSTPRC1,DSNM1=MYDATA.URMI.INPUT1, // DATAC=MYDATA.BASE.LIB1(DATA1) //*
Dans l’exemple ci-dessus, le JCL appelle la procédure INSTPRC1 dans JSTEP1 et la procédure INSTPRC2 est appelée dans la procédure INSTPRC1.
Ici, la sortie de INSTPRC1 (SORTOUT) est transmise comme entrée (SORTIN) à INSTPRC2.
Une instruction SET est utilisée pour définir les symboles couramment utilisés dans les étapes ou les procédures de job.
Il initialise les valeurs précédentes dans les noms symboliques.
Il doit être défini avant la première utilisation des noms symboliques dans le JCL.
Jetons un coup d’œil à la description ci-dessous pour en savoir un peu plus sur le programme ci-dessus :
- Le paramètre SET initialise DSNM1=INPUT1 et DSNM2=OUTPUT1.
- Lorsque INSTPRC1 est appelé dans JSTEP1 de JCL, DSNM1=MYDATA.URMI.INPUT1 et DSNM2=OUTPUT1., c’est-à-dire que la valeur initialisée dans l’instruction SET est réinitialisée avec la valeur définie dans l’une des étapes/procédures de travail.
- Lorsque INSTPRC2 est appelé dans STEP2 de INSTPRC1, DSNM1=MYDATA.URMI.INPUT1 et DSNM2=MYDATA.URMI.OUTPUT2.