Antes de empezar
En El mapa del mainframe dejamos a CALCNOM1 en dos lugares: su
fuente en NOMINA.FUENTES y el programa que el job de ejecución busca en
NOMINA.PRUEBAS.LOADLIB. Esta guía es lo que pasa en medio. Los términos (dataset, miembro,
ddname, step) están en el glosario del mapa; aquí los usamos sin volver a explicarlos.
Tres pasos, tres cosas que cambian de mano
En una PC “compilar” suele ser un solo botón. Aquí son dos pasos antes de ejecutar, y cada uno recibe una cosa y entrega otra:
- Compilar. Entra el fuente, el texto COBOL. Sale el módulo objeto: código máquina, pero incompleto. Tiene huecos donde el programa llama a cosas que no están en él.
- Linkeditar. Entra el módulo objeto. El binder le rellena los huecos con las rutinas de Language Environment (LE) y, si las hay, con otros programas, y entrega el program object: el ejecutable completo, guardado como miembro en la librería de loads.
- Ejecutar. El job de ejecución nombra el miembro con
PGM=y la librería conSTEPLIB.
Por eso no basta con compilar: un módulo objeto no corre. Hasta que el binder no lo convierte en program object y lo deja en la librería, el job de ejecución sigue encontrando el miembro de antes.
Compilar: IGYCRCTL y sus DD
El compilador de Enterprise COBOL es el programa IGYCRCTL, y se ejecuta como cualquier otro:
con un EXEC y los DD que necesita. Este es el step de compilación de CALCNOM1, armado con la
estructura del procedimiento IGYWCL que entrega IBM:
//NOMINA02 JOB (CUENTA),'COMPILA CALCNOM1',CLASS=A,MSGCLASS=X
//COMPILA EXEC PGM=IGYCRCTL,REGION=0M
//STEPLIB DD DSN=IGY.V6R4M0.SIGYCOMP,DISP=SHR
// DD DSN=CEE.SCEERUN,DISP=SHR
// DD DSN=CEE.SCEERUN2,DISP=SHR
//SYSIN DD DSN=NOMINA.FUENTES(CALCNOM1),DISP=SHR
//SYSLIB DD DSN=NOMINA.COPYS,DISP=SHR
//SYSPRINT DD SYSOUT=*
//SYSLIN DD DSN=&&OBJETO,DISP=(MOD,PASS),UNIT=SYSALLDA,
// SPACE=(CYL,(1,1))
//SYSUT1 DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT2 DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT3 DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT4 DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT5 DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT6 DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT7 DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT8 DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT9 DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT10 DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT11 DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT12 DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT13 DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT14 DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT15 DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSMDECK DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
Los cuatro DD que importan:
SYSIN: el fuente. Un miembro de la librería de fuentes, o el código pegado en el mismo JCL conDD *.SYSLIB: las librerías de copys. Aquí se cierra lo que el mapa dejó pendiente: cada vez que el compilador encuentra unCOPY, busca el miembro en las librerías delSYSLIB, en el orden en que estén concatenadas. Si tu proyecto tiene copys propios y copys comunes, van dosDDseguidos, el segundo sin nombre. Un copy que no está en ninguna da el mensaje de arranque y la cascada que se explica en Los errores de compilación más comunes.SYSPRINT: el listado. El de Cómo leer un listado de compilación, conSYSOUT=*para verlo en el spool.SYSLIN: el módulo objeto. La salida que le interesa al siguiente step.&&OBJETOes un dataset temporal: existe solo durante el job, yDISP=(MOD,PASS)se lo pasa al step de linkedit.
Los demás están porque el compilador los exige: el STEPLIB es la librería del compilador más las
de LE que necesita para correr; SYSUT1 a SYSUT15 son datasets de trabajo temporales; y
SYSMDECK recibe el fuente con los copys ya expandidos, o sirve de trabajo si no pides la opción
MDECK. Los nombres IGY.V6R4M0.SIGYCOMP, CEE.SCEERUN y CEE.SCEERUN2 son los que trae la
documentación por omisión; cada instalación puede tener otros.
Linkeditar: el binder y sus DD
El binder es el programa IEWBLINK (el nombre viejo, linkage editor, sigue vivo en el
verbo “linkeditar”). Toma el módulo objeto y resuelve sus referencias externas: cada nombre
que el programa usa y no define.
Para CALCNOM1 son las rutinas de Language Environment que el compilador invoca por él: lo que no
genera como código dentro del programa, como abrir y leer archivos o hacer DISPLAY, lo pide a LE.
La aritmética, en cambio, sí la genera el compilador dentro del programa. Por eso el S0C7 de Me
tronó en ejecución cae en un offset de CALCNOM1, es decir, en una posición
del código del propio programa.
Si CALCNOM1 tuviera CALL a otros programas, también serían referencias externas. El binder busca
cada nombre en las librerías del SYSLIB, pega lo que encuentra y deja el resultado como un solo
miembro. Un CALL puede resolverse aquí, al linkeditar, o en ejecución: es la diferencia entre
CALL estático y dinámico.
Lo que el binder pega de LE no es la librería completa. IBM separa dos cosas: en SCEELKED y
SCEELKEX están las rutinas residentes, las que se linkeditan con tu programa (entre ellas
las de inicio y fin de la ejecución), y en SCEERUN y SCEERUN2 están las rutinas de
ejecución, las que el programa carga cuando corre. Por eso LE aparece dos veces en el recorrido:
en el SYSLIB del binder y en el STEPLIB del job de ejecución.
//LINKEDIT EXEC PGM=IEWBLINK,COND=(8,LT,COMPILA),REGION=0M
//SYSLIB DD DSN=CEE.SCEELKEX,DISP=SHR
// DD DSN=CEE.SCEELKED,DISP=SHR
//SYSLIN DD DSN=&&OBJETO,DISP=(OLD,DELETE)
//SYSLMOD DD DSN=NOMINA.PRUEBAS.LOADLIB(CALCNOM1),DISP=SHR
//SYSPRINT DD SYSOUT=*
//SYSUT1 DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
SYSLIN: la entrada. El mismo&&OBJETOque dejó el compilador.DISP=(OLD,DELETE)lo borra al terminar: ya no hace falta.SYSLIB: de dónde saca lo que falta. Las librerías de LE con las rutinas que el programa necesita. SiCALCNOM1llamara a subprogramas tuyos, su librería iría concatenada aquí.SYSLMOD: la salida. El miembroCALCNOM1de la librería de loads. Esta librería tiene que ser un PDSE: desde Enterprise COBOL 5 el binder produce un program object, y los program objects solo se guardan en PDSE (o en archivos de z/OS UNIX, que aquí no usamos). Con un PDS el linkedit no sirve para programas de Enterprise COBOL 5 o posterior: IBM documenta que un módulo con varias clases de texto, como los que genera este compilador, no cabe en el formato viejo, y el binder lo guarda marcado con error o no lo guarda.SYSPRINT: el reporte del binder. Trae los módulos que incluyó, el mapa del programa y los avisos. Se lee menos que el listado del compilador, pero cuando el linkedit falla, aquí está el porqué.
SYSUT1 es su dataset de trabajo. Y CEE.SCEELKEX y CEE.SCEELKED son, de nuevo, los nombres por
omisión de la documentación; tu instalación puede usar otros.
Ejecutar: PGM= y STEPLIB
El job de ejecución es el del mapa, visto ahora desde el otro lado:
//PASO01 EXEC PGM=CALCNOM1
//STEPLIB DD DSN=NOMINA.PRUEBAS.LOADLIB,DISP=SHR
PGM=CALCNOM1 es el miembro que el binder dejó en SYSLMOD, y STEPLIB es la misma librería.
El sistema busca el programa en el STEPLIB y, si no lo encuentra, en las librerías del sistema;
si no está en ninguna, el step termina con un S806 antes de ejecutar nada.
Un programa COBOL siempre necesita LE al correr: las rutinas de ejecución de SCEERUN y
SCEERUN2 tienen que estar en el orden de búsqueda del sistema, sea en el STEPLIB o en la
lista de enlace del sistema (LNKLST). En casi todas las instalaciones ya están en la lista del
sistema y el STEPLIB solo lleva tu librería; si no, van concatenadas después de la tuya, como
en el procedimiento IGYWCLG de IBM.
El recorrido completo
De arriba hacia abajo, con el DD que conecta cada paso:
NOMINA.FUENTES(CALCNOM1) NOMINA.COPYS
fuente copys
| |
| SYSIN | SYSLIB
v |
COMPILA: IGYCRCTL <------------------+
|
| SYSLIN SYSPRINT -> listado de compilación
v
&&OBJETO
módulo objeto, temporal
| CEE.SCEELKEX, CEE.SCEELKED
| SYSLIN rutinas de LE
v |
LINKEDIT: IEWBLINK <-----------------+ SYSLIB
|
| SYSLMOD SYSPRINT -> reporte del binder
v
NOMINA.PRUEBAS.LOADLIB(CALCNOM1)
program object, en un PDSE
|
| STEPLIB y PGM=CALCNOM1
v
job de ejecución (el del mapa)
En prosa: el fuente entra por SYSIN y los copys por SYSLIB; el compilador deja el listado en
SYSPRINT y el módulo objeto en SYSLIN. Ese módulo entra al binder por su propio SYSLIN, el
binder completa lo que falta desde su SYSLIB y deja el program object en SYSLMOD, que es el
miembro de la librería de loads. El job de ejecución lo encuentra por STEPLIB y PGM=.
Casi nunca vas a escribir este JCL a mano. IBM entrega procedimientos catalogados que ya lo
traen: IGYWC compila, IGYWCL compila y linkedita, IGYWCLG compila, linkedita y ejecuta. Tu
instalación suele tener el suyo, con sus librerías y sus opciones, o una herramienta que lo lanza
por ti. Lo que cambia es quién escribe el JCL; los pasos y los DD son estos.
Return codes y el COND
Cada step deja su return code. El del compilador es la severidad más alta de sus mensajes (0, 4, 8, 12 o 16, como se explica en Cómo leer un listado de compilación). El del binder va igual: 0 limpio, 4 con avisos, 8 terminó con errores, 12 un error severo no lo dejó terminar y 16 se detuvo de inmediato. Con 8, revisa su reporte antes de ejecutar.
Un step puede decidir si corre según el return code de uno anterior, con el parámetro COND del
EXEC. Se lee al revés de lo que uno espera: el step se salta si la condición es cierta. En
el ejemplo, COND=(8,LT,COMPILA) se lee “salta este step si 8 es menor que el return code de
COMPILA”. Con números:
Return code de COMPILA |
¿8 es menor que él? | LINKEDIT |
|---|---|---|
| 0 o 4 | No | Corre. |
| 8 | No | Corre. |
| 12 o 16 | Sí | Se salta. |
Es la práctica común, no una regla: IBM la usa en IGYWCL, y en IGYWCLG el step que ejecuta el
programa lleva además COND=(4,LT,LKED), es decir, no corre si el binder devolvió más de 4. Cada
instalación ajusta estos valores; hay quien linkedita solo con 0 o 4. Léelo en el JCL de tu
equipo antes de suponer.
“Compilé y sigue corriendo lo viejo”
Es el tropiezo clásico del primer mes: cambias el fuente, compilas, ejecutas, y el programa se comporta como antes. Tres causas, de la más común a la menos:
- El linkedit no corrió. La compilación terminó con 12 y el
CONDsaltó el step. El miembro de la librería de loads sigue siendo el de la vez pasada. Cómo comprobarlo: en la salida del job, compara el return code deCOMPILAcon elCONDdelLINKEDIT; si la condición se cumplió, el step no corrió: en lugar de su return code verás el mensajeIEF202Icon el textoSTEP WAS NOT RUN BECAUSE OF CONDITION CODES. SYSLMODySTEPLIBapuntan a librerías distintas. El linkedit dejó el load en una y el job de ejecución lo busca en otra. Tiene dos orígenes típicos: compilaste con un procedimiento que escribe en una librería que no es la de tu ambiente, o copiaste el JCL de ejecución de otro ambiente y elSTEPLIBse quedó con la librería de ese. Cómo comprobarlo: pon los dos JCL uno junto al otro y compara los nombres letra por letra.- El STEPLIB tiene varias librerías concatenadas. El sistema las recorre en el orden de los
DDy se queda con el primer miembro que encuentre con ese nombre. Si tuCALCNOM1está en la segunda librería y hay otroCALCNOM1en la primera, corre el de la primera. Cómo comprobarlo: busca el miembro en cada librería delSTEPLIB, en orden.
Ojo con esto: antes de buscar el error en tu código, confirma que lo que corrió es lo que compilaste. Un
DISPLAYnuevo al inicio del programa, con la fecha del cambio, te lo dice en elSYSOUTsin abrir ninguna librería.
Qué puede fallar en cada paso, y si hay SQL
| Paso | Cómo se ve | A dónde ir |
|---|---|---|
| Compilación | Return code 8 o más y mensajes al final del SYSPRINT. |
Cómo leer un listado de compilación y Los errores de compilación más comunes. |
| Linkedit | Return code 8 en LINKEDIT (4 si se linkeditó con NCAL); en su SYSPRINT, el mensaje IEW2456E con el nombre del símbolo que no encontró. |
Revisa el SYSLIB del binder y el nombre del CALL. Con 8, el binder marca el módulo como no ejecutable, salvo que se linkedite con LET; en ese caso el CALL puede acabar en un S0C1. |
| Ejecución | Abend (el sistema detuvo el programa a media ejecución) o return code alto en el job de ejecución. | Me tronó en ejecución; si es un S806, vuelve a la sección anterior. |
Si el programa tiene EXEC SQL, hay pasos adicionales que esta guía solo nombra: el SQL se procesa
antes de compilar (con el precompilador de Db2) o durante la compilación (con el coprocesador,
opción SQL), y del lado de Db2 hace falta un bind, el paso que registra en Db2 el SQL del
programa, antes de ejecutar. Tu instalación ya tiene el procedimiento para esto; cuando te toque,
pregunta cuál es.
Resumen
- Compilar produce un módulo objeto; linkeditar lo convierte en program object; ejecutar lo busca
por
STEPLIByPGM=. Sin el segundo paso, corre el programa de antes. - Compilador:
SYSINel fuente,SYSLIBlos copys en orden de búsqueda,SYSPRINTel listado,SYSLINel módulo objeto. - Binder:
SYSLINla entrada,SYSLIBlas rutinas de LE y tus subprogramas,SYSLMODel miembro en la librería de loads, que es un PDSE. COND=(8,LT,COMPILA): el linkedit se salta si 8 es menor que el return code de la compilación. Práctica común; cada instalación tiene la suya.- Si cambiaste el fuente y corre lo viejo: linkedit saltado,
SYSLMODySTEPLIBen librerías distintas, o una librería concatenada antes que la tuya. - Los términos están en el glosario del mapa.