rexx – un buen lenguaje - rga training & solutions. pull stack o teclado 3. external teclado...

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

../../../Manuales/IKJ3A310.BOO



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 execution

2. HI – Halt execution

3. TS – Trace start

4. 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. TSO

2. IDCAMS

3. RACF

4. HSM

5. TCP/IP

6. OMVS

7. Productos con interface a TSO

O bien 1. Programas

2. Clist o REXX.

De donde se ejecutan: 1. REXX de la DD SYSEXEC o SYSPROC

2. CLIST de la DD SYSPROC

3. Programas de la DD STEPLIB o ISPLLIB

4. 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 arriba

3. 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 transferir

función: DISKR (read) DISKW (write) DISKRU (read for update)

ddname: nombre de la DD

STEM : si está indica operación con stem

stemname: nombre del stem si es usado

FINIS : si está hace CLOSE del archivo

Si no se usa stem va contra el stack

Tiene 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:ss

2. 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 TSO

1. 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 batch

1. 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 * 00240002

LU &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 submitirlo

4. Armar un JCL dinamico y submitirlo con el comando SUB

5. IDEM pero con intrdr

6. Armar una REXX y tirar algún comando de DISPLAY en la consola

7. IDEM anterior pero capturando la salida

8. Con una REXX displayar el numero de buffers de consola en uso

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

Manos a la obra


rexx – un buen lenguaje - rga training & solutions. pull stack o teclado 3. external teclado...

Documents