Está en la página 1de 9

CLIST en Z/OS

Francisco Gálvez
Noviembre 2008
Francisco Gálvez – CLIST en z/OS

1
Francisco Gálvez – CLIST en z/OS

1 UTILIZACIÓN DE CLIST EN Z/OS .............................................................................................3


1.1 TIPOS DE CLIST.........................................................................................................................3
1.1.1 CLIST que realizan tareas de rutina.....................................................................................3
1.1.2 CLIST que son aplicaciones estructuradas...........................................................................4
1.1.3 CLIST que manejan aplicaciones escritas en otros lenguajes..............................................4
1.2 EJECUCIÓN DE CLISTS ..............................................................................................................4
1.3 COMO CREAR Y EJECUTAR UN CLIST ........................................................................................4
1.3.1 Ejecución de CLIST desde TSO nativo. ................................................................................5
1.3.2 Uso de variables simbólicas en CLISTs ...............................................................................6
1.3.3 Sentencias de procedimiento utilizadas en CLISTs ..............................................................6
1.3.4 Funciones y variables de control en CLISTs ........................................................................7
1.4 OTROS USOS DEL LENGUAJE CLIST ...........................................................................................8

2
Francisco Gálvez – CLIST en z/OS

1 Utilización de CLIST en z/OS


El lenguaje CLIST es un lenguaje interpretado. Como otros programas en otros lenguajes
interpretados de alto nivel, los CLIST’s son fáciles de escribir y de probar. No es necesario
compilarlos o enlazarlos. Para probar un CLIST, simplemente se ejecuta y se corrigen aquellos
errores que puedan aparecer hasta que el programa finalice sin error alguno.

Los lenguajes CLIST y REXX son los dos lenguajes de comandos disponibles desde TSO/E. El
lenguaje CLIST permite al usuario trabajar de una forma más eficiente con TSO/E.

El término CLIST (pronunciado “si list”) quiere decir Command List, y se llama de esta forma
porque la mayoría de los CLIST más básicos no son sino listas de comandos TSO/E. Cuando
se invoca un CLIST, este ejecuta los comandos TSO/E de forma secuencial.

El lenguaje de programación CLIST se utiliza para:

 Realizar tareas rutinarias (tales como introducir comandos TSO/E).

 Realizar llamadas a otros programas CLIST

 Invocar aplicaciones escritas en otros lenguajes

 Aplicaciones ISPF (tales como visualizar paneles y controlar el flujo de la aplicación).

1.1 Tipos de CLIST

Un programa CLIST realiza un amplio rango de tareas, pero la mayoría de estas pertenecen a
alguna de estas tres categorías generales:

 CLIST que realizan tareas de rutina.

 CLIST que son aplicaciones estructuradas.

 CLIST que gestionan aplicaciones escritas en otros lenguajes.

Estas categorías se describen con más detalle a continuación.

1.1.1 CLIST que realizan tareas de rutina

Cualquier usuario de TSO realiza con cierta frecuencia ciertas tareas de forma regular. Estas
tareas pueden contemplar la entrada de comandos TSO/E para comprobar el estado de los
datasets, para ubicar datasets para programas particulares o para imprimir ficheros.

Es posible escribir programas CLIST que reduzcan significativamente la cantidad de tiempo


que un usuario emplea en estas tareas rutinarias. Agrupando todas las instrucciones que se
utilizan en la realización de una tarea en un programa CLIST, se puede reducir el tiempo el
número de keystrokes y de errores cometidos en la realización de una tareas e incrementar de
esta forma la productividad. Un programa CLIST puede estar compuesto solo de comandos
TSO/E o de una combinación de comandos TSO/E y sentencias CLIST.

3
Francisco Gálvez – CLIST en z/OS

1.1.2 CLIST que son aplicaciones estructuradas

El lenguaje CLIST incluye las herramientas básicas que se necesitan para escribir aplicaciones
estructuradas completamente. Cualquier CLIST puede invocar a otro programa CLIST, lo cual
se conoce como CLIST anidados . Los CLIST puede también contener rutinas separadas
llamadas subprocedimientos. Los CLIST anidados y los subprocedimientos permiten la
separación de los CLIST en unidades lógicas y poner funciones comunes en una ubicación
única. Las sentencias específicas de CLIST permiten:

 Definir datos comunes para subprocedimientos y CLISTs anidados.

 Restringir datos a ciertos subprocedimientos y CLISTs

 Pasar datos específicos a subprocedimentos o CLISTs anidados.

Para aplicaciones interactivas, las CLISTs puede ejecutar comandos ISPF para visuales
paneles a pantalla completa. Recíprocamente, los paneles ISPF pueden invocar CLISTs
basandose en las entradas que un usuario introduce por teclado.

1.1.3 CLIST que manejan aplicaciones escritas en otros lenguajes

Supóngase que se tiene acceso a aplicaciones escritas en otros lenguajes pero las interfaces a
estas aplicaciones no son fáciles de manejar o recordar. En lugar de escribir una nueva
aplicación, se pueden escribir CLISTs que proporcionen al usuario una interfaz de fácil manejo
para estas aplicaciones.

1.2 Ejecución de CLISTs


Para ejecutar una CLIST, se utiliza el comando EXEC. Si se ejecuta desde una línea de
comandos ISPF, se debe teclear TSO al principio del comando. En el modo EDIT o TEST de
TSO/E se utiliza el subcomando EXEC tal como se utilizaría al comando EXEC. (Las CLIST
ejecutadas bajo EDIT o TEST solo pueden ejecutar subcomandos EDIT o TEST y sentencias
CLIST, pero se puede utilizar el comando END para finalizar el modo EDIT o TEST y permitir a
la CLIST ejecutar comandos TSO/E).

1.3 Como crear y ejecutar un CLIST


La creación de un CLIST es tan simple como escribir las sentencias y comandos en un
miembro de un dataset particionado o incluso de un fichero secuencial y ejecutarlo.

En el ejemplo XX se muestra una CLIST que llama a un programa COBOL.

ALLOCATE DDNAME(CUSTMAST) DSNAME(CUSTMAST.DATA)


ALLOCATE DDNAME(SYSIN) DSNAME(*)
ALLOCATE DDNAME(SYSOUT) DSNAME(*)
CALL TEST(MKTG1200) PARM(‘ENERO’)
FREE DDNAME(CUSTMAST SYSIN SYSOUT)

Ejemplo 1.3.1

Para ejecutar una CLIST desde un panel ISPF, es necesario primero alocar y activar la librería
CLIST. Tal y como se muestra en el ejemplo, el comando ALLOCATE, asigna la librería de
usuario CLIST al ddname SYSUEXEC. Esta acción establece la librería del usuario como una

4
Francisco Gálvez – CLIST en z/OS

librería de procedimientos de usuario. Después, el comando ALTLIB activa la librería de


usuario para que esta sea buscada antes que la librería de procedimientos de TSO.

TSO ALLOCATE DDNAME(SYSUEXEC) DSN(TEST.CLIST) SHR REUSE


TSO ALTLIB ACTIVATE USER(EXEC)

TSO %MKTGTEST

Ejemplo 1.3.1

Una vez que se ha activado la libreria de usuario, ya se puede ejecutar el programa CLIST
desde cualquier panel de ISPF tecleando TSO + espacio + nombre del programa CLIST.

El nombre del programa CLIST debe ir precedido de un signo %, en caso contrario, el sistema
interpreta que es un comando de sistema y lo buscará primero en sus propias librerías de
comandos. Si se antepone un signo %, entonces se le está diciendo al sistema que es un
programa CLIST y que busque primeramente en las librerías propias del usuario que están
activas. Por tanto lo más eficiente es que los nombres de las CLIST comiencen por “%”.

1.3.1 Ejecución de CLIST desde TSO nativo.

Hay dos formas de ejecutar programas CLIST desde TSO nativo, la explícita y la implícita:

En la forma explícita se utiliza el comando EXEC y se tiene que especificar la librería y el


miembro de la librería que contiene el CLIST. Dado que con el comando EXEC ya se asume
que se va a ejecutar una CLIST, no es necesario incluirla en el nombre de la librería. Es decir si
el usuario es VAL0001, entonces al teclear TEST(MKTGTEST) el sistema lo interpreta como:
VAL0001.TEST.CLIST(MKTGTEST).

En la forma implícita del comando EXEC, se puede omitir el nombre del comando y el nombre
de la librería, sin embargo antes de hacer eso, hay que tener en cuenta que hay que alocar y
activar la librería de usuario que contiene el programa CLIST mediante los comandos
ALLOCATE y ALTLIB. Una vez echo esto se ejecuta la CLIST precedida del signo %.

Por supuesto, dependiendo de la configuración de la instalación en la que se esté trabajando


es posible que la librería CLIST de cada usuario esté ya alocada y activa cuando se produce la
conexión a TSO. En tal caso no será necesario utilizar los conmandos ALLOCATE y ALTLIB
antes de la ejecución de las CLIST.

Forma explícita:

EXEC TEXT(MKTGTEST)

Forma implícita:

ALLOCATE DDNAME(SYSUEXEC) DSNAME(TEST.CLIST) SHR REUSE


ALTLIB ACTIVATE USER(EXEC)
%MKTGTEST

Ejemplo 1.3.1

5
Francisco Gálvez – CLIST en z/OS

1.3.2 Uso de variables simbólicas en CLISTs

En los programas CLIST se puede utilizar variables de la misma forma que se utilizan en otros
programas. Para pasar valores a variables de programas CLIST cuando estos se invocan es
necesario codificar un procedimiento PROC junto con los nombres de las variables al
comienzo del programa.

Cuando se ejecute el programa CLIST, se suministran los valores que se almacenarán en esas
variables previamente declaradas con el procedimiento PROC

PROC 1 MASTERDSN PARM()


ALLOCATE DDNAME(CUSTMAST) DSNAME(&MASTERDSN..DATA)
ALLOCATE DDNAME(SYSIN) DSNAME(*)
ALLOCATE DDNAME(SYSOUT) DSNAME(*)
CALL TEST(MKTG1200) PARM(‘&PARM’)
FREE DDNAME(&MASTERDSN SYSIN SYSOUT)

1.3.3 Sentencias de procedimiento utilizadas en CLISTs

Además de comandos TSO, dentro de una CLIST se pueden codificar sentencias de


procedimientos. La sentencia PROC es un ejemplo de sentencia de procedimientos.

Una sentencia de procedimientos es ejecutada por el intérprete de procedimientos, mientras


que un comando TSO es ejecutado directamente por TSO.

A continuación se listan algunas de las sentencias de procedimientos más comúnmente


utilizadas:

Sentencias de Control:

DO
DO-UNTIL
DO-WHILE
DO repeticiones
END
EXIT
GOTO
IF
SELECT
SET

Sentencias de E/S a terminal

READ
WRITE
WRITERN

Sentencias de E/S a ficheros


OPENFILE
GETFILE
PUTFILE
CLOSFILE

6
Francisco Gálvez – CLIST en z/OS

1.3.4 Funciones y variables de control en CLISTs

A continuación se muestran algunas de las funciones que se pueden utilizar en programas


CLIST:

&DATETYPE
&LENGTH
&EVAL
&STR
&SUBSTR
&SYSINDEX
&SYSDSN

Las variables de control permiten acceder y utilizar información del sistema en una CLIST. La
variable de control &LASTCC recoge siempre el código de retorno de la última sentencia
ejecutada.

&SYSUID
&LASTCC
&SYSNEST
&SYSTIME
&SYSDATE

Ejemplo de programa CLIST.

ALLOCATE DDNAME(ORDER) DSNAME(ORDER.DATA) MOD


OPENFILE ORDER OUTPUT
WRITE REALIZA TU PEDIDO DE PUBLICACIONES
WRITE
WRITE TECLEA TU NUMERO DE EMPLEADO
READ EMPNO
WRITE TECLEA TU NUMERO DE DEPARTAMENTO
READ DEPTCODE
WRITE
SET NULL =
DO UNTIL &STR(&DOCID) = &NULL
WRITE TECLEA DOCUMENTO Y CANTIDAD (BLANCO PARA FINALIZAR):
READ DOCID QUANT
IF &STR(&DOCID) ¬= &NULL THEN DO
SET ORDER = &EMPNO &SYSUID &DEPTCODE &STR(&DOCID) &QUANT
PUTFILE ORDER
END
END
WRITE
WRITE TU PEDIDO HA SIDO PROCESADO
CLOSFILE
FREE DDNAME(ORDER)

7
Francisco Gálvez – CLIST en z/OS

1.4 Otros usos del lenguaje CLIST

Aparte de ejecutar comandos TSO/E, las CLIST puede ejecutar tareas de programación más
complejas. El lenguaje CLIST incluye herramientas de programación que permiten la
codificación de grandes aplicaciones estructuradas. Las CLISTs pueden ejecutar cualquier
número de tareas complejas desde mostrar series de paneles a pantalla completa hasta
gestionar programas escritos en otros lenguajes.

Las funcionalidades del lenguaje CLIST incluyen:

 Un extensivo conjunto de operadores lógicos y aritméticos para el procesado de datos


numéricos.

 Funciones de manejo de cadenas para procesado de datos alfanuméricos.

 Sentencias CLIST que permiten estructurar los programas, realizar operaciones E/S,
definir y modificar variables y manejar errores y señales de interrupción.