REXXAvanzado

Copyright © 2005 - N. Bocalandro 1

Advanced REXX – Programación Profesional


Advanced REXX – Capítulo 4

Se espera que un REXX cumpla una serie de requisitos para que se lo considere “profesional” o avanzado:Estandares prediseñados por la instalación.RAS (Reliability,Availability,Serviciability)Signal ON .Diagnóstico automático.Documentación.Pseudo código (si fuera necesario).

Porque “avanzado”



Buenos comentarios. (Un comentario por linea si es posible o necesario) Layout

1. Prólogo que contiene: Función de esta REXX. Descripción de parámetros de invocación (detallada y sus defaults) Descripción de TODOS los códigos de retorno. Programas o REXX externas llamadas. Quienes invocan a esta REXX y desde que entorno (si es posible). Descripción breve de subrutinas/funciones internas principales. Historia de los cambios.

2. Codigo principal.

3. Subrutinas (con su propio prólogo).

4. Rutinas de recovery (con su propio prólogo).

Nombre de variables “lógicos” y breves. Diseño del flujo estructurado, natural y de acuerdo al usuario. Analizar SIEMPRE los códigos de retorno de los comandos externos. Evitar a toda costa “trucos” que demuestran que se mucho de REXX. Códigos de retorno lógicos y DOCUMENTADOS.

Guidelines



Signal es “equivalante” a “GO TO” pero tiene otros usos mejores.+--------------------------------------------------+¦ ¦¦ >>--SIGNAL----labelname--------;-------------->< ¦ Goto labelname¦ +---expression------¦ ¦ Goto contenido expression ¦ ¦ +-VALUE-+ ¦ ¦ Idem anterior ¦ +-OFF---ERROR-------¦ ¦ Disable traps ¦ ¦ +-FAILURE-¦ ¦ ¦¦ ¦ +-HALT----¦ ¦ ¦¦ ¦ +-NOVALUE-¦ ¦ ¦¦ ¦ +-SYNTAX--+ ¦ ¦¦ +-ON---ERROR--------+ ¦ Enable traps RC¬=0¦ +-FAILURE-¦ +-NAME--trapname-+ ¦ Idem anterior (casi igual)¦ +-HALT----¦ ¦ Interrupción ¦ +-NOVALUE-¦ ¦ Variable no asignada¦ +-SYNTAX--+ ¦ Error de sintaxis ¦ ¦+--------------------------------------------------+ trapname es el label de la rutina de recovery

Signal

Ver ‘TSO/E REXX Reference’ en ‘TSO/E Bookshelf’ para su uso



El esfuerzo de testeo depende de que tan intensivo va a ser su uso y quien la va a usar (nosotros, usuarios finales, etc).

Testear TODAS las lineas de código. Forzar errorres ya sea en datos como dentro de la misma REXX. Usar la instrucción TRACE para el testeo.

1. TRACE R (results)2. Trace N (normal )3. Trace O (OFF)4. A, C, E, F, I, L, S, ?, ! (otras opciones)

EXECUTIL TS (antes de ejecutar la exec fuerza el TRACE desde afuera) TRACE() (Función muy util) Comandos inmediatos útiles para toda ocasión (PA1 mediante):

1. HE – Halt execution2. HI – Halt execution3. TS – Trace start4. TE – Trace end

Testeo de una REXX



Si no encuentra un label busca una REXX externa con ese nombre. Todo es igual “salvo” que no comparten el pool de variables. Si es una función cambia ligeramente la sintaxis: EJ: ........

parm1=6 /* valor para la función */

a= rutina1(parm1) /* invoco la funcion y el resultado

lo pongo en A */

say a /* se verá 3 en la pantalla */

Exit /* Fin de la exec */

Rutina1: /* comienza la función */

arg p1 /* leo el argumento */

z = p1 / 2 /* codigo de la función */

Return z /* retorno con el resultado */

Subrutinas y funciones (cont)



Hasta ahora hemos visto que hay variables. Un arreglo especial de variables es denominado STEM. Un STEM es un vector (o una matriz) y se compone de n elementos. Cada uno se denomina xxxx.subindice donde xxxx es el nombre del

stem y subindice es el nombre del elemento (un vector) o xxxx.x.y donde xxxx es el nombre del stem y X e Y son los

subindices de la matriz, en este caso de 2 dimensiones, pero puede ser de tantas como les de la memoria de la máquina.

EJ: A.1=Norberto

A.2 =Pepe

A.3=Carlos

A.0=3 (un caso típico en vectores, en el elemento 0 de pone la longitud del vector)

Manejo de datos

Vector de 3 elementos



Una matriz contiene mas de un subindice. STEM.X.Y.Z es una matriz tridimensional. EJ: A.1.1.1=Norberto

A.1.1.2=Pepe

A.1.1.3=Carlos

A.1.2.1=Fernando

A.1.2.2=Diego

A.1.2.3=Yugo

A.2.1.1=Guille

A.2.2.1=Ricardo

A.0.2.1=Miguel

Manejo de datos (cont.)

Matriz tridimensional


Advanced REXX – Ejercicio 5

1. Escribir una REXX de manera “profesional” hasta donde hemos visto.

2. Invocar una subrutina interna que divida una variable por 2 y haga display de la misma

3. Igual al anterior pero con una función interna.

4. Igual a las 2 anteriores pero con subrutina o funciones externas.

5. Usar SIGNAL ON ... en la primera de las REXX de este ejercicio.

6. Use trace para Debug

7. Intente algo mas complicado (use los conocimiento del curso previo) por ejemplo un STEM con valores numéricos de entrada y de salida otro STEM con los mismos valores multiplicados por los elementos correspondientes de un tercer STEM. (Multiplicaciòn de vectores).

Manos a la obra



Un comando externo es denominado Host command, y puede ser de TSO de ISPF, de Netview, etc.

A cada uno de esos entornos los llamaremos Host command enviroment.

Por default se va a TSO, pero puedo alterar esto con la sentencia REXX address(xxxxxx) donde xxxxx es el enviroment que deseo usar.

Para volver al anterior enviroment uso address(). EJ:

Address(TSO) /* switch a TSO */

“TIME” /* ejecuto el comando TIME */

Address() /* vuelvo al entorno anterior */

Address TSO “TIME” /* es equivalente a lo anterior */

Host commands



Enviroments disponibles: TSO ISPEXEC ISREDIT CONSOLE MVS LINK/ATTACH APPCMVS Provisto por algun producto (ej: Netview) Escrito por Uds.

RECUERDEN SIEMPRE ANALIZAR EL CÓDIGO DE RETORNO DE LOS COMANDOS (viene en la variable llamada RC)

Host enviroments



Se pueden ejecutar comandos de:1. TSO2. IDCAMS3. RACF4. HSM5. TCP/IP6. OMVS7. Productos con interface a TSO

O bien 1. Programas 2. Clist o REXX.

De donde se ejecutan:1. REXX de la DD SYSEXEC o SYSPROC2. CLIST de la DD SYSPROC3. Programas de la DD STEPLIB o ISPLLIB4. Programas de LPA o de LINKLIST

TSO enviroment



Este comando permite “capturar” la salida de un comando de TSO. Esta información es puesta en un stem. Se la usa como función externa EJ: x=outtrap(line.) /* comienzo captura */ TIME /* comando de TSO */

x=outtrap(off) /* finalizo captura */

Do i=1 to line.0 /* analizo el stem */

Say line.i /* muestro la linea */End /* finalizo DO */

x es tan solo de forma, no se usa su contenido. (es el RC ) Se pueden atrapar tantos comandos como se quiera, pero una buena

práctica es de a uno por vez. Captura solo comandos de TSO bien escritos (no soporta macros TPUT

o WTO)

OUTTRAP



El stack es un area de memoria para “guardar” elementos. Normalmente lo mismo que entro por el teclado.

Se lo maneja con 3 sentencias:1. Push Introduce un elmento arriba (LIFO)2. Pull Saca un elemento de arriba3. Queue Introduce un elemento abajo (FIFO)

Para saber cuantos elementos hay se usa:1. Queued() Devuelve la cantidad de elementos en el stack

Si se acaban los elementos del stack el PULL lee el teclado de la terminal.

Si se quiere leer el teclado sin importar el stack se usa:1. Parse external

Recuerden que PULL es PARSE UPPER PULL abreviado

El stack



Se lo puede usar para pasar variables entre REXXs. Se lo usa para programas como el FTP que requieren intervencion

manual leyendo la terminal. Se lo puede usar para el EXECIO Permite enviar comandos al llamador de una exec cuando esta termina. Se pueden usar varios stack al mismo tiempo. (OJO, hay que saberlo

hacer muy bien)1. MAKEBUF Crea un nuevo buffer de stack

2. DROPBUF Deletea un buffer de stack

3. NEWSTACK Crea un nuevo stack

4. DELSTACK Destruye un stack

Cuando una REXX termina el stack es leido por el TSO, por eso se DEBE usar DROPBUF para limpiar el mismo previo a terminar una REXX.

Usos del STACK



Es la manera de hacer I/Os con REXX. Debe estar alocada la DD contra la que se hace el I/O. Solo datasets secuenciales o miembros de particionados. Sintaxis:

EXECIO numlineas funcion ddname ( STEM stemname FINIS

numlineas: cantidad de lineas a transferirfunción: DISKR (read) DISKW (write) DISKRU (read for

update) ddname: nombre de la DDSTEM : si está indica operación con stemstemname: nombre del stem si es usadoFINIS : si está hace CLOSE del archivoSi no se usa stem va contra el stackTiene mas opciones (ver el manual)

EXECIO



1. Leer un archivo y decir cuantos registros tiene.

2. Leer un archivo y mostrar (say) las lineas impares.

3. Leer un archivo y grabarlo en sentido inverso.

4. Leer un archivo y grabar solo los registros que cumplan ciertas condiciones. (a su elección).

5. Idem 4 pero yo indique las condiciones.

6. Atrapar la salida de un listcat y grabarla en un archivo.

7. Hacer un FTP con una REXX contra la misma maquina y ejecutar un LS.

8. Intente algo que normalmente usa en su tarea cotidiana y que hoy realiza manualmente.

Manos a la obra



Sirve para manejar datos seprandolos en distintas variables. Es fundamental si uno pretende usar el REXX como se debe. Solo una sentencia: PARSE (y sus abreviadas PULL y ARG) Ocho fuentes posibles para el PARSE

1. ARG Argumento cuando se invoca

2. PULL Stack o teclado

3. External Teclado

4. VAR Una variable

5. VALUE ... WITH Expresión

6. SOURCE como fue invocado

7. VERSION Versión de REXX

8. NUMERIC Info sobre el ambiente numérico en uso

Tiene una cantidad importante de variantes. Ver el manual

Parsing



Templates: Usar blanco como delimitador. (clásico) Usar columnas para parsear o posiciones relativas. Usar literales como separadores. Usar . para descartar una parte de los datos. Forzar todo a mayúsculas. EJ:Parse upper arg p1 p2p p3 . Lee los tres primeros parámetros, en mayúsculas y

descarta el resto

Parse var 18:40:35 hh ‘:’ mm ‘:’ ss Parsea la hora en hh mm ss

Parse arg command ‘(‘ parms Lee argumentos y lo que está antes del (lo pone en commands y el resto en parms respetando minúsculas.

Parse pull 5 var1 +2 14 var2 +3 . La var1 empieza en columna 5 y es de 2 de longitud, y var2 empieza en 14 y es

3 de longitud. Respeta minúsculas y descarta resto.

Parsing (cont.)



Escribir las siguientes REXX:

1. Input hora hh:mm:ss salida diferencia con la actual en hh:mm:ss2. Reformatear la salida del comando LISTALC STATUS para que quede

encolumnado el nombre de la DD, luego el nombre del DATASET y finalmente la DISP.

3. Averiguar si se tiene acceso a un dataset (por RACF) sin provocar una violación. El nombre del dataset se debe pasar como parámetro.

4. Averiguar el address space ID del usuario de TSO que está usando, con comandos de consola, y mostrarlo con un SAY.

5. De un dataset específico leer cuantas palabras se repiten y que cantidad de veces cada una. Grabar la salida en otro archivo encolumnado. Las que estan una sola vez descartarlas.

6. Mejorar la REXXTRY para que no falle aún ingresando mal los datos.(Use SIGNAL ....)

7. Que necesidad tienen hoy para usar REXX. Intentelo resolver.

Manos a la obra



Equivalencias entre JCL y TSO1. ALLOC es similar a DD solo que cuando se finaliza el uso de la

misma se debe ejecutar el comando FREE

2. EXEC ejecuta execs y no programas

3. Para ejecutar programas se debe usar CALL.

4. Call tambien se usa para invocar otras REXX o CLIST

Para correr una REXX en batch1. Se usa el programa IKJEFT01

2. Se debe usar la DD SYSPROC o la SYSEXEC para que encuentre las REXX a ejecutar

3. El input va en SYSTSIN y el output en SYSTSPRT

Algunos comandos de TSO



Se usa para no bloquear la terminal mientras se ejecuta la REXX

EJ://xxxxTST JOB MSGCLASS=X,CLASS=A,NOTIFY=&SYSUID 00010000//*********************************************************** 00173300//** TSO BATCH ** 00173400//*********************************************************** 00173500//AA1 EXEC PGM=IKJEFT01,TIME=1440,DYNAMNBR=250 PARM='TEST1 ' 00210104//STEPLIB DD DISP=SHR,DSN=REXX.V1R3M0.SEAGLPA 00211006//SYSEXEC DD DSN=xxxx.EXEC,DISP=SHR 00220006//SYSTSPRT DD SYSOUT=* 00230010//SYSTSIN DD * 00240002LU &SYSUID

Se puede usar la SYSTSIN o pasar un parámetro en la tarjeta EXEC

TSO Batch



Se pueden ejecutar comandos de consola desde una REXX, capturar su salida, etc.

Se necesita autoridad para ejecutar el comando CONSOLE EJ:

CONSPROF SOLDISPLAY(NO/YES) SOLNUM(xxx)CONSOLE ACTIVATE ADDRESS CONSOLE“nnnnnnnnnnnnnnnnnn”

Para capturar la salida de los comamdos se usa GETMSG EJ:

Getcode = GETMSG(“MSG.”,”SOL”,,,3)

Espera 3 segundos por la respuesta y la pone en el Stem MSG. Y solo si es un msg solicitado

Console



Escribir las siguientes REXX:

1. Ejecutar un IEBGENER pero “online”2. Ejecutar una REX de su elección (de las ya escritas) pero

batch.3. Leer un archivo y submitirlo4. Armar un JCL dinamico y submitirlo con el comando SUB5. IDEM pero con intrdr6. Armar una REXX y tirar algún comando de DISPLAY en la

consola7. IDEM anterior pero capturando la salida 8. Con una REXX displayar el numero de buffers de consola en

uso9. Grabar en un archivo lo que hay en maquina cada 5 minutos.

Manos a la obra

REXXAvanzado

Documents

Transcript of REXXAvanzado