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.

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.