Saltar al contenido
Entender conceptos

Principiante11 min de lectura

Anatomía de un programa batch

Un programa batch real tiene cientos de líneas, pero la misma forma que los ejercicios de la academia. Aquí ves esa forma con CALCNOM1 completo, división por división, y en qué orden leer un programa que no escribiste.

Al terminar sabrás

  • Qué pregunta responde cada una de las cuatro divisiones y cómo se ve en un programa real.
  • Cómo se conectan el SELECT, el FD, el copy y el ddname del JCL.
  • El esqueleto de inicio, proceso y fin, el ciclo de lectura y la revisión del file status.
  • En qué orden recorrer un programa ajeno para entenderlo en minutos.

Antes de empezar

En la academia escribiste programas de treinta líneas. El primero que abras en un proyecto tendrá quinientas, y la sensación de no saber por dónde empezar es normal. La buena noticia: la forma es la misma. Un programa batch es un programa que lee uno o varios archivos, hace algo con cada registro y escribe un resultado, sin nadie frente a una pantalla. Esta guía te enseña esa forma con CALCNOM1 completo, el mismo que conociste en El mapa del mainframe. Los términos del oficio (copy, JCL, dataset, step) están en su glosario.

Una aclaración: el CALCNOM1 que vas a ver en las guías de “Interpretar errores” tiene 480 líneas y de ahí salen los números de línea que citan. El de aquí es una versión reducida pero entera, así que sus líneas no coinciden con esos números y no las numeramos.

La forma general: cuatro divisiones, cuatro preguntas

La Language Reference agrupa un programa COBOL en cuatro divisiones, siempre en este orden. Solo la IDENTIFICATION DIVISION es obligatoria, pero un programa batch real trae las cuatro, y cada una responde una pregunta:

División Pregunta que responde En CALCNOM1
IDENTIFICATION ¿Quién soy? PROGRAM-ID. CALCNOM1.
ENVIRONMENT ¿Con qué archivos trabajo? SELECT ENTRADA ASSIGN TO EMPLEADO
DATA ¿Qué datos manejo? 01 ENT-REGISTRO PIC X(52).
PROCEDURE ¿Qué hago con ellos? PERFORM 100-INICIO

Las dos primeras son cortas. La DATA DIVISION suele ser la mitad del programa, y la PROCEDURE DIVISION la otra mitad. Cuando abras un programa largo, lo primero es ubicar dónde empieza cada una: busca DIVISION y ya tienes el mapa.

ENVIRONMENT DIVISION: con qué archivos trabajo

Aquí está la conexión que explicó el mapa: cada archivo tiene un nombre interno, el que usa el programa, y un ddname, el que busca en el JCL:

           SELECT ENTRADA ASSIGN TO EMPLEADO
                  FILE STATUS IS WS-FS-ENTRADA.

ENTRADA es el nombre del archivo dentro del programa: con él haces OPEN, READ y CLOSE. EMPLEADO es el ddname: el DD con ese nombre, en el JCL, dice qué dataset es hoy. Si no coinciden letra por letra, el OPEN devuelve file status 35.

FILE STATUS IS WS-FS-ENTRADA nombra un campo de dos caracteres, definido en WORKING-STORAGE, que COBOL llena después de cada operación sobre ese archivo. Es tu única forma de saber si el OPEN abrió, si el READ leyó o si ya no hay más registros. Cada archivo lleva el suyo.

DATA DIVISION: qué datos manejo

Tiene dos partes que se confunden al principio. La FILE SECTION describe los registros de los archivos, uno por FD:

       FD  ENTRADA
           RECORDING MODE IS F
           BLOCK CONTAINS 0 RECORDS.
       01  ENT-REGISTRO             PIC X(52).

El FD dice cómo son los registros del archivo (F, fijos) y el 01 que le sigue es el área de registro: los 52 bytes donde cae cada registro que lees, los mismos que mide el registro de CPEMPLEA.

BLOCK CONTAINS 0 RECORDS deja que el sistema decida el tamaño de bloque en ejecución, a partir del JCL o del dataset. Por eso el JCL del mapa trae RECFM y LRECL y no trae BLKSIZE: el sistema calcula el mejor tamaño.

Si omites la cláusula, el compilador asume que los registros no van en bloques, salvo que la instalación compile con la opción BLOCK0, que equivale a escribirla en cada archivo.

La WORKING-STORAGE SECTION es todo lo demás: los campos que el programa usa para trabajar. Aquí entran los copys:

       01  WS-TOTALES.
           05  WS-TOTAL-NOMINA      PIC S9(9)V99 COMP-3.
           05  WS-CONTADOR          PIC 9(5).
           05  WS-RECHAZADOS        PIC 9(5).
           COPY CPEMPLEA.

COPY CPEMPLEA trae el 01 WS-EMPLEADO con los campos del empleado, y el programa lee cada registro INTO ese grupo: el área de registro recibe los bytes y WS-EMPLEADO les da nombre. Es la forma común de trabajar con archivos cuyo layout (qué campo va en qué posición del registro) comparten varios programas.

Dos piezas más que verás en cualquier programa: los switches y los niveles 88. Un switch es un campo de un carácter que guarda un estado (“ya se acabó el archivo”). Un nivel 88 es un nombre de condición: en lugar de comparar contra un literal, le pones nombre al valor:

           05  WS-FIN-ARCHIVO       PIC X VALUE 'N'.
               88  FIN-ARCHIVO           VALUE 'S'.

Con eso escribes PERFORM UNTIL FIN-ARCHIVO en lugar de UNTIL WS-FIN-ARCHIVO = 'S', y SET FIN-ARCHIVO TO TRUE pone la 'S' por ti. Lo mismo sirve para el file status: 88 ENTRADA-OK VALUE '00' deja que preguntes IF NOT ENTRADA-OK, y 88 ENTRADA-FIN VALUE '10' reconoce el fin de archivo.

PROCEDURE DIVISION: qué hago

Casi todos los programas batch tienen el mismo esqueleto, y suele estar en el primer párrafo:

       000-PRINCIPAL.
           PERFORM 100-INICIO
           PERFORM 150-LEE-EMPLEADO
           PERFORM UNTIL FIN-ARCHIVO
              PERFORM 200-ACUMULA-EMPLEADO
              PERFORM 150-LEE-EMPLEADO
           END-PERFORM
           PERFORM 300-FIN
           GOBACK.

Inicio, proceso y fin. El inicio abre los archivos e inicializa; el proceso es un ciclo que trata un registro a la vez; el fin escribe los totales y cierra. Cada parte es un párrafo, y PERFORM lo ejecuta y regresa a la línea siguiente. Los números al frente (100, 200, 9999) son una convención para que el orden de lectura coincida con el de ejecución; cada equipo tiene la suya y no es una regla de COBOL.

El ciclo de lectura. Fíjate en el orden: se lee una vez antes del ciclo, y dentro del ciclo primero se procesa y luego se lee el siguiente. Así, cuando el READ llega al final del archivo, el ciclo se detiene sin procesar un registro vacío. El READ lo dice con AT END, y el programa lo guarda en el switch:

           READ ENTRADA INTO WS-EMPLEADO
              AT END
                 SET FIN-ARCHIVO TO TRUE
           END-READ

¿Por qué hay un switch FIN-ARCHIVO y además el 88 ENTRADA-FIN sobre el file status, si los dos dicen lo mismo? Porque sirven para cosas distintas. El file status cambia con cada operación: después del CLOSE ya no vale '10'. El switch lo pones tú y se queda hasta que lo cambies; por eso es el que gobierna el ciclo. El 88 sobre el file status sirve para distinguir, justo después del READ, el fin de archivo (file status 10, que no es error) de un error de verdad.

Revisar el file status después de cada operación. OPEN, READ, WRITE y CLOSE: cada uno deja su resultado en el campo, y el programa lo revisa en seguida. Si no es 00 ni el fin de archivo esperado, avisa y termina con error. Un file status que nadie revisa es un programa que sigue con datos que no leyó, o que truena más adelante en una línea que no tiene la culpa.

Cómo termina. GOBACK en el programa principal termina la ejecución, igual que STOP RUN; los dos cierran los archivos que quedaron abiertos y devuelven el control al sistema. Lo que el sistema recibe es el valor del registro especial RETURN-CODE, que vale cero salvo que tú le pongas otra cosa:

           IF WS-RECHAZADOS > ZERO
              MOVE 4 TO RETURN-CODE
           END-IF.

Ese valor es el COND CODE que ves en el JESYSMSG, los mensajes del sistema en la salida del job, y el que el COND del siguiente step evalúa, como verás en Del fuente a la ejecución. La convención común: 0 todo bien, 4 terminó con avisos, 8 o más terminó mal.

Lo que no está en este programa, y verás en otros: EXEC SQL para hablar con Db2, CALL a subprogramas, tablas con OCCURS, SORT, reportes con cortes de control y programas en línea (CICS), que este sitio todavía no cubre. Cada uno agrega piezas, pero no cambia el esqueleto.

El programa completo

Este es CALCNOM1 entero: lee EMPLEADO, acumula el importe de cada empleado y escribe una línea de totales en TOTALES. Está escrito con dos costumbres que te ahorran errores de compilación: terminadores explícitos (END-IF, END-READ, END-PERFORM) y un solo punto al final de cada párrafo.

       IDENTIFICATION DIVISION.
       PROGRAM-ID. CALCNOM1.
      *----------------------------------------------------------------
      * ACUMULA LA NOMINA DE LA QUINCENA Y ESCRIBE UNA LINEA DE TOTALES
      * ENTRADA: EMPLEADO (FB DE 52)   SALIDA: TOTALES (FB DE 80)
      *----------------------------------------------------------------
       ENVIRONMENT DIVISION.
       INPUT-OUTPUT SECTION.
       FILE-CONTROL.
           SELECT ENTRADA ASSIGN TO EMPLEADO
                  FILE STATUS IS WS-FS-ENTRADA.
           SELECT SALIDA  ASSIGN TO TOTALES
                  FILE STATUS IS WS-FS-SALIDA.
       DATA DIVISION.
       FILE SECTION.
       FD  ENTRADA
           RECORDING MODE IS F
           BLOCK CONTAINS 0 RECORDS.
       01  ENT-REGISTRO             PIC X(52).
       FD  SALIDA
           RECORDING MODE IS F
           BLOCK CONTAINS 0 RECORDS.
       01  SAL-REGISTRO             PIC X(80).
       WORKING-STORAGE SECTION.
       01  WS-FILE-STATUS.
           05  WS-FS-ENTRADA        PIC XX.
               88  ENTRADA-OK            VALUE '00'.
               88  ENTRADA-FIN           VALUE '10'.
           05  WS-FS-SALIDA         PIC XX.
               88  SALIDA-OK             VALUE '00'.
       01  WS-SWITCHES.
           05  WS-FIN-ARCHIVO       PIC X VALUE 'N'.
               88  FIN-ARCHIVO           VALUE 'S'.
       01  WS-TOTALES.
           05  WS-TOTAL-NOMINA      PIC S9(9)V99 COMP-3.
           05  WS-CONTADOR          PIC 9(5).
           05  WS-RECHAZADOS        PIC 9(5).
           COPY CPEMPLEA.
       01  WS-LINEA-TOTAL.
           05  FILLER               PIC X(16) VALUE 'TOTAL NOMINA:   '.
           05  WS-TOTAL-EDIT        PIC Z(8)9.99-.
           05  FILLER               PIC X(14) VALUE '  EMPLEADOS:  '.
           05  WS-CONTADOR-EDIT     PIC Z(4)9.
           05  FILLER               PIC X(14) VALUE '  RECHAZADOS: '.
           05  WS-RECHAZADOS-EDIT   PIC Z(4)9.
           05  FILLER               PIC X(13) VALUE SPACES.
       PROCEDURE DIVISION.
       000-PRINCIPAL.
           PERFORM 100-INICIO
           PERFORM 150-LEE-EMPLEADO
           PERFORM UNTIL FIN-ARCHIVO
              PERFORM 200-ACUMULA-EMPLEADO
              PERFORM 150-LEE-EMPLEADO
           END-PERFORM
           PERFORM 300-FIN
           GOBACK.

       100-INICIO.
           INITIALIZE WS-TOTALES
           OPEN INPUT ENTRADA
           IF NOT ENTRADA-OK
              DISPLAY 'ERROR AL ABRIR EMPLEADO. FS: ' WS-FS-ENTRADA
              PERFORM 9999-TERMINA-CON-ERROR
           END-IF
           OPEN OUTPUT SALIDA
           IF NOT SALIDA-OK
              DISPLAY 'ERROR AL ABRIR TOTALES. FS: ' WS-FS-SALIDA
              PERFORM 9999-TERMINA-CON-ERROR
           END-IF.

       150-LEE-EMPLEADO.
           READ ENTRADA INTO WS-EMPLEADO
              AT END
                 SET FIN-ARCHIVO TO TRUE
           END-READ
           IF NOT ENTRADA-OK AND NOT ENTRADA-FIN
              DISPLAY 'ERROR AL LEER EMPLEADO. FS: ' WS-FS-ENTRADA
              PERFORM 9999-TERMINA-CON-ERROR
           END-IF.

       200-ACUMULA-EMPLEADO.
           IF WS-IMPORTE IS NUMERIC
              ADD WS-IMPORTE TO WS-TOTAL-NOMINA
              ADD 1 TO WS-CONTADOR
           ELSE
              PERFORM 9000-REGISTRA-RECHAZO
           END-IF.

       300-FIN.
           MOVE WS-TOTAL-NOMINA TO WS-TOTAL-EDIT
           MOVE WS-CONTADOR     TO WS-CONTADOR-EDIT
           MOVE WS-RECHAZADOS   TO WS-RECHAZADOS-EDIT
           WRITE SAL-REGISTRO FROM WS-LINEA-TOTAL
           IF NOT SALIDA-OK
              DISPLAY 'ERROR AL ESCRIBIR TOTALES. FS: ' WS-FS-SALIDA
              PERFORM 9999-TERMINA-CON-ERROR
           END-IF
           CLOSE ENTRADA
           IF NOT ENTRADA-OK
              DISPLAY 'ERROR AL CERRAR EMPLEADO. FS: ' WS-FS-ENTRADA
              PERFORM 9999-TERMINA-CON-ERROR
           END-IF
           CLOSE SALIDA
           IF NOT SALIDA-OK
              DISPLAY 'ERROR AL CERRAR TOTALES. FS: ' WS-FS-SALIDA
              PERFORM 9999-TERMINA-CON-ERROR
           END-IF
           DISPLAY 'CALCNOM1 TERMINO. EMPLEADOS: ' WS-CONTADOR
                   ' RECHAZADOS: ' WS-RECHAZADOS
           IF WS-RECHAZADOS > ZERO
              MOVE 4 TO RETURN-CODE
           END-IF.

       9000-REGISTRA-RECHAZO.
           ADD 1 TO WS-RECHAZADOS
           DISPLAY 'IMPORTE NO NUMERICO. EMPLEADO: ' WS-NUM-EMPLEADO.

       9999-TERMINA-CON-ERROR.
           MOVE 16 TO RETURN-CODE
           STOP RUN.

Cuatro cosas que conviene notar:

  • 200-ACUMULA-EMPLEADO es el párrafo corregido de Me tronó en ejecución. El IS NUMERIC es lo que evita el S0C7 cuando el importe viene con espacios; el rechazo se cuenta y se reporta en lugar de tirar la nómina.
  • 9999-TERMINA-CON-ERROR termina con STOP RUN y return code 16. Como se llega a él con PERFORM, es de esperarse un IGYOP3093-W, el “este PERFORM no puede regresar” de Los errores de compilación más comunes. Si sale, aquí es intencional: el programa debe terminar en ese párrafo.
  • WS-LINEA-TOTAL mide 80 bytes exactos, los del FD de salida y los del LRECL=80 del JCL. Los campos Z(8)9.99- y Z(4)9 son numéricos editados: ponen el número con punto decimal y sin ceros a la izquierda para que se lea.
  • ENT-REGISTRO casi no aparece en la PROCEDURE DIVISION. El READ ... INTO lo copia a WS-EMPLEADO, y el programa trabaja con los nombres del copy.

Cómo leer un programa que no escribiste

No lo leas de arriba abajo. Recórrelo en este orden, y en diez minutos sabes qué hace:

  1. FILE-CONTROL. Cuántos archivos hay, cuáles son de entrada y cuáles de salida (lo dice el OPEN, búscalo), y sus ddnames. Con eso ya puedes mirar el JCL y saber qué datasets toca.
  2. Los FD y los copys. Cómo son los registros: largo, campos, cuáles son numéricos. Si el layout viene de un copy, abre el copy; es donde están los nombres que vas a ver después.
  3. El primer párrafo de la PROCEDURE DIVISION. Es el esqueleto: inicio, ciclo, fin. Ahí ves de un vistazo si el programa lee uno o varios archivos, si hay un ciclo o varios, y cómo termina.
  4. De ahí hacia abajo, siguiendo cada PERFORM. Entra al párrafo del ciclo, y de él a los que llama. Los párrafos de inicio y fin los lees al final; casi siempre son OPEN, INITIALIZE, CLOSE y totales.

Los prefijos (WS-, ENT-, SAL-), la numeración y el orden de las secciones te ayudan a orientarte, pero son la convención de ese equipo. Si el programa que abres usa otra, ajústate a la suya; lo que no cambia es el recorrido.

Resumen

  • Cuatro divisiones, cuatro preguntas: quién soy, con qué archivos trabajo, qué datos manejo, qué hago.
  • SELECT ... ASSIGN TO ddname conecta el programa con el DD del JCL; FILE STATUS es el campo que revisas después de cada OPEN, READ, WRITE y CLOSE.
  • FILE SECTION para los registros de los archivos; WORKING-STORAGE para todo lo demás, copys incluidos. Los niveles 88 ponen nombre a los valores.
  • Esqueleto: inicio, ciclo con lectura inicial y AT END, fin. GOBACK o STOP RUN devuelven el RETURN-CODE, que el JCL ve como COND CODE.
  • Para leer un programa ajeno: archivos, registros, primer párrafo y de ahí siguiendo los PERFORM.
  • Los términos están en el glosario del mapa.