Discussion :

[Metalman]

Après 1 semaine de questions, lecture de doc, expérimentations diverses...
Voici comment compiler du C sur z/OS en mode batch (JCL), avec CCNDRVR (XL C/C++) et IEWL, selon un débutant sur le C/zOS :

1) Créer les PDS contenant les sources (.c), les headers (.h), les objets (.o), les load modules (le binaire final/exécutable) :

• METAL.MALIB.C : RECFM=FB, LRECL=240
• METAL.MALIB.H : RECFM=FB, LRECL=80 (peut aussi être du VB 255...)
• METAL.MALIB.OBJ : RECFM=FB, LRECL=80
• METAL.MALIB.OUT : RECFM=U, LRECL=80

2) Taper le code et ses headers en code page 1047 - US (à régler dans son terminal 3270)...
Mon exemple ne nécessite pas tous les headers, mais je les ai mis pour indiquer quelques précisions après.

METAL.MALIB.C(HELLOC)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
#include "myincl.h"

int main(void)                          
{                                       
  int i = 42;                           
  char *str = "Hello World!";           
  printf("i : %d, str : %s\n", i, str); 
                                        
  return (0);                           
}

METAL.MALIB.H(MYINCL)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
#ifndef MYINCL_H_        
# define MYINCL_H_       
                         
# define _POSIX_SOURCE   
#  include <unistd.h>    
#  include <fcntl.h>     
# undef _POSIX_SOURCE    
# include <stdlib.h>     
# include <stdio.h>      
                         
#endif /* !MYINCL_H_ */

3) JCL de compilation (avec XL C/C++, CCNDRVR) + binding/linking (avec IEWL) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
//COMPILNK JOB CLASS=A,MSGLEVEL=(1,1),MSGCLASS=X,REGION=0M,          
//         NOTIFY=&SYSUID,TIME=30                                    
//  SET FICHIER=HELLOC                                                                    
//*                                                                  
//*****************************************************************  
//** COMPILE CCNDRVR '/SEARCH(''CEE.SCEEH.+'') NOOPT SO OBJ LIST' *  
//*****************************************************************  
//*                                                                  
//COMPILE EXEC PGM=CCNDRVR,                                          
//        PARM='/SEARCH(''CEE.SCEEH.+'') NOOPT SO OBJ LIST'          
//USERLIB DD DSNAME=METAL.MALIB.H,DISP=SHR                           
//STEPLIB DD DSNAME=CEE.SCEERUN,DISP=SHR                             
//        DD DSNAME=CEE.SCEERUN2,DISP=SHR                            
//        DD DSNAME=CBC.SCCNCMP,DISP=SHR               
//SYSPRINT DD SYSOUT=*                                 
//SYSCPRTT DD SYSOUT=*                                 
//*SYSLIB DD DSN=METAL.MALIB.C,DISP=SHR                
//*      DD DISP=SHR,DSN=TCPIP.SEZACMAC                
//*      DD DISP=SHR,DSN=CEE.SCEEH.H                             
//SYSIN  DD DSN=METAL.MALIB.C(&FICHIER),DISP=SHR       
//SYSLIN DD DSN=METAL.MALIB.OBJ(&FICHIER),DISP=SHR     
//*                                                    
//**************************************************   
//**  BIND1  IEWL 'OPTIONS=OPTS'                   *   
//**************************************************   
//*                                                    
//BIND1 EXEC PGM=IEWL,PARM='OPTIONS=OPTS'              
//OPTS DD *                                                 
     AMODE=31,MAP                                           
     NORENT,DYNAM=DLL                                       
     CASE=MIXED                                             
/*                                                          
//SYSLIB DD DISP=SHR,DSN=CEE.SCEELKEX                       
//       DD DISP=SHR,DSN=TCPIP.SEZACMTX                     
//       DD DISP=SHR,DSN=CEE.SCEELKED                       
//       DD DISP=SHR,DSN=CEE.SCEECPP                        
//       DD DISP=SHR,DSN=SYS1.CSSLIB                        
//SYSLIN DD DISP=SHR,DSN=METAL.MALIB.OBJ(&FICHIER)          
//*      DD DISP=SHR,DSN=SYS1.MDALBIN.PROG.OBJ(EDSATT)      
//*      DD DISP=SHR,DSN=SYS1.MDALBIN.PROG.OBJ(WAIT)        
//*      DD DISP=SHR,DSN=SYS1.MDALBIN.PROG.OBJ(STOP0C1)     
//       DD DISP=SHR,DSN=CBC.SCLBSID(IOSTREAM)              
//SYSLMOD DD DISP=SHR,DSN=METAL.MALIB.OUT(&FICHIER)  
//SYSPRINT DD SYSOUT=*                               
//*

On peut mettre plusieurs cartes DD au niveau du USERLIB pour plusieurs headers.
Ou on peut remplacer la carte DD USERLIB par un paramètre plus complet :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
//        PARM=('/SEARCH(''CEE.SCEEH.+'',''METAL.MALIB.+''),', 
//             ' NOOPT,SO,OBJ,LIST')

On retrouve les erreurs de compilation dans SDSF, log "st"...
Ou dans le PDS créé à côté du PDS contenant les sources (il se créer automatiquement et se nomme dans mon cas : META.MALIB.C.LIST)

Je n'ai pas encore essayé de compiler plusieurs fichiers, mais de ce que j'ai pu lire, une des méthodes "possible" est de compiler chaque membre contenant des sources (1 step par source à compiler), puis de binder tous les objets générés en les indiquant dans plusieurs cartes DD associées à SYSLIN.

4) JCL d'exécution du load module/binaire final :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
//MYRUN    JOB CLASS=A,MSGLEVEL=(1,1),MSGCLASS=A,REGION=0M,  
//         NOTIFY=&SYSUID,TIME=30                            
//  SET FICHIER=HELLOC                                       
//RUNPRM   EXEC PGM=&FICHIER,                                
//             PARM='METAL.TEST',                            
//             REGION=0M                                     
//STEPLIB  DD DSN=METAL.MALIB.OUT,DISP=SHR                   
//* CONFIG   DD DSN=METAL.TEST,DISP=SHR                        
//SYSPRINT DD SYSOUT=*                                       
//SYSUDUMP DD SYSOUT=*                                       
//SYSABEND DD SYSOUT=*                                       
//SYSCPRTT DD SYSOUT=*

PARM sert à indiquer les paramètres donnés au programme.

La sortie standard se retrouve dans la log "st", pour plus de détails, on peut taper "?" devant le job du programme, puis "s" sur la SYSPRINT pour voir uniquement la sortie des printf.

Je ne sais pas encore comment ouvrir un DSN donné en DD, j'ai essayé plusieurs méthodes : open(CONFIG, O_RDONLY) mais cela renvoi -1...

D'ailleurs ! Pour que les defines O_RDONLY, STDOUT_FILENO, STDERR_FILENO, etc... fonctionnent, IL FAUT indiquer le define _POSIX_SOURCE !


Pour essayer d'utiliser le préprocesseur, j'ai trouvé ce lien : préprocesseur
On peut voir que le premier step met en paramètre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
//COMP1   EXEC PGM=CCNDRVR,REGION=0M,
// PARM=('PP(COMMENTS,NOLINES)')

Un grand merci à tous !

[Metalman]

Pour la partie COBOL...
J'ai trouvé quelques exemples utilisant IGYCRCTL
Notamment : Lien 1, Lien 2, et Lien 3.

Je me retrouve donc, pour la partie compilation, avec ça :
(&FICHIER étant, comme dans les JCL précédents, le nom du membre)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//COMPILE  EXEC PGM=IGYCRCTL,                           
//         PARM='DYN,DATA(31),LIST,NOOFF'               
//STEPLIB  DD   DSNAME=IGY410.SIGYCOMP,DISP=SHR         
//SYSPRINT DD   SYSOUT=*                                
//SYSLIN   DD   DSN=METAL.MALIB.OBJ(&FICHIER),DISP=SHR  
//SYSUT1   DD   UNIT=MESYS1,SPACE=(CYL,(1,1))           
//SYSUT2   DD   UNIT=MESYS1,SPACE=(CYL,(1,1))           
//SYSUT3   DD   UNIT=MESYS1,SPACE=(CYL,(1,1))           
//SYSUT4   DD   UNIT=MESYS1,SPACE=(CYL,(1,1))           
//SYSUT5   DD   UNIT=MESYS1,SPACE=(CYL,(1,1))           
//SYSUT6   DD   UNIT=MESYS1,SPACE=(CYL,(1,1))           
//SYSUT7   DD   UNIT=MESYS1,SPACE=(CYL,(1,1))           
//SYSIN    DD   DSN=METAL.MALIB.COB(&FICHIER),DISP=SHR

Si j'ai bien compris les options de compilation que j'ai donné,

• DYN : Permet de créer des load modules plus légers et séparés pour être appelés séparément (comme des DLL sous Windows ou des libs dynamiques)
• DATA(31) : Permet de passer des paramètres en mode 31 bits (à l'inverse du DATA(24) qui permet de transformer des paramètres 31 bits en 24 bits pour des programmes 24 bits)
• LIST : Permet d'afficher le code ASM
• NOOFF : N'affiche pas les offsets ?...

Le DATA(31) ne me parait pas très approprié... mais je ne suis sûr de rien...

Bref, après avoir lancé mon JCL, j'ai un JCL error avec ça comme message :

IEF210I COBCOMP COMPILE SYSUT1 - UNIT FIELD SPECIFIES INCORRECT DEVICE NAME

D'après la doc, les SYSUT* servent comme espace temporaire pour que le compilateur fasse son travail.
Mais je ne comprends pas trop l'erreur pour le coup... devrais-je déclarer moi-même des datasets temporaires sur ce disque, et préciser un DSN dans SYSUT1 ?

(J'espère qu'en fin de semaine ma curiosité sera à 100% assouvie ! J'ai ressorti le livre "COBOL du 21e siècle" pour adapter les FD à z/OS... je pense faire d'abord un exécutable avec tri interne COBOL, puis je ferai un 2e JCL appelant le SORT z/OS en retirant le tri interne COBOL ! Et normalement... cela devrait me suffire pour être content et un peu moins naïf sur z/OS)

[Luc Orient]

... Bref, après avoir lancé mon JCL, j'ai un JCL error avec ça comme message ...

Je pense que ton "device-type", ce qui suit UNIT=, n'est pas défini sur ton z/OS ...

Essaie UNIT=SYSDA

Maintenant le mieux serait pour moi d'utiliser les procédures cataloguées fournies par IBM, à savoir, IGYWC pour une compilation seule ou IGYWCL pour une compilation et une édition de liens.

cf. le Programming Guide COBOL.

[Metalman]

En effet ça marche ! (maintenant j'ai pleins d'erreurs COBOL que je vais soigneusement corriger )

Cela m'étonne, mes PDS sont tous sur MESYS1, et sans préciser de unit sur les autres JCL, cela fonctionne...
AAAAAAAAAH... je suis bête.
Dans device-type... il y a "type"... j'ai confondu volume-label/VOL=SER avec unit...
J'ai testé avec 3390, et cela fonctionne aussi ! Merci pour la remarque "device-type" !

Quelles sont les différences entre IGYWC et IGYCRCTL ?
J'irai lire la doc dans tous les cas...
(J'avais vu en effet les programmes finissant par L = compil + link, LG = compil + link + exécution... j'essayerai volontier le IGYWCL pour le coup !)

[Luc Orient]

... j'ai confondu volume-label/VOL=SER avec unit...
J'ai testé avec 3390, et cela fonctionne aussi ! Merci pour la remarque "device-type" !

Attention ! On n'est ici dans un contexte didactique ... Sur un "vrai" site z/OS on ne code plus VOL=SER= ... mais on laisse faire SMS et ses ACS routines faire le travail ... La notion même de "volume" n'est même plus que virtuelle puisque les systèmes de stockage reliés au Mainframe sont désormais les mêmes que ceux reliés au grands serveurs UNIX ...

Quelles sont les différences entre IGYWC et IGYCRCTL ?

La première procédure ne fait que la compilation et le seconde y rajoute l'édition de liens.

[Metalman]

Hmmm...
En utilisant le IGYWCL, je vois qu'il génère un JCL avec IGYCRCTL et HEWL...
Mais il me créer une erreur :

23 XXSYSUT1 DD UNIT=SYSALLDA,SPACE=(TRK,(10,10))
STMT NO. MESSAGE
3 IEFC001I PROCEDURE IGYWCL WAS EXPANDED USING SYSTEM LIBRARY
23 IEF686I DDNAME REFERRED TO ON DDNAME KEYWORD IN PRIOR STEP WAS NOT RESOLVED

Je vais d'abord voir quoi faire avec mon job précédent qui fonctionnait (et corriger les erreurs ), puis je vais re-essayer avec votre proposition qui offre un JCL beaucoup plus simple !

EDIT : A propos du stockage, merci de l'information !
Je me doutais que les SAN étaient partagés entre UNIX/Linux, mais je ne pensais pas que les Mainframe pouvaient également se mettre dessus.
J'avais encore en tête l'armoire Mainframe + l'armoire CU + l'armoire disques avec ma 1ère formation (et le Introduction to the New Mainframe)...
Je suppose que le SAN ne fait que remplacer l'armoire disques, et que les CU sont toujours là.

[M.Dlb]

Pas de SAN à proprement parlé avec un Mainframe sous z/OS. On a toujours la structure, Ficon/Escon <-> Ficon switch/Escon director <-> baie de disque. Les Control Units sont "virtuelles" maintenant, tout se fait lorsqu'on formate la baie de disque en format ECKD, la couche de gestion fait tout ça de façon transparente...

Pour utiliser les volumes dit "Open Storage" et éventuellement les SAN, il faut utiliser Linux sur System z, avec les disques au format SCSI.

[Metalman]

Finalement, je compile et j'exécute correctement du COBOL !

Voici les specs de mes datasets :

• METAL.MALIB.JCL => PDS, organization=PO
  RECFM=FB,LRECL=80,BLKSIZE=800,1stExt=200,second=10,DIRBlock=10
  Contient les JCL
• METAL.MALIB.COBOL => PDS, organization=PO
  RECFM=FB,LRECL=80,BLKSIZE=80,1stExt=200,second=40,DIRBlock=10
  Contient le code source
• METAL.MALIB.OBJ => PDS, organization=PO
  RECFM=FB,LRECL=80,BLKSIZE=80,1stExt=200,second=40,DIRBlock=10
  Contient les objets générés à la compilation
• METAL.MALIB.OUT => PDS, organization=PO
  RECFM=U,LRECL=80,BLKSIZE=256,1stExt=200,second=40,DIRBlock=10
  Contient le load module/binaire final
• METAL.MALIB.DATA.IN.DEP$JAN => organisation=PS
  RECFM=FB,LRECL=35,BLKSIZE=350,1stExt=10,second=5
  Contient mes données en entrée [le LRECL dépend du format codé dans COBOL en FD]
• METAL.MALIB.DATA.OUT.TOTAL => organisation=PS
  RECFM=FB,LRECL=37,BLKSIZE=370,1stExt=10,second=5
  Contient mes données en sortie [le LRECL dépend du format codé dans COBOL en FD]

Voici le JCL de compilation (j'utilise IGYCRCTL en compilateur, et IEWL en linker/binder) :
Ne pas oublier d'adapter dans la partie de link les libs !
Rechercher un CEE.SCEELKED (ou un SCEELKED), un IGY410.SIGYCOMP (ou SIGYCOMP), et IGY410.SIGYPROC (ou SIGYPROC).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
//COBCOMP  JOB CLASS=A,MSGLEVEL=(1,1),MSGCLASS=1,REGION=0M,  
//         NOTIFY=&SYSUID,TIME=30                            
//  SET FICHIER=CHICOU$Z                                     
//*                                                          
//* *********************************************************
//* * COMPILE IGYCRCTL 'DYN,DATA(31),LIST,NOOFF,NOFASTSRT'  *
//* *********************************************************
//*                                                          
//COMPILE  EXEC PGM=IGYCRCTL,                                
//         PARM='DYN,DATA(31),LIST,NOOFF,NOFASTSRT'          
//STEPLIB  DD   DSNAME=IGY410.SIGYCOMP,DISP=SHR              
//SYSPRINT DD   SYSOUT=*                                     
//SYSLIN   DD   DSN=METAL.MALIB.OBJ(&FICHIER),DISP=SHR       
//SYSUT1   DD   UNIT=3390,SPACE=(CYL,(1,1))                           
//SYSUT2   DD   UNIT=3390,SPACE=(CYL,(1,1))                         
//SYSUT3   DD   UNIT=3390,SPACE=(CYL,(1,1))                         
//SYSUT4   DD   UNIT=3390,SPACE=(CYL,(1,1))                         
//SYSUT5   DD   UNIT=3390,SPACE=(CYL,(1,1))                         
//SYSUT6   DD   UNIT=3390,SPACE=(CYL,(1,1))                         
//SYSUT7   DD   UNIT=3390,SPACE=(CYL,(1,1))                         
//SYSIN    DD   DSN=METAL.MALIB.COBOL(&FICHIER),DISP=SHR            
//*                                                                 
//* ************************************************************    
//* * LINK IEWL 'OPTIONS=OPTS'                                 *    
//* ************************************************************    
//*                                                                 
//LINK     EXEC PGM=IEWL,PARM='OPTIONS=OPTS'                        
//OPTS DD *                                               
     AMODE=31,MAP                                         
     NORENT,DYNAM=DLL                                     
     CASE=MIXED                                           
/*                                                        
//*SYSLIB   DD   DSN=SYS1.COB2LIB,DISP=SHR                
//*         DD   DSN=SYS1.COB2COMP,DISP=SHR               
//SYSLIB   DD   DSN=IGY410.SIGYCOMP,DISP=SHR              
//         DD   DSN=IGY410.SIGYPROC,DISP=SHR              
//         DD   DSN=SYS1.LINKLIB,DISP=SHR                 
//         DD   DSN=CEE.SCEELKED,DISP=SHR                 
//SYSLMOD  DD   DSN=METAL.MALIB.OUT(&FICHIER),DISP=SHR    
//SYSTERM  DD   SYSOUT=*                                  
//SYSPRINT DD   SYSOUT=*                                  
//SYSLIN   DD   DSN=METAL.MALIB.OBJ(&FICHIER),DISP=SHR

Le JCL d'exécution :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//MYRUN    JOB CLASS=A,MSGLEVEL=(1,1),MSGCLASS=A,REGION=0M,   
//         NOTIFY=&SYSUID,TIME=30                             
//* SET FICHIER=HELLOC                                        
//* SET FICHIER=TESTFD                                        
//  SET FICHIER=CHICOU$Z                                      
//RUNPRM   EXEC PGM=&FICHIER,                                 
//             PARM='METAL.TEST',                             
//             REGION=0M                                      
//STEPLIB  DD DSN=METAL.MALIB.OUT,DISP=SHR                                 
//DEPENS   DD DSN=METAL.MALIB.DATA.IN.DEP$JAN,DISP=SHR        
//SORTIE   DD DSN=METAL.MALIB.DATA.OUT.TOTAL,DISP=SHR               
//SYSPRINT DD SYSOUT=*                                        
//SYSUDUMP DD SYSOUT=*       
//SYSABEND DD SYSOUT=*       
//SYSCPRTT DD SYSOUT=*       
//SYSOUT   DD SYSOUT=*

Le code que j'ai compilé se trouve ici.

[Metalman]

Réouverture tardive, mais !
Elle ne servira pas à rien.
Sur la partie C : j'ai trouvé comment ouvrir avec un DDname... et j'ai aussi trouvé comment convertir ASCII -> EBCDIC.

Tout d'abord, ASCII -> EBCDIC (utile pour les transferts en binary mode de sources) :

pax -ofrom=ISO8859-1,to=IBM-1047 -rv

+ man pax pour les détails
Merci à IBM avec ce lien.

Ensuite, je n'ai pas réussi à utiliser "open", par contre, le "fopen" sur des DDname est assez facile.
Utilisation de fopen
Détails des flags pour fopen
On déduit de ces liens qu'il faut faire un fopen("dd:MONDD", "w+"); pour ouvrir le DDname "MONDD" et écrire dedans.

Attention ! Si on écrit certains caractères "ASCII", ISPF râle qu'il n'arrive pas à les afficher.

Les liens précédents expliquent comment utiliser fopen sur OMVS/USS et la partie "classique" de z/OS (MVS).... et comment accéder aux fichiers dans la HFS et aux DataSets depuis ces 2 environnements.

[M.Dlb]

Attention ! Si on écrit certains caractères "ASCII", ISPF râle qu'il n'arrive pas à les afficher.

C'est justement parce que ce n'est pas un système ASCII mais EBCDIC
Les codes caractère stockés dans les fichiers sont EBCDIC et non ASCII. Si on écrit un code ASCII, ben il sera interprété en EBCDIC, donc on obtiendra un résultat différent !

Il faut aussi faire attention au codepage 3270 qu'on utilise... Personnellement, je ne prends plus que le CP1047 US.

[Metalman]

Mes phrases sont correctement affichable dans le DSN de sortie, donc full EBCDIC, sauf quelques caractères que j'ai "essayé" !
J'avais essayé un "\n" et quelques bizarreries du genre, et j'ai lu quelque part que quelques caractères du genre n'existent même pas en EBCDIC.
C'est pour ça que j'ai mis le ASCII entre guillemets !

En effet, dans le topic plus haut on voit le CP1047-US, et j'ai tout tapé avec !
(sinon les accolades ne passaient pas... ce qui est problématique pour du C)

[M.Dlb]

Normalement, dans un printf, le "\n" fonctionne de même que les autres caractères spéciaux, comme "\0", car il me semble qu'ils font partie du standard C.

Le "\n" fonctionne sur la SYSLOG par exemple. Dans un fichier, il y a peut-être des restrictions, à cause des formats de PDS (LRECL...), en réalité j'ai jamais testé l'écriture dans un fichier

[Metalman]

J'ai essayé d'écrire dans un dataset classique, les retours à la ligne ont été pris comme des délimiteurs de "nouveaux" enregistrements.
Mais je n'ai pas vérifié en détails si ce sont eux les "caractères non-affichables" qui sont remontés par ISPF.
Dès que je le peux, je testerai plus en détails les PDS et DataSets !

'\n' et '\0'... standard C...
'\0' oui ! C'est le caractère de fin de chaîne. Donc il ne sera pas nécessairement écrit, mais sera interprété/utilisé.
A l'inverse le '\n' reste un caractère "dédié" à l'ASCII/lié à UNIX/TéléTypes il me semble...
Du coup... bah j'expérimenterai la chose pour avoir la réponse dès que je le peux !

[juju742]

Bonjour,

Je recherche un script JCL (à titre d'exemple) pour compilé un hello word cobol sur un système Z/OS 1.10 ADCD. Je suis débutant et je connais pas ce système qu'on m'a fourni t elle qu'elle.
Merci de votre aide, je débute un poste de développeur Cobol dans un mois et le soucis c'est j'ai eu une formation très courte.