Job Control Language

Dans le JCL, l'unité est le job (la tâche), laquelle consiste en un ou plusieurs steps (étapes). Chaque step consiste en l'exécution d'un programme spécifique. Ainsi, un job qui consisterait à créer un rapport pourrait être composé des steps suivants :

• sélection des enregistrements voulus à l'aide d'un programme et stockage des résultats dans un fichier temporaire ;
• tri des résultats à l'aide d'un utilitaire approprié ;
• création du rapport proprement dit à l'aide d'un autre programme qui fait le calcul — cumuls, etc. — et la mise en forme des informations voulues ;
• affichage du rapport, etc.

Carte perforée correspondant à une ligne d'instruction

Le JCL utilise des identifiants basiques que l'on nomme « cartes » (reste de l’époque où chaque ligne de script, de programme, etc. était fournie à l’ordinateur au moyen d'une carte perforée). Un script JCL devra débuter par la carte JOB qui permet notamment :

• de donner un nom au job ;
• d'identifier le groupe qui recevra le rapport d'exécution ;
• de définir comment le job doit être exécuté (par exemple sa priorité)

Il est possible de créer des scripts JCL qui pourront être appelés dans d'autres scripts JCL en passant si nécessaire des paramètres. De tels scripts sont appelées procédures.

Remarque : Par métonymie, le mot JCL désigne aussi le script (job) lui-même. Ainsi, en environnement IBM, on ne parle pas de script JCL mais simplement de JCL (ex. : lancer ou exécuter un JCL).

La syntaxe du JCL comparée à la plupart des langages de batch, est assez lourde. Par exemple, si on désire copier un fichier dans un autre sous MS-DOS ou UNIX, il suffit d'écrire une instruction du style :

copy fichier1 fichier2

or en JCL OS, pour obtenir le même résultat il faudrait écrire quelque chose comme :

//IS198CPY JOB (IS198T30500),'COPY JOB',CLASS=L,MSGCLASS=X
//COPY01   EXEC PGM=IEBGENER
//SYSPRINT DD SYSOUT=*
//SYSUT1   DD DSN=FICHIER1,DISP=SHR
//SYSUT2   DD DSN=FICHIER2,
//            DISP=(NEW,CATLG,DELETE),
//            SPACE=(CYL,(40,5),RLSE),
//            DCB=(LRECL=115,BLKSIZE=1150)
//SYSIN    DD DUMMY

Cette lourdeur est due à quelques facteurs :

• d'une part le JCL a été développé pour des ordinateurs des années 1960, limités en termes de mémoire et d'instructions par seconde. Que les instructions soient plus faciles à être interprétées pour la machine (et donc plus rapides à exécuter) était un objectif considéré comme plus important qu'avoir des instructions faciles à coder pour le programmeur ;
• d'autre part, les systèmes /360 ont été conçus dans un esprit multi-utilisateur. Il fallait donc transmettre des paramètres permettant par exemple d'identifier qui devait recevoir les rapports d'exécution (ici le compte IS198T30500), quelle était la priorité de la tâche (CLASS), s'il fallait verrouiller ou non les fichiers lus par les programmes durant leur exécution (DISP), etc.

IBM a gardé la syntaxe originelle du JCL de manière que les anciens scripts puissent toujours être exécutés, mais a également introduit des alternatives plus faciles à utiliser pour le programmeur comme CLIST. La possibilité d'utiliser des procédures paramétrables est également une manière de contourner en partie la lourdeur de la syntaxe.

Les lignes des scripts JCL sont limités à 80 caractères. Il s'agit d'un héritage du temps où les programmes s'écrivaient à l'aide de cartes perforées de 80 colonnes. Tout ce qui est écrit au-delà du 80^e caractère est ignoré par le système d'exploitation. En réalité, seuls les 71 premiers caractères sont réellement pris en compte et utilisables par le programmeur. Le 72^e caractère consiste usuellement en un espace, et les caractères 73 à 80 sont réservés pour la numérotation des lignes.

Toutes les lignes, à l'exception des flots d'entrée, doivent commencer par un slash (/), et toutes les lignes contenant les processus du système d'exploitation doivent débuter par deux slashs (//) devant toujours commencer en colonne 1. Il existe deux exceptions à cette règle : le délimiteur (/*), et le commentaire (//*).

Beaucoup d'instructions JCL sont trop longues pour tenir sur 71 caractères, mais peuvent être prolongées sur un nombre non-défini de lignes.

La syntaxe générale d'une instruction JCL est :

//NOM CARTE PARAMETRES

Les paramètres sont séparés par des virgules (,) sans espace.

Le JCL permet les flots d'entrée, c'est-à-dire des cartes qui seront utilisés directement par les programmes appelés et non le système d'exploitation directement.

Bien que les JCL DOS et OS ne définissent pas les flots d'entrée de la même façon, ils les délimitent tous deux par un slash-étoile (/*) en colonne 1.

Les flots, ainsi que les fichiers entrée/sortie, peuvent être décrits à l'aide de la carte DD (qui inspirera plus tard l'utilitaire dd d'UNIX).

En JCL DOS, les paramètres sont positionnels. L'ordre d'entrée des paramètres est donc extrêmement important, et même l'emplacement destiné aux paramètres optionnels doivent être remplis au moyen de virgules si le programmeur ne les utilise pas.

Ceci est illustré par l'exemple ci-dessous :

// TLBL TAPEFIL,'COPYTAPE.JOB',,,,2
// ASSGN SYS005,DISK,VOL=VOL01,SHR
// DLBL DISKFIL,'COPYTAPE.JOB',0,SD
// EXTENT SYS005,VOL01,1,0,800,16

Dans la version originale de DOS/360 ainsi que dans la plupart des versions de DOS/VS, il fallait spécifier le numéro de modèle du matériel utilisé pour lire chaque disque ou cassette, y compris pour les fichiers temporaires. Changer le matériel signifiait donc devoir modifier de nombreux scripts JCL.

Le JCL OS ne comporte que trois cartes basiques :

• la carte JOB, qui permet d'identifier le job et de fournir des informations qui lui sont relatives ;
• la carte EXEC, qui permet à chaque step d'identifier quel programme appeler ;
• la carte DD qui permet d'identifier les fichiers ou flots à utiliser au cours d'un step.

Le JCL OS utilise également des paramètres à mots-clefs, ce qui signifie que l'ordre de passage des paramètres importe peu et qu'il n'est pas nécessaire d'entrer les paramètres optionnels si ceux-ci ne servent pas.

Par exemple :

//NEWFILE DD DSN=MYFILE01,UNIT=DISK,SPACE=(TRK,80,10),
//           DCB=(LRECL=100,BLKSIZE=1000),
//           DISP=(NEW,CATLG,DELETE)

De nombreux mots-clefs (DSN, UNIT, SPACE, etc.) permettent de passer les paramètres relatifs au fichier NEWFILE.

En JCL OS, le matériel peut être déclaré via des termes génériques du style TAPE ou DISK, ce qui offre une indépendance relative vis-à-vis du matériel.

Le JCL OS permet de créer des procédures paramétrables, ce qui permet de créer des scripts faciles à réutiliser.

Les procédures sont déclarées au moyen de la carte PROC. Les paramètres sont indiqués au moyen d’esperluettes (&) et une valeur par défaut peut être fournie.

On peut par exemple créer une procédure de cette manière :

//MYPROC PROC FNAME=MYFILE01,SPTYPE=TRK,SPINIT=50,SPEXT=10,LR=100,BLK=1000
.....
//NEWFILE DD DSN=&FNAME,UNIT=DISK,SPACE=(&SPTYPE,&SPINIT,&SPEXT),
//           DCB=(LRECL=&LR,BLKSIZE=&BLK),DISP=(NEW,CATLG,DELETE)
....

et l'appeler ainsi :

//JOB01  JOB ..........
//STEP01 EXEC MYPROC FNAME=JOESFILE,SPTYPE=CYL,SPINIT=10,SPEXT=2,LR=100,BLK=2000

ou encore :

//JOB02  JOB ..........
//STEP01 EXEC MYPROC FNAME=SUESFILE,SPTYPE=TRK,SPINIT=500,SPEXT=100,LR=100,BLK=5000

Le JCL OS permet de conditionner l'exécution des steps en fonction des erreurs produites par les steps précédents. En effet, chaque step produit un code retour (COND), qui suit généralement cette norme :

• 0 : exécution normale
• 4 : erreur mineure
• 8 : erreur importante
• 12 : erreur majeure
• 16 : erreur très sérieuse

Le JCL OS permet de tester (ou modifier) la valeur de ce code erreur pour conditionner l'exécution du step suivant.

Ainsi dans le script JCL suivant :

//MYJOB JOB ...........
//STEP01 EXEC PGM=PROG01
....
//STEP02 EXEC PGM=PROG02,COND=(4,GT,STEP01)
....
//STEP03 EXEC PGM=PROG03,COND=(8,LE)
....
//STEP04 EXEC PGM=PROG04,COND=(ONLY,STEP01)
....
//STEP05 EXEC PGM=PROG05,COND=(EVEN,STEP03)
....

va :

• démarrer le step STEP01 qui exécute le programme PROG01
• si le code retour actuel est supérieur à 4, lancer STEP02
• si le code retour actuel est inférieur ou égal à 8, lancer STEP03
• si STEP01 n'a pas fini normalement, lancer STEP04
• lancer STEP05 même si STEP03 a fini anormalement

IBM a également introduit plus tard l'instruction IF qui permet de coder ces conditions un peu plus facilement.