Archives par mot-clé : EXEC

JCL – Paramètre en commun entre EXEC et JOB

Vous trouverez ci-dessous les paramètres en commun entre EXEC et JOB :

Paramètre de mot-cléDescription
ADDRSPPCADDRSPC codé dans l’instruction JOB remplace l’ADDRSPC codé dans l’instruction EXEC de toute étape de job.
TIMESi TIME est codé dans une instruction EXEC, il s’applique uniquement à cette étape de job.
S’il est spécifié à la fois dans les instructions JOB et EXEC, les deux seront en vigueur et peuvent provoquer une erreur de temporisation due à l’un ou l’autre.
Il n’est pas recommandé d’utiliser le paramètre TIME dans les instructions JOB et EXEC ensemble.
REGIONSi REGION est codé dans une instruction EXEC, il s’applique uniquement à cette étape de travail.

REGION codée dans l’instruction JOB remplace la REGION codée dans l’instruction EXEC de toute étape de job.
CONDUtilisé pour contrôler l’exécution de l’étape de travail en fonction du code de retour de l’étape précédente.

Si un paramètre COND est codé dans une instruction EXEC d’une étape de job, le paramètre COND de l’instruction JOB (s’il est présent) est ignoré.
Les différents tests pouvant être effectués à l’aide d’un paramètre COND sont expliqués dans Traitement conditionnel.

Exemple

Voici un exemple simple de script JCL avec les instructions JOB et EXEC :

//LCDCOBOL JOB 'TUTO',CLASS=6,MSGCLASS=X,REGION=8K,
//      NOTIFY=&SYSUID
//*
//STEP001 EXEC PGM=MYCOBOL,PARAM=CUST1000,
//      ACCT=(XXXX),REGION=8K,ADDRSPC=REAL,TIME=1440

JCL – Instruction EXEC

Chaque JCL peut être composé de plusieurs étapes de job.
Chaque étape de tâche peut exécuter directement un programme ou appeler une procédure qui, à son tour, exécute un ou plusieurs programmes (étapes de tâche).
L’instruction, qui contient les informations de programme/procédure d’étape de job, est l’instruction EXEC.

Le but de l’instruction EXEC est de fournir les informations requises pour le programme/la procédure exécuté(e) dans l’étape de job.
Les paramètres codés dans cette instruction peuvent transmettre des données au programme en cours d’exécution, peuvent remplacer certains paramètres de l’instruction JOB et peuvent transmettre des paramètres à la procédure si l’instruction EXEC appelle une procédure au lieu d’exécuter directement un programme.

Syntaxe

Voici la syntaxe de base d’une instruction JCL EXEC :

//Nom-step EXEC Position-param, Keyword-param 

Description

Voyons la description des termes utilisés dans la syntaxe de l’instruction EXEC ci-dessus.

Nom-step

Ceci identifie l’étape de travail dans le JCL. Il peut être de longueur 1 à 8 avec des caractères alphanumériques.

EXEC

Il s’agit du mot-clé pour l’identifier en tant qu’instruction EXEC.

POSITION-PARAM

Ce sont des paramètres positionnels, qui peuvent être de deux types :

Paramètre de positionDescription
PGMIl s’agit du nom du programme à exécuter dans l’étape de travail.
PROCIl s’agit du nom de la procédure à exécuter dans l’étape de travail. Nous en parlerons dans un chapitre séparé.
KEYWORD-PARAM

Voici les différents paramètres de mots-clés pour l’instruction EXEC. Vous pouvez utiliser un ou plusieurs paramètres en fonction des besoins et ils sont séparés par une virgule :

Paramètre de mot-cléDescription
PARMUtilisé pour fournir des données paramétrées au programme en cours d’exécution dans l’étape de job.
Ceci est un champ dépendant du programme et n’a pas de règles définies, sauf que la valeur PARM doit être incluse entre guillemets en cas de caractères spéciaux.

Par exemple donné ci-dessous, la valeur “CUST1000” est transmise sous forme de valeur alphanumérique au programme.
Si le programme est en COBOL, la valeur transmise via un paramètre PARM dans un JCL est reçue dans la LINKAGE SECTION du programme.
ADDRSPPCCeci est utilisé pour spécifier si l’étape de travail nécessite un stockage virtuel ou réel pour l’exécution.
Le stockage virtuel est paginable alors que le stockage réel ne l’est pas et est placé dans la mémoire principale pour exécution.
Les étapes de travail, qui nécessitent une exécution plus rapide, peuvent être placées dans un stockage réel. 

Voici la syntaxe :
ADRESPC=VIRT | REAL

Lorsqu’un ADDRSPC n’est pas codé, VIRT est celui par défaut.
ACCTCela spécifie les informations comptables de l’étape de travail. 

Voici la syntaxe :
ACCT=(ID utilisateur)

Ceci est similaire aux informations de comptabilisation des paramètres positionnels dans l’instruction JOB.
S’il est codé à la fois dans les instructions JOB et EXEC, les informations de comptabilisation dans l’instruction JOB s’appliquent à toutes les étapes de travail où un paramètre ACCT n’est pas codé.
Le paramètre ACCT dans une instruction EXEC remplacera celui présent dans l’instruction JOB pour cette étape de travail uniquement.

4. L’ORDRE EXEC

Elle permet d’identifier le programme ou la procédure à exécuter.
Limite : un JOB ne peut être constitué de plus de 255 étapes (soit 255 ordre exec).

C’est obligatoirement le premier ordre d’un STEP. Elle ce compose de paramètres positionnels et des paramètres à mots-clés. La zone nom de la carte est nécessaire pour faire un référence arrière qu STEP, modifier les paramètres des cartes EXEC et DD dans les procédures cataloguées, effectuer des reprises en début d’étapes ou à un check-point.
Pour l’ensemble de ces besoins, il est recommandé de données au différent STEP d’un JOB des noms différents.
• Si le programme a exécuté n’est pas trouvé le JOB envois un code retour système ABEND S806
• Si la procédure n’est pas trouvée elle envoie un message PROCEDURE NOT FOUND.

4.1. Format

//NOM

EXEC

PGM=nom.pgm

PROC=nom.pr

ou nom procedure

,PARM=valeur ,ADDRSPC=VIRT/REAL ,COND= ((cde,opr) ,(cde,opr,stp)
,(cde,opr,prc.stp),EVEN/ONLY) ,PERFORM=n
,REGION=nk
,TIME=1440/(min,s)

4.2. Description des paramètres

NOM : c’est le nom donné à l’étape par le programmeur. 1 à 8 caractères alphanumériques, le premier étant obligatoirement une lettre.

PGM = : Ce paramètre est positionnel; Il est nécessaire pour demander l’exécution du programme. Il s’agit d’un programme compilé antérieurement. Il ce compose de 8 caractère alphanumérique. Le programme est contenu dans une bibliothèque déclarée système
d’exploitation et le programme et au format LINK-EDIT.

PROC = : Ce paramètre est positionnel. Il est utilisé pour appeler une procédure cataloguée et demander son exécution.
Ce n’est pas un paramètre obligatoire. Il suffit, pour appeler une procédure, de fournir simplement son nom.

ADDRSPC = : Il est à demander le chargement du programme à exécuter soit en mémoire réelle, soit en mémoire virtuelle.
Ordre de priorité du paramètre : Le paramètre ADDRSPC, s’il est codé dans la carte JOB, prime sur les paramètres codés dans une carte EXEC. S’il est codé dans une carte EXEC d’appel de procédure prime sur celui codé dans les cartes EXEC de la procédure.

COND = Ce paramètre permet de donner une ou plusieurs conditions de non exécution d’un STEP.

Prend la forme suivante COND=(Valeur numérique, opérateur,Nom du step).

L’opérateur prend les valeurs suivantes :

  • GT : plus grand que.
  • GE : plus grand ou égal.
  • EQ : égal.
  • NE : non égal.
  • LT : plus petit que.
  • LE : Plus petit ou égal.

Fonctionnement :

  • Le test peut être fait par rapport au résultat de n’importe quelle étape précédente(on ne donne pas de nom d’étape) ou par rapport au résultat d’une étape précise (on donne le nom de l’étape).
  • Si une des conditions est réalisée, l’étape pour laquelle elle est codifiée n’est pas exécutée et on passe à l’étape suivante.
  • EVEN et ONLY : sont particuliers dans le sens ou ils font intervenir la notion d’ABEND. L’interprétation doit se faire de la façon suivante:
    1. COND=EVEN : Exécuter l’étape même si n’importe quelle étape précédente s’est terminée par un ABEND.
    2. COND=ONLY : Exécuter l’étape si et seulement si n’importe quelle étape précédente s’est terminée par un ABEND

Remarque : Si le paramètre COND est fourni dans la carte JOB et dans les cartes EXEC, le système réagit de la façon suivante :
– Si la condition définie dans la carte JOB est réalisée, il y a arrêt du JOB.
– Si non, le système teste la condition définie dans la carte EXEC. En fonction du résultat, il initialise ou n’initialise pas l’étape.

Exemple 1 :

//I000001AS JOB
//STEP1 EXEC PGM=PGM1
//FICENT1 DD DISP=SHR
//FICSOR1 DD DSN=FIC1
Résultat lors de l'exécution -> Returne Code = 0

//STEP2 EXEC PGM=PGM2,COND(0,NE)
//FICENT2 DD DISP=SHR,DSN=FIC1
//FICSOR2 DD DSN=FIC2
Résultat lors de l'exécution -> Returne Code = 8

//STEP3 EXEC PGM=PGM3,COND(0,NE,STEP1)
//FICENT3 DD DISP=SHR,DSN=FIC1
//FICSOR3 DD DSN=FIC3
Résultat lors de l'exécution -> Returne Code = 0

//STEP4 EXEC PGM=PGM4,COND(0,NE,STEP2)
//FICENT4 DD DISP=SHR,DSN=FIC2
//FICSOR4 DD DSN=FIC4

  • Le programme PGM1 s’exécute et se termine avec émission d’un code retour à 0.
  • Avant d’initialiser l’étape STEP2, l’initiator teste la condition définie dans la carte EXEC de la façon suivante :
    • Est-ce que 0 est différent du code retour émis par l’une des étapes précédentes?
    • Le programme PGM1 ayant émis un code retour égal à 0, la condition n’est pas réalisée et l’étape STEP2 peut s’exécuté.
  • Le programme PGM2 s’exécute et se termine avec émission d’un code retour égal à 8.
  • Avant d’initialiser l’étape STEP3, l’initiator teste la condition définie dans la carte EXEC de la façon suivante :
    • Est-ce que 0 est différent du code retour émis par l’étape STP1?
    • Le programme PGM1 ayant émis un code retour égal à 0, la condition n’est pas réalisée et l’étape STEP3 peut s’exécuter.
  • Le programme PGM3 s’exécute et se termine avec émission d’un code retour à 0.
  • Avant d’initialiser l’étape STEP4, l’initiator teste la condition définie dans la carte EXEC de la façon suivante:
    • Est-ce que 0 est différent du code retour émis par l’étape STEP2.
    • Le programme PGM2 ayant émis un code retour égal à 8, la condition est réalisée est l’étape STEP4 ne peut être exécuter.

Exemple 2 :

//I000001AS JOB
//STEP1 EXEC PGM=PGM1
//FICENT1 DD DISP=SHR
//FICSOR1 DD DSN=FIC1
Résultat lors de l'exécution -> Returne Code = 0

//STEP2 EXEC PGM=PGM2,COND(0,NE)
//FICENT2 DD DISP=SHR,DSN=FIC1
//FICSOR2 DD DSN=FIC2
Résultat lors de l'exécution -> Returne Code = 8

//STEP3 EXEC PGM=PGM3,COND(0,NE,STEP1)
//FICENT3 DD DISP=SHR,DSN=FIC1
//FICSOR3 DD DSN=FIC3
Résultat lors de l'exécution -> Returne Code = 0

//STEP4 EXEC PGM=PGM4,COND(0,NE,STEP2)
//FICENT4 DD DISP=SHR,DSN=FIC2
//FICSOR4 DD DSN=FIC4

  • Le programme PGM1 s’exécute et se termine avec émission d’un code retour à 0.
  • Avant d’initialiser l’étape STEP2, l’initiator teste la condition définie dans la carte EXEC de la façon suivante :
    • Est-ce que 0 est différent du code retour émis par l’une des étapes précédentes?
    • Le programme PGM1 ayant émis un code retour égal à 0, la condition n’est pas réalisée et l’étape STEP2 peut s’exécuté.
  • Le programme PGM2 s’exécute et se termine avec émission d’un code retour égal à 8.
  • Avant d’initialiser l’étape STEP3, l’initiator teste la condition définie dans la carte EXEC de la façon suivante :
    • Est-ce que 0 est différent du code retour émis par l’étape STP1?
    • Le programme PGM1 ayant émis un code retour égal à 0, la condition n’est pas réalisée et l’étape STEP3 peut s’exécuter.
  • Le programme PGM3 s’exécute et se termine avec émission d’un code retour à 0.
  • Avant d’initialiser l’étape STEP4, l’initiator teste la condition définie dans la carte EXEC de la façon suivante:
    • Est-ce que 0 est différent du code retour émis par l’étape STEP2.
    • Le programme PGM2 ayant émis un code retour égal à 8, la condition est réalisée est l’étape STEP4 ne peut être exécuter.

Exemple 2 :

//I000001AS JOB
//STEP1 EXEC PGM=PGM1
//FICENT1 DD DISP=SHR
//FICSOR1 DD DSN=FIC1
Résultat lors de l'exécution -> ABEND

//STEP2 EXEC PGM=PGM2,COND=ONLY
//FICENT2 DD DISP=SHR,DSN=FIC1
//FICSOR2 DD DSN=FIC2
Résultat lors de l'exécution -> Returne Code = 8

//STEP3 EXEC PGM=PGM3,COND=(0,NE,STEP1)
//FICENT3 DD DISP=SHR,DSN=FIC1
//FICSOR3 DD DSN=FIC3
Résultat lors de l'exécution -> Returne Code = 0

//STEP4 EXEC PGM=PGM4,COND=((0,NE,STEP2),EVEN)
//FICENT4 DD DISP=SHR,DSN=FIC2
//FICSOR4 DD DSN=FIC4

  • Le programme PGM1 s’exécute et se termine par ABEND.
  • Avant l’initialiser l’étape STEP2, l’initiator teste la condition définie dans la carte EXEC de la façon suivante :
    • Est-ce l’une des étapes précédentes s’est terminée par ABEND?
    • Le programme PGM1 est terminé par un ABEND, la condition est réalisée STEP2 peut s’exécuter.
  • Le programme PGM2 s’exécute et se termine avec émission d’un code retour égal à 8.
  • Pour l’initialisation de l’étape STEP3, l’initiator teste la condition définie dans la carte EXEC de la façon suivante :
    • Étant donné qu’il y a eu ABEND dans une étape précédente et que EVEN ou ONLY ce sont pas spécifiés, l’étape STEP3 ne peut pas s’exécuter.
  • Avant d’initialiser l’étape STEP4, l’initiator teste la condition définie dans la carte EXEC de la façon suivante :
    • Est-ce que l’étapes précédentes se sont exécutés s’est terminée par un ABEND? (OUI).
    • Est-ce que le test du code retour est satisfait. (OUI).
    • Dans ces conditions l’étape STEP4 ne peut pas s’exécuter (voir tableaux suivant).

Tableaux récapitulatifs des cas possible avec les opérateurs :

DESCRIPTIONInitialiseur étapePas d’initialisation de l’étape
COND=(code,GT)
COND=(code,GE)
COND=(code,EQ)
COND=(code,LT)
COND=(code,LE)
COND=(code,NE)
RC>=code
RC >code
RC ≠code
RC =<code
RC<code
RC=code
RC<code
RC=<code
RC=code
RC >code
RC>=code
RC ≠code

Tableaux récapitulatifs des cas possible pour EVEN et ONLY :

Spécification de
EVEN ou ONLY ?
ABEND étapes
précédentes?
TESTS RC
satisfaits
INIT étape
EVEN
EVEN
EVEN
EVEN
NON
NON
OUI
OUI
NON
OUI
NON
OUI
OUI
NON
OUI
NON
ONLY
ONLY
ONLY
ONLY
NON
NON
OUI
OUI
NON
OUI
NON
OUI
NON
NON
OUI
NON
NON
NON
NON
NON
NON
NON
OUI
OUI
NON
OUI
NON
OUI
OUI
NON
NON
NON

PARM : Ce paramètre permet de passer divers paramètres à un programme. Les paramètres pouvant être passés sont :
• Paramètre utilisateur.
• Paramètre compilateur et assembleurs.
• Les paramètres LINK-EDIT.
En ce qui concerne les paramètres utilisateurs, le programmeur doit avoir prévue une zone de réception dans son programme dans la LINKAGE SECTION.
Si la valeur du paramètre contient plusieurs expressions séparées par une virgule, il faut la mettre entre parenthèses ou entre apostrophes, ces caractères n’étant pas transmis au programme.
Si la valeur contient des caractères spéciaux, elle doivent être mise entre parenthèse ou entre apostrophes.
On peut transmettre jusqu’à 100 caractères de paramètres utilisateurs et des paramètres COBOL.

PERFORM : Ce paramètre permet d’affecter le STEP à un groupe de performance particulier.
Si le paramètre PERFORM est aussi codé dans la carte JOB, il primera sur ceux codés dans les différentes cartes EXEC.
Par défaut il le système qui définie le groupe de performance en fonction des paramètre du système.