Saltar al contenido
Moverse en TSO/ISPF

Principiante13 min de lectura

ISPF para escribir código

Ya sabes abrir un miembro y escribir línea por línea. Aquí están los comandos del editor que te ahorran horas, organizados por lo que quieres hacer, con un antes y un después sobre CALCNOM1.

Al terminar sabrás

  • Las dos zonas del editor y qué tipo de comando va en cada una.
  • Moverte, copiar, mover, borrar y corregir columnas sin teclear de más.
  • Ocultar lo que no importa, buscar y cambiar con control, y deshacer sin miedo.
  • Reutilizar código entre miembros y trabajar sin salir del editor.

Antes de empezar

Esta guía es para cuando ya sabes abrir un miembro en el editor de ISPF y escribir código, pero lo haces línea por línea. Cada sección parte de algo que quieres hacer y enseña solo los comandos que lo resuelven. La lista completa, en tabla, es la siguiente guía, la chuleta.

Dos avisos que valen para toda la guía. Las teclas de función (F7, F8, F5…) son la asignación de fábrica de ISPF; cada instalación o emulador puede cambiarlas, y por eso siempre verás el comando junto a la tecla. Con KEYS en la línea de comandos ves las tuyas. Y las pantallas muestran solo las líneas que importan, con los números del CALCNOM1 de Anatomía de un programa batch contados desde la IDENTIFICATION DIVISION; son los números del editor, no los de un listado de compilación.

Las dos zonas del editor

Todo lo que tecleas en el editor va en una de dos zonas, y saber cuál es ordena el resto de la guía:

  • La línea de comandos, Command ===>, arriba. Ahí van los comandos primarios: los que actúan sobre todo el miembro o sobre un rango (FIND, CHANGE, SAVE).
  • El área de números, a la izquierda de cada línea. Ahí van los comandos de línea: los tecleas encima del número de la línea sobre la que quieres actuar (D para borrar, C para copiar). Puedes teclear varios y luego dar Enter una sola vez.

Si tecleaste un comando de línea a medias o te arrepentiste, RESET en la línea de comandos limpia el área de números y deja la pantalla como estaba: quita los comandos pendientes, las marcas de cambio y error, las líneas especiales (como la regla de columnas) y vuelve a mostrar las líneas excluidas. Lo único que no toca son las etiquetas; para eso está RESET LABEL.

“Quiero llegar a esa parte del programa”

F7 y F8 (UP y DOWN) mueven la pantalla hacia arriba y hacia abajo lo que diga el campo Scroll ===> de la esquina: PAGE una pantalla, HALF media, CSR hasta donde esté el cursor. CSR es el más cómodo para código: pones el cursor en la línea que quieres arriba y das F8. Si tecleas M en la línea de comandos y das F7 o F8, vas al principio o al final del miembro.

LOCATE (o L) con un número pone esa línea al principio de la pantalla: LOCATE 89 te lleva a 300-FIN. También funciona con una etiqueta: un nombre que le pones a una línea tecleando .A (un punto y hasta cinco letras) sobre su número. La etiqueta se queda con la línea aunque se mueva, y LOCATE .A vuelve a ella. Las etiquetas sirven además para marcar rangos, como verás en las secciones que siguen.

“Quiero insertar, borrar, repetir, copiar o mover líneas”

Estos son comandos de línea, y todos siguen la misma lógica: la letra sola actúa sobre una línea, con un número actúa sobre esa cantidad de líneas, y la letra doble marca el principio y el final de un bloque.

  • I inserta líneas en blanco debajo; I3 inserta tres. Las que dejes vacías desaparecen al dar Enter.
  • D borra la línea; D4 borra cuatro; DD en la primera y en la última borra el bloque.
  • R repite la línea debajo de sí misma; R2 la repite dos veces; RR repite el bloque.
  • C/CC copia y M/MM mueve. Los dos necesitan un destino: A (after, después de esa línea) o B (before, antes).

Quieres que el OPEN OUTPUT SALIDA tenga la misma revisión del file status (el código que COBOL deja después de cada operación con un archivo) que el OPEN INPUT. En el ejemplo se supone que esa revisión aún no está escrita, así que el párrafo termina en la línea 65, con su punto. Marcas el bloque con CC y el destino con A:

Command ===>                                                  Scroll ===> CSR
000060            OPEN INPUT ENTRADA
CC0061            IF NOT ENTRADA-OK
000062               DISPLAY 'ERROR AL ABRIR EMPLEADO. FS: ' WS-FS-ENTRADA
000063               PERFORM 9999-TERMINA-CON-ERROR
CC0064            END-IF
A00065            OPEN OUTPUT SALIDA.

Enter:

000060            OPEN INPUT ENTRADA
000061            IF NOT ENTRADA-OK
000062               DISPLAY 'ERROR AL ABRIR EMPLEADO. FS: ' WS-FS-ENTRADA
000063               PERFORM 9999-TERMINA-CON-ERROR
000064            END-IF
000065            OPEN OUTPUT SALIDA.
000066            IF NOT ENTRADA-OK
000067               DISPLAY 'ERROR AL ABRIR EMPLEADO. FS: ' WS-FS-ENTRADA
000068               PERFORM 9999-TERMINA-CON-ERROR
000069            END-IF

El bloque copiado todavía dice ENTRADA, y el punto del párrafo sigue en la 65; las dos cosas se arreglan en la sección de buscar y cambiar. Si el bloque no cabe en una pantalla, no pasa nada: tecleas el primer CC, te desplazas con F8 (o con FIND o LOCATE) y tecleas el segundo. Y si das Enter antes de poner el destino, el editor muestra un aviso de copia o movimiento pendiente y espera a que teclees A o B.

“Se me corrió una columna”

En formato fijo, el de siempre en el mainframe, cada columna tiene dueño, y un código corrido una columna compila con errores aunque se vea bien; lo explica la sección de columnas de Los errores de compilación más comunes. Tres comandos de línea lo resuelven:

  • COLS sobre cualquier línea inserta una regla de columnas justo debajo, que se mueve con el código. RESET la quita, junto con las demás líneas especiales.
  • ) desplaza la línea a la derecha y ( a la izquierda, dos columnas si no dices cuántas: )1 mueve una. En bloque, )) y (( en la primera y la última línea.

Pegaste un párrafo desde otro lado y dos líneas quedaron fuera de lugar: el nombre del párrafo en la columna 12, que es área B (la de las sentencias), y un MOVE en la columna 11. Con COLS lo ves, y con ( y ) lo acomodas:

=COLS> ----+----1----+----2----+----3----+----4----+----5----+----6----+----7--
(40089            300-FIN.
)10090           MOVE WS-TOTAL-NOMINA TO WS-TOTAL-EDIT
000091            MOVE WS-CONTADOR     TO WS-CONTADOR-EDIT

Enter:

=COLS> ----+----1----+----2----+----3----+----4----+----5----+----6----+----7--
000089        300-FIN.
000090            MOVE WS-TOTAL-NOMINA TO WS-TOTAL-EDIT
000091            MOVE WS-CONTADOR     TO WS-CONTADOR-EDIT

El párrafo quedó en la columna 8 y el MOVE en la 12. Las fichas de la columna 7 y del área A y B explican qué dice el compilador cuando no lo corriges.

Ojo con esto: ( borra sin avisar lo que se salga del límite izquierdo. Antes de desplazar un bloque grande a la izquierda, mira cuál es la línea que más a la izquierda empieza.

“Quiero ver solo las líneas que usan este campo”

El editor puede excluir líneas: no las borra, las esconde detrás de una línea punteada que dice cuántas hay. Sirve para leer un programa largo como si fuera corto.

  • X excluye la línea; X5 cinco; XX un bloque. La línea punteada se vuelve a abrir con F (las primeras), L (las últimas) o S (las menos indentadas: los nombres de párrafo, por ejemplo). RESET (o RESET EXCLUDED, si solo quieres eso) muestra todo otra vez.
  • La combinación que más vas a usar: X ALL en la línea de comandos, y luego FIND algo ALL. Se excluye todo y FIND vuelve a mostrar solo las líneas donde encontró la cadena.

Quieres ver dónde se usa WS-FS-ENTRADA:

Command ===> X ALL
Command ===> FIND WS-FS-ENTRADA ALL
- - - - - - - - - - - - - - - - - - - - - - - - - - -  10 Line(s) not Displayed
000011                   FILE STATUS IS WS-FS-ENTRADA.
- - - - - - - - - - - - - - - - - - - - - - - - - - -  14 Line(s) not Displayed
000026            05  WS-FS-ENTRADA        PIC XX.
- - - - - - - - - - - - - - - - - - - - - - - - - - -  35 Line(s) not Displayed
000062               DISPLAY 'ERROR AL ABRIR EMPLEADO. FS: ' WS-FS-ENTRADA
- - - - - - - - - - - - - - - - - - - - - - - - - - -  14 Line(s) not Displayed
000077               DISPLAY 'ERROR AL LEER EMPLEADO. FS: ' WS-FS-ENTRADA
- - - - - - - - - - - - - - - - - - - - - - - - - - -  22 Line(s) not Displayed
000100               DISPLAY 'ERROR AL CERRAR EMPLEADO. FS: ' WS-FS-ENTRADA
- - - - - - - - - - - - - - - - - - - - - - - - - - -  20 Line(s) not Displayed

Cinco líneas, el campo completo de un vistazo. Dos comandos más aprovechan lo excluido: DELETE ALL X borra todas las líneas excluidas y DELETE ALL NX todas las que no lo están. Es la forma rápida de quedarte solo con lo que encontró un FIND, o de tirar justo eso.

“Quiero buscar y cambiar”

FIND (o F) busca la siguiente aparición de una cadena desde el cursor. Los operandos cambian cómo busca:

  • Cuáles: ALL todas (y te dice cuántas), FIRST la primera, LAST la última, PREV hacia atrás.
  • Dónde: en columnas (FIND MOVE 12 solo si empieza en la 12; con dos columnas, solo si la cadena cabe entera entre ellas) o en un rango de etiquetas (.A .B).
  • Qué: la cadena entre comillas simples no distingue mayúsculas; C'...' exige mayúsculas exactas, y X'...' busca bytes en hexadecimal.

Las columnas y el hexadecimal juntos son el FIND X'4040404040' 48 52 de Me tronó en ejecución: cinco espacios, solo entre las columnas 48 y 52.

CHANGE (o C) tiene los mismos operandos y una cadena más: CHANGE vieja nueva cambia la siguiente; CHANGE vieja nueva ALL cambia todas. F5 (RFIND) repite la última búsqueda y F6 (RCHANGE) el último cambio, una aparición a la vez: es la forma segura de cambiar revisando cada caso.

Volvamos al bloque que copiaste: quieres cambiar ENTRADA por SALIDA solo ahí. Marcas el rango con etiquetas, tecleando .A y .B sobre los números de la primera y la última línea:

Command ===> CHANGE ENTRADA SALIDA ALL .A .B
.A                IF NOT ENTRADA-OK
000067               DISPLAY 'ERROR AL ABRIR EMPLEADO. FS: ' WS-FS-ENTRADA
000068               PERFORM 9999-TERMINA-CON-ERROR
.B                END-IF

Enter:

.A                IF NOT SALIDA-OK
000067               DISPLAY 'ERROR AL ABRIR EMPLEADO. FS: ' WS-FS-SALIDA
000068               PERFORM 9999-TERMINA-CON-ERROR
.B                END-IF

Cambió el IF y el campo, pero el texto del DISPLAY sigue diciendo EMPLEADO. Un CHANGE ALL cambia exactamente lo que le pediste y nada más; por eso después de uno se revisa el resultado antes de seguir. Falta un segundo cambio en el mismo rango:

Command ===> CHANGE EMPLEADO TOTALES ALL .A .B

Y por último, con el bloque listo, mueves el punto del párrafo: lo quitas de la línea 65 y se lo pones a la 69, que ahora lo cierra. Las etiquetas se quitan con RESET LABEL, o borrándolas una por una del área de números.

Para un renombre en todo el miembro no hace falta rango. Decides llamar WS-RECHAZOS al contador WS-RECHAZADOS:

Command ===> CHANGE WS-RECHAZADOS WS-RECHAZOS ALL

Cambia la definición en la línea 37 y todos los usos, incluidas las apariciones dentro de WS-RECHAZADOS-EDIT, que también se renombra. Aquí eso es lo que quieres; cuando no lo sea, el operando WORD limita el cambio a la palabra completa. Y después de cualquier CHANGE ALL, FIND WS-RECHAZADOS ALL confirma que no quedó ninguna.

“No quiero perder lo que hice”

  • SAVE guarda sin salir. END (F3) sale y, con la configuración habitual del perfil, guarda si cambiaste algo. CANCEL sale sin guardar nada desde el último SAVE.
  • UNDO deshace la última interacción, es decir, todo lo que hiciste entre un Enter y el siguiente; repetido, deshace la anterior, y así. Solo funciona si el editor está guardando el historial: con RECOVERY ON en el perfil, o con SETUNDO si tu instalación lo habilitó. Un CHANGE ALL que cambió de más se deshace con un UNDO.
  • PROFILE muestra tu perfil de edición, las opciones que el editor recuerda para este tipo de miembro. Cuatro que conviene entender: CAPS convierte a mayúsculas lo que tecleas; NULLS hace que los espacios al final de cada línea sean nulos, para poder meter caracteres en medio de la línea con la tecla de inserción (Ins); NUMBER numera las líneas en el campo estándar o en el campo COBOL; y RECOVERY guarda cada cambio en un dataset de recuperación, que permite UNDO y recuperar la sesión si se cae la conexión.

Ojo con esto: SAVE reinicia el historial de UNDO: después de guardar ya no puedes deshacer nada de lo anterior, con RECOVERY o con SETUNDO, salvo que uses SETUNDO KEEP, que conserva el historial al guardar. Guarda antes de un cambio grande, y si sale mal, UNDO o CANCEL te regresan justo a ese punto.

“Este pedazo ya lo escribí en otro lado”

  • COPY miembro trae un miembro completo de la misma librería al miembro que editas. Como no sabe dónde ponerlo, marcas el destino con A o B en el área de números antes de dar Enter. Sin nombre, COPY abre un panel para elegir.
  • CUT y PASTE mueven líneas entre miembros a través de un portapapeles. CUT con un rango (.A .B, o líneas marcadas con C/M) guarda las líneas; abres el otro miembro, marcas el destino con A o B y tecleas PASTE.
  • CREATE miembro crea un miembro nuevo con las líneas que marques con C o M; REPLACE miembro hace lo mismo sobre uno que ya existe (y lo crea si no).

El párrafo 9999-TERMINA-CON-ERROR lo vas a querer en todos tus programas. Lo sacas a un miembro propio marcándolo con CC y tecleando el comando:

Command ===> CREATE TERMERR
CC0118        9999-TERMINA-CON-ERROR.
000119            MOVE 16 TO RETURN-CODE
CC0120            STOP RUN.

En tu próximo programa, COPY TERMERR con una A en la línea donde lo quieres lo trae de vuelta. Si tu equipo guarda estas piezas en una librería de copys, el camino es el COPY de COBOL del mapa, no este; pregunta cuál usan.

“Quiero ver mejor”

  • HILITE COBOL colorea palabras reservadas, literales y comentarios según el lenguaje; HILITE JCL para un JCL; HILITE solo abre un panel con las opciones. Depende de que la instalación lo tenga habilitado.
  • HEX ON muestra debajo de cada carácter sus dos nibbles (cada mitad del byte) en hexadecimal, en dos renglones; sirve para ver el mismo registro con espacios en el importe que provoca el abend en Me tronó en ejecución. HEX OFF lo quita.

“Sin salir del editor”

  • SUBMIT manda a JES (el componente que recibe los jobs) el miembro que estás editando, si es un JCL. Con un rango (SUBMIT .A .B) manda solo esas líneas.
  • F2 (SPLIT) parte la pantalla en dos sesiones de ISPF por donde esté el cursor, y F9 (SWAP) salta de una a otra. Es la forma de tener el programa en una mitad y el copy, o el listado, en la otra.
  • RETRIEVE vuelve a poner en la línea de comandos el último comando que tecleaste; repetido, el anterior. Muchas instalaciones lo asignan a F12, pero con otras configuraciones F12 es CANCEL: oprimirlo creyendo que es RETRIEVE puede sacarte del editor sin guardar. Revisa con KEYS antes de usarlo.
  • = seguido de una opción salta directo a ella desde cualquier panel: =3.4 suele ser la lista de datasets. El número de cada opción es el del menú de tu instalación.

Resumen

  • Comandos primarios en Command ===>; comandos de línea encima del número. RESET limpia.
  • Moverte: F7 y F8 con Scroll CSR, M + F7/F8 para los extremos, LOCATE con número o etiqueta.
  • I, D, R, C, M solos, con número o dobles para bloques; A y B marcan el destino.
  • COLS para ver columnas, ( y ) para mover una o varias líneas.
  • X ALL y FIND algo ALL para ver solo lo que importa; DELETE ALL X o NX para quedarte con ello o tirarlo.
  • FIND y CHANGE con ALL, columnas y etiquetas; F5 y F6 para repetir uno por uno. Un CHANGE ALL se revisa.
  • SAVE, END, CANCEL; UNDO con RECOVERY ON. COPY, CUT, PASTE, CREATE, REPLACE para reutilizar.
  • La lista completa, con todo lo que aquí no cupo, es la siguiente guía: la chuleta.