9. LES PROCEDURES - La Communauté du Cobol

Une procédure est équivalent a un sous-programme de JCL que l’ont peut appeler par une carte EXEC. Elle s’utilise lors ce que noue avons dans le système un ensemble de carte de JCL, de Bibliothèque … suffisamment standard pour pouvoir être utilisé assez fréquemment dans des travaux différents. C’est le cas par exemple des compilations, des lancements de Logiciels transactionnels des SGBD (système de gestion de donnée).

9.1. Contenu d’une procédure

Une procédure peut contenir des cartes EXEC :

Une procédure ne peut appeler une autre procédure que depuis MVS/ESA SP4 (jusqu’à 15 niveaux)
Elle peut contenir des carte DD, qui représente des fichiers utilisés par la procédure, ainsi que des cartes IF,ELSE, END-IF
Elle ne peut contenir des Carte JOB, DDDATA, DD*
Elle peut contenir la carte PROC, la carte PEND est normalement réservée aux procédures IN STREAM, on peut cependant la coder dans une procédure cataloguée depuis MVS/ESA SP4.

9.2. Description schématique d’une procédure

//MYJOB JOB //STEP1 EXEC PROCD //FICH DD DSB= …. //STEP2 EXEC PGM=PROGRAM1

recherche de la procédure catalogué ==>

procédure
//PROCD PROC //STEPA EXEC PGM=PGM1 //FICHENT1 DD DSN= … //FICHENT2 DD DSN= … //SYSOUT DD SYSOUT=* // PEND

//MYJOB       JOB
//STEPA       EXEC PGM=PGM1
//FICHENT1 DD     DSN= …
//FICHENT2 DD     DSN= …
//SYSOUT     DD     SYSOUT=*
//FICH        DD     DSB= ….
//STEP2       EXEC PGM=PROGRAM1

PROCD : marque le début de la procédure.
PEND : marque la fin de la procédure.

9.3. Types de procédures

IN STEREAM : utiliser lors de la création de la procédure. Contenue dans la carte JOB qui l’appelle. Ceci n’ayant d’intérêt que pendant la phase de test de la procédure. La procédure est délimitée par les cartes PROC et PEND.

CATALOGUED : il s’agit de procédure d’enregistrement définitivement la nouvelle procédure dans une ou plusieurs bibliothèques disponible pour tout le monde. La bibliothèque standard est la SYS1.PROCLIB.

Syntaxe :
//name JCLLIB ORDER=(nom_de_bibliotheque, (nom_de_bibliotheque),….)

9.4. Création d’une procédure

La création ce fait au moyen d’un éditeur (exemple SPF) et consiste soit à créer et à tester une procédure IN STEREAM, puis à l’ajouter dans un membre de la bibliothèque des procédures, soit à créer directement le membre dans la bibliothèque puis à écrire directement le membre dans la bibliothèque puis écrire le JCL d’appel.

9.4.1. Procédure IN STERN

Le nom de la carte PROC détermine le nom de la procédure. On peut ensuite appeler cette procédure aussi souvent que nécessaire dans le même JOB.

Exemple :

//MYJOB    JOB …
//*_______________________________ PROCEDURE DEBUT
//MYPROC   PROC
//PROC1    EXEC PGM=PROGRA1
//STSOUT   DD   SYSOUT=*
//FICENTR1 DD   DSN=FIC1.ENTRE …
//FICSORT2 DD   DSN=FIC1.SORTI …
//PROC2    EXEC PGM=PROGRA2
//SYSOUT   DD   SYSOUT=*
// …
//         PEND
//*________________________________PROCEDURE FIN
//STEP1    EXEC PGM=PROGRAM3
// …

9.4.2. Procédure cataloguée

Contenu de la procédure cataloguée par exemple dans SYS1.PROCLIB :

//MYPROC  PROC
//PROC1   EXEC PGM=PGM1
//SYSOUT  DD   SYSOUT=*
//FICENTR DD   DSN=FIC.ENTRE1 …
//FICSOR  DD   DSN=FIC.SORTI1 …
//PROC2   EXEC PGM=PGM2
//SYSOUT  DD   SYSOUT=*
// …

Le nom de la procédure est donné par le nom du membre qui la contient, et non pas par le nom de la carte PROC. Si la carte PROC ne contient pas de paramètre, elle est facultative, ce qui est le cas de cet exemple.

Appel de la procédure :
//MYJOB JOB …
//STEP1 EXEC MYPROC
// …

9.5. Utilisation d’une procédure

Une procédure est un JCL standardisé, elle ne peut prendre en compte à priori les cas particuliers de tous les utilisateurs. Elle doit donc être donc paramétrable. On sera amené à apporter dynamiquement des modifications au moment de l’appel :
– Modification des cartes EXEC.
– Modification des cartes DD.
– Définition de variables avec valeurs par défaut ou imposées au moment de l’appel.

Lors de l’appel d’une procédure, l’interpréteur recherchera la procédure dans la bibliothèque système ou utilisateur (carte JCLLIB), la fusionnera avec le JCL d’appel et procédera aux modifications demandées par l’appel. Dans le compte rendu d’exécution, on pourra visualiser le résultat de cette fusion dans la mesure où l’on aura codé MSGLEVEL=(1, … )dans la carte JOB.
Distinction entre les différents types de cartes dans la partie JCL IMAGE du compte rendu d’exécution du JOB :

Hors procédure :
// ==> Carte du JCL d’origine
dans une procédure cataloguée :
XX      ==> Carte de procédure non modifiée.
X/        ==> Carte de procédure modifiée.
//          ==> carte ajoutée à la procédure.
Dans une procédure IN STREAM :
++      ==> carte de procédure non modifiée
+/       ==>   carte de procédure modifiée
//         ==> carte ajoutée à la procédure

9.6. Modification des cartes EXEC

Pour l’ensemble des cartes EXEC de la procédure, les modifications se font dans la carte EXEC d’appel. On peut ajouter, modifier ou supprimer des paramètres (sauf le nom du PGM à exécuter).

La syntaxe générale est la suivante :
Paramètre.(PROCSTEP)=Valeur

PROCSTEP est le nom de l’étape de procédure dans la quelle on veut agir. S’il est omis, le paramètre sera valable pour toutes les étapes de la procédure.

Exemple :
//STEP1 EXEC MYPROC,COD.ET1=O,NE),
//      TIME.ET2=(,5)

Règles :
Bien que l’on puisse imbriquer jusqu’à 15 niveau de procédure depuis MVS/ESA SP4, on ne peut pas paramétrer que le premier niveau.

Les paramètres à modifier doivent respecter l’ordre suivant :
1. D’abord les paramètres s’appliquant à toutes les étapes
2. Puis ceux qui modifient une étape particulière, dans l’ordre des étapes.
Ajout : on code le paramètre, l’étape, la valeur. L’interpréteur ajoute ce paramètre s’il n’existe pas déjà dans l’étape.
Modification : On code le paramètre, l’étape, la valeur. L’interpréteur attribue la nouvelle valeur au paramètre s’il existe déjà, sinon il procède à un ajout.
Suppression : On code le paramètre, l’étape, mais pas la valeur. Si ce paramètre existe dans l’étape, l’interpréteur le supprime, sinon il ne fait rien.

Exemple :
Soit la procédure suivante :
//S1      EXEC     PGM=MYPROG,PARM=’TOTO’…
//S2      EXEC     PGM=PROG2,TIME=1.. et l’appel de la procédure :
//STEP1   EXEC     MYPROC,COND.S1=(0,NE), //        PARM.S1=,TIME.S2=(,5)… Qui apporte les modifications suivantes :
    • Ajout de COND dans l’étape S1
    • Suppression de PARM dans l’étape S1.
    • Modification de TIME dans S2.
X/S1      EXEC     PGM=MYPROG,COND=(0,NE)…
X/S2      EXEC     PGM=PROG2,TIME=(,5)

9.7. Modification des cartes DD

Se font par l’intermédiaire de cartes DD code dans le JCL d’appel. On peut ajouter ou supprimer des cartes DD.

Syntaxe générale :
//PROCSTEP.DDNAME DD

procstep est le nom d’étape de la procédure que l’on veut modifier.

Règles : bien que l’on imbrique 15 niveau de procédure depuis MVS/ESA SP4, on ne peut paramétrer que le premier niveau.
Bien que l’on puisse imbriquer jusqu’à 15 niveau de procédure depuis MVS/ESA SP4, on ne peut paramétrer que le premier niveau.

Les cartes DD doivent respecter un certain ordre :
- On doit aller dans l’ordre des étapes de la procédure,
- Pour une étape donnée, on doit d’abord trouver les cartes DD qui modifient des cartes DD présentes dans la procédure, puis les cartes DD ajoutées à la procédure.
Si on omet le nom de l’étape devant le ddname, la carte sera ajoutée à la dernière étape que l’on a nommée (la première, si aucune étape n’est nommée).
Ajout : si la carte codée dans le JCL d’appel n’existe pas, elle est ajoutée dans l’étape concernée de la procédure. Si d’autres cartes DD de cette étape ont été modifiées, elles doivent précéder les cartes ajoutées.
Modification : si la carte codée dans le JCL d’appel existe dans la procédure, ses paramètres sont modifiés en fonction des règles suivantes :
- Si un paramètre codé n’existait pas, il est ajouté.
- Si un paramètre existe existait déjà, il est modifié.
- Si un paramètre est codé sans valeur, il est supprimé.
- Si un paramètre existant n’est pas recodé, il est conservé.
Suppression de tous les paramètres sauf le DCB : On code la carte avec le paramètre DUMMY

Exemple :
//S1     EXEC PGM=PROG1
//SYSOUT DD   SYSOUT=*
//FICENT DD   DSN=I00020.FICENT,DISP=SHR
//S2     EXEC PGM=PROGRAM2
//SYSOUT DD   SYSOUT=*
//IMPRIM DD   SYSOUT=,copies=2

… et appel de la procedure

//STEP1 EXEC MYPROC //S1.FICENT DD DISP=OLD //S1.FICSOR DD DSN= I00020.FICENT,DISP=SHR // UNIT=SYSDA,SPACE=(TRK,10), // DCB=BLKSIZE=120 //S2.IMPRIM DD SYSOUT=A,OUTLIM=1000,COPIES= modif Ajout suppression

Entraîne les modifications suivantes (extrait du JCL image) :

//SEP1 EXEC MYPROC XXS1 EXEC PGM=PROG1 XXSYSOUT DD SYSOUT= X/S1.FICENT DD DSN= I00020.FICENT,DISP=OLD //S1.FICSOR DD DSN= I00020.FICENT,DISP=SHR // UNIT=SYSDA,SPACE=(TRK,10), // DCB=BLKSIZE=120 XXS2 EXEC PGM=PROGRAM2 XXSYSOUT DD SYSOUT=* X/S2.IMPRIM DD SYSOUT=A,OUTLIM=1000
Modif Ajout

Cas particulier des fichiers concaténés :
Il doit y avoir autant de cartes DD dans le JCL d’appel que dans l’étape de la procédure. Les cartes doivent apparaître dans le même ordre.
Pour modifier un paramètre, on le code dans la carte DD correspondante.
Si aucun paramètre ne doit être changé dans une carte, on code cette carte sans paramètre.

Exemples :
Dans la procédure PROCA :

//SX     EXEC …
//DD1    DD   DNS=LOAD.LOAD1,DISP=SHR
//       DD   DNS=LOAD.LOAD3,DISP=SHR
//       DD   DNS=LOAD.LOAD2,DISP=SHR

1- Dans le JCL d’appel de la procédure :

//STEPA  EXEC PROCA
//SX.DD1 DD   DSN=I0004.PROJ1,DISP=SHR
            On trouvera dans le JCL image :
X/SX.DD1 DD   DSN=I0004.PROJ1,DISP=SHR
X/       DD   DNS=LOAD.LOAD3,DISP=SHR
X/       DD   DNS=LOAD.LOAD2,DISP=SHR

2- Dans le JCL d’appel de la procédure :

//STEPA  EXEC PROCA
//SX.DD1 DD   DSN=I0004.PROJ1,DISP=SHR
//         DD   DSN=I0004.PROJ2,DISP=SHR
            On trouve dans le JCL image
X/SXDD1  DD   DSN=I0004.PROJ1,DISP=SHR
//         DD   DSN=I0004.PROJ2,DISP=SHR
//         DD   DSN=LOAD.LOAD2,DISP=SHR

3- Dans le JCL d’appel de la procédure :

//STEPA  EXEC PROCA
//SXDD1  DD DSN=I0004.PROJ1,DISP=SHR
//         DD DSN=I0004.PROJ2,DISP=SHR
            On trouve dans le JCL image
//SXDD1  DD DSN=I0004.PROJ1,DISP=SHR
//         DD DNS=LOAD.LOAD3,DISP=SHR
//         DD DSN=I0004.PROJ2,DISP=SHR

9.8. Définition de variables symboliques

9.8.1. Codage des variables

Dans une procédure, il est possible de remplacer les valeurs fixes attribuées aux paramètres par des noms de variables symboliques.
Cela augmente la souplesse d’utilisation des procédures que l’on peut alors modifier simplement en changeant les valeurs attribuées aux variables symboliques.

Une variable s’écrit sous la forme :

Paramètre =&nom

Le & permet à l’interpréteur de différencier les variables des valeurs attribuées aux paramètres ordinaires. Pour attribuer une valeur à une variable, on code son nom sans le &.Ceci peut être fait soit au niveau de la carte EXEC d’appel de la procédure, soit au niveau de la carte PROC (facultative pour les procédures cataloguées, obligatoire pour les procédures instream).
La valeur est alors attribuée à toutes les occurrences de la variable symbolique.

9.8.2. Variable par défaut

La carte PROC permet d’attribuer des valeurs par défaut aux variables de la procédure.

//MYPROC PROC 
 DUREE=’(,2)’,FIC=TOTO,DISPO=SHR,VERS=M0000,
//  
           APPLI=COMM,AA=95,QQQ=312
//STEP1  EXEC PGM=PROGRAM1,TIME=&DUREE,PARM=’&AA&QQQ’
//FIC1  
        DD DSN=&FIC,DISP=&DISPO
//FIC2  
        DD DSN=&APPLI..&VERS,
//  
           DISP=(NEW,ATALG,DELETE), …

Attention : Le double point précédant &VERS est indispensable pour séparer deux variables dans un nom de fichier.

9.8.3. Attribution dynamique de valeurs

On attribue les valeurs aux variables, dynamiquement lors de l’exécution de la procédure, en codant les paramètres au niveau de la carte EXEC d’appel. Les valeurs attribuées ainsi remplacent les valeurs codées sur la carte PROC.

Exemple :
Carte d’appel pour la procédure ci-dessus :

//STEP1 EXEC MYPROC,DUREE=1,FIC=’STOCK.DONNEE’,
//             APPLI=COMM,VERS=DU280571

L’interpréteur attribuera une durée de une minute et utilisera les fichiers STOCK.DONNEE et COMM.DU280571. :

//STEP1 EXEC PROG=PROGRAM1,TIME=1,PARM=’95312’
//FIC1  DD   DSN=STOCK.DONNEE,DISP=SHR
//FIC2  DD   DSN=COMM.DU280571,DISP=(NEW,CATLG,DELETE), ..

Remarque : L’attribution dynamique de valeurs à des variables peut également se faire directement dans le JCL, sans avoir à faire appel a une procédure, à l’aide de la carte SET.