Curso de Programacion Rexx

Programación REXX Nivel Básico
TABLA DE CONTENIDO
PRESENTACION.................................................................................................................................... 1
¿QUÉ ES REXX? .................................................................................................................................... 2
Descargas ........................................................................................................................................ 3
Documentación en Línea................................................................................................................. 3
Tutorial ............................................................................................................................................ 3
REGINA ............................................................................................................................................ 3
PRIMER PROGRAMA REXX .................................................................................................................. 4
Comentarios .................................................................................................................................... 4
Sintaxis ............................................................................................................................................ 4
PAUSE .............................................................................................................................................. 4
Guardar el Programa ....................................................................................................................... 4
VARIABLES ........................................................................................................................................... 5
CARACTERES ESPECIALES .................................................................................................................... 6
ENTRADA Y SALIDA .............................................................................................................................. 7
OPERADORES....................................................................................................................................... 8
OPERADORES ARITMETICOS ........................................................................................................... 8
OPERADORES DE COMPARACION ................................................................................................... 9
OPERADORES LOGICOS ................................................................................................................... 9
CONDICIONALES ................................................................................................................................ 10
Condicional Simple ........................................................................................................................ 10
Condicional Compuesto ................................................................................................................ 11
Condicional Anidado ..................................................................................................................... 11
Bloque de Instrucciones ................................................................................................................ 11
Condicional Estructurado .............................................................................................................. 11
NOP ............................................................................................................................................... 12
CICLOS ............................................................................................................................................... 13
Ciclo DO ......................................................................................................................................... 13
Ciclo DO WHILE ............................................................................................................................. 13
Ciclo DO UNTIL .............................................................................................................................. 14
Ciclo DO estructurado ................................................................................................................... 14
Ciclo Infinito .................................................................................................................................. 15
i
Ciclo Anidado................................................................................................................................. 15
GOTO ETIQUETA ................................................................................................................................ 16
SUBRUTINAS ...................................................................................................................................... 17
PROCEDIMIENTOS ............................................................................................................................. 18
FUNCIONES........................................................................................................................................ 19
Argumentos de una función .......................................................................................................... 19
Tipo de Datos ................................................................................................................................ 19
INSTRUCCIONES DE CONTROL .......................................................................................................... 21
RC .................................................................................................................................................. 21
SYSGETERRORTEXT(RC) ................................................................................................................. 21
TRACE ............................................................................................................................................ 22
MANEJO DE CADENAS ....................................................................................................................... 23
LEFT (cadena, longitud, relleno) .................................................................................................... 23
RIGHT (cadena, longitud, relleno) ................................................................................................. 23
LENGTH (cadena)........................................................................................................................... 24
OVERLAY (nueva, cadena, n, l, relleno) ......................................................................................... 24
REVERSE (cadena) ......................................................................................................................... 24
SUBSTR (cadena, n, l, relleno) ....................................................................................................... 25
COMPARE (cadena1, cadena2, relleno) ........................................................................................ 25
VERIFY (cadena, referencia, opción, n) ......................................................................................... 25
COPIES (cadena, n) ........................................................................................................................ 26
DELSTR (cadena, n, l) ..................................................................................................................... 26
INSERT (nueva, cadena, n, l, relleno) ............................................................................................ 26
POS (cadena, original, n) ............................................................................................................... 27
LASTPOS (cadena, original, n) ....................................................................................................... 28
MANEJO DE PALABRAS...................................................................................................................... 29
ABBREV (original, cadena, n) ......................................................................................................... 29
SPACE (cadena, n, relleno) ............................................................................................................ 30
TRASLATE (cadena, nuevos, originales, relleno) ........................................................................... 30
WORDS (cadena) ........................................................................................................................... 31
WORD (cadena, n) ......................................................................................................................... 31
WORDPOS (cadena, texto, n) ........................................................................................................ 31
ii
SUBWORD (cadena, n, l)................................................................................................................ 32

WORDINDEX (cadena, n) ............................................................................................................... 32
WORDLENGTH (cadena, n) ............................................................................................................ 32
DELWORD (cadena, n, l) ................................................................................................................ 33
FUNCIONES MATEMATICAS .............................................................................................................. 34
ABS (número) ................................................................................................................................ 34
SIGN (número)............................................................................................................................... 34
MAX (n1 a n20).............................................................................................................................. 34
MIN (n1 a n20) .............................................................................................................................. 35
XRANGE ......................................................................................................................................... 35
RANDOM (mínimo, máximo)......................................................................................................... 35
TRUNC (número, n) ....................................................................................................................... 36
FORMAT (número, entero, decimales) ......................................................................................... 36
ARREGLOS ......................................................................................................................................... 37
Vectores o arreglos de una dimensión.......................................................................................... 37
Matrices o arreglos de dos dimensiones ...................................................................................... 37
Arreglos Multidimensionales ........................................................................................................ 38
MANEJO DE ARCHIVOS...................................................................................................................... 39
FUNCIONES DE ARCHIVOS................................................................................................................. 40
SYSFILEEXISTS (archivo) ................................................................................................................. 40
SYSFILEDELETE (archivo)................................................................................................................ 40
SYSFILECOPY (origen, destino) ...................................................................................................... 41
SYSFILEMOVE (origen, destino) ..................................................................................................... 41
DIRECTORY .................................................................................................................................... 41
COMANDOS DEL SISTEMA................................................................................................................. 42
USERID ........................................................................................................................................... 42
DATE (formato1, fecha, formato2)................................................................................................ 42
TIME (opción) ................................................................................................................................ 43
EJERCICIOS......................................................................................................................................... 44
Proyectos ....................................................................................................................................... 45
iii
PRESENTACION
El presente documento intenta describir los comandos básicos del lenguaje de
programación REXX. Comienza describiendo las características del lenguaje para luego
entrar a la explicación de los comandos y funciones como tal, haciendo uso de ejemplos
sencillos.
Es importante destacar que este documento no es un manual de referencia, muy lejos de
eso, lo que intenta es servir de guía al curso introductorio de REXX. Muchas cosas serán
explicadas por el instructor y no están incluidas en el escrito.
Es importante manifestar que los ejemplos serán ejecutados en un simulador de REXX que
corre bajo Windows instalado para tales fines. No se tiene soporte sobre MVS por lo que no
se utilizará tal sistema operativo para hacer las demostraciones en ningún momento.
Tampoco se tiene soporte sobre Z/OS o cualquier entorno mainframe.
El documento describe el uso de la programación lineal, es decir, la ejecución de
instrucciones que se ejecutan de arriba a abajo. Se incluyen aspectos propios de la
programación estructurada, es decir, se codifican procedimientos, subrutinas y funciones
para la formulación de módulos o segmentos de programas repetitivos. No se tiene soporte
sobre la programación orientada a objetos que es otra de las características resaltantes de
REXX. Este aspecto forma parte de un nuevo curso con objetivos específicos, nuevos
comandos y ejemplos propios sobre este paradigma de la programación.
Como ya se dijo, no guarda relación con los sistemas operativos de mainframe por lo cual
no se explicará la ejecución de comandos en tales entornos operacionales. Nos basaremos
en la ejecución de utilitarios para Windows y DOS. Tampoco haremos referencia a
comandos sobre los demás sistemas operativos donde corre REXX, como MAC OS, LINUX y
otras plataformas.
Esperamos que esta guía cumpla con los objetivos esperados por la audiencia en cuanto al
uso del software como lenguaje de programación. Se explica el uso de las variables, los
distintos operadores: aritméticos, lógicos, de comparación; las instrucciones condicionales,
los diversos ciclos iterativos como MIENTRAS, HASTA QUE y PARA, así como los ciclos
infinitos y ciclos controlados en términos de lógica de programación; las etiquetas y los
saltos GOTO; subrutinas, procedimientos y funciones, el pase de parámetros, funciones con
polimorfismo, la evaluación de los argumentos de las funciones/procedimientos/rutinas; las
funciones de cadenas y de palabras; funciones matemáticas; el manejo de archivos para
lectura y escritura, y el manejo de copiado de archivos y carpetas; para finalizar, se hará un
recorrido por las funciones más importantes de REXX ideales para escribir programas
interesantes que cumplan con los propósitos planteados por el programador.
1
¿QUÉ ES REXX?
REXX es la abreviatura de REstructured eXtended eXecutor, un lenguaje de programación
propietario desarrollado por Mike Cowlishaw de IBM entre 1976 y 1982, sin embargo,
existen muchas implementaciones disponibles en código abierto. Es un lenguaje de
programación estructurado de alto nivel fácil de entender. Hay intérpretes de código REXX
comerciales y de código abierto para muchas plataformas, y compiladores para los
mainframes de IBM.
El nombre también se aplica a la familia de lenguajes relacionados con el lenguaje de
programación REXX: el propio REXX −llamado en ese contexto REXX clásico o tradicional− y
otros como Object REXX y NetREXX.
Es esencialmente un lenguaje de formato libre con solamente un tipo de dato primitivo: la
cadena de caracteres. Esta filosofía implica que todos los datos son visibles y que la
depuración y el trazado se simplifican.
La sintaxis de REXX parece similar a la de PL/I, pero tiene menos notaciones; esto hace que
el código sea más difícil de analizar por el intérprete o el compilador pero más fácil de usar
para el programador.
Como lenguaje interpretado, REXX se usa con frecuencia como lenguaje de scripting, donde
el código se guarda en un archivo de texto simple y luego el intérprete lo ejecuta. Por
supuesto, el intérprete también se puede operar como un programa separado, que
proporciona un símbolo del sistema para escribir directamente la sintaxis del lenguaje, lo
que lo hace útil para pruebas y otros comandos y operaciones rápidos del sistema.
REXX sirve bien como un lenguaje adhesivo, entonces, ya que es capaz de juntar funciones
de otros programas en un solo script. Uno de sus mayores puntos fuertes es su diseño como
macrolenguaje. Los desarrolladores de programas pueden simplemente agregar soporte
REXX a su software para que las macros se puedan escribir sin tener que programar su
propio lenguaje de macros en su software.
Otra de las características de REXX es su sintaxis de forma libre, que hace que el lenguaje
sea similar a otros lenguajes de scripting, como Perl. Con esta capacidad, el uso del idioma
se vuelve más simple ya que los requisitos de posicionamiento, como la sangría y los
caracteres de final de línea, son menos estrictos. Además, toda la sintaxis utilizada en el
lenguaje son solo 23 instrucciones específicas. Este pequeño conjunto de instrucciones, con
sus operandos, es capaz de interactuar con prácticamente cualquier cosa, incluidas
interfaces gráficas de usuario (GUI), bases de datos y servidores web. Por esta razón, REXX
se utiliza a veces como un lenguaje de scripting de interfaz de puerta de enlace común (CGI)
en servidores web.
2
Otro rasgo algo único del lenguaje es su falta de tipos de datos. REXX usa solo cadenas de
caracteres como tipos de datos. Los significados de las cadenas dependen de su uso, y las
matemáticas se pueden realizar en cualquier cadena que forme un número válido. Esta
capacidad inherente para trabajar con cadenas hace que el lenguaje sea útil para analizar y
procesar texto.
Descargas
Para descargar el intérprete debe visitar el enlace oficial del producto:
http://www.rexxinfo.org/
Para descargar un emulador del intérprete visite el siguiente enlace:
https://sourceforge.net/projects/oorexx/
Documentación en Línea
El siguiente enlace corresponde a la documentación oficial del propietario (IBM):
https://www.ibm.com/docs/en/zos/2.1.0?topic=guide-learning-rexx-language
Tutorial
Este otro enlace nos conduce a un tutorial del lenguaje bastante sencillo pero muy
completo, escrito por un desarrollador en particular:
https://www.tutorialspoint.com/rexx/index.htm
REGINA
Regina es el intérprete de REXX más moderno y popular del mercado. Fue escrito por Anders
Christiansen y actualmente es soportado por Mark Hessling.
Sus características más resaltantes es que es ANSI-compliant, es decir, totalmente
compatible con ANSI (American National Standards Institute es el Instituto Nacional de
Estándares Estadounidense), lo que permite ser compatible con muchos software norte
americanos, y está disponible en muchas plataformas, como UNIX, Windows, Mac OS X, y
muchos otros sistemas operativos.
Es común para los desarrolladores REXX hacer uso de este intérprete, por eso su nombre,
simula el matrimonio del lenguaje rey REXX y su interpretador reina REGINA.
3
PRIMER PROGRAMA REXX

Comentarios
Para agregar un comentario en cualquier parte del programa debe hacer uso de los
caracteres /* para abrir y cerrar con */. También puede agregar líneas dentro de los
separadores /* y */. El comentario va dentro ambos juegos de caracteres.
/* esto es un comentario */
/*
Esto es otro comentario de varias líneas
…
Continua el comentario
*/
Sintaxis
Para escribir un programa se debe agregar un comentario en la primera línea del archivo
que le indica al intérprete que se trata de un código escrito en REXX.
/* REXX */
PAUSE
Para ejecutar el programa en ambiente DOS mediante el emulador, tenemos que agregar
la instrucción PAUSE al final del programa. PAUSE es un comando de DOS que ejecuta una
pausa para que el usuario presione una tecla para continuar con la ejecución del programa
o script de comandos.
A partir de este momento nos referiremos al sistema operativo “Disk Operating System”
como DOS.
Guardar el Programa
Para guardar un programa escrito en REXX debe colocar el nombre, preferiblemente sin
espacios en blanco, con la extensión “rex”. Por ejemplo: miprograma1.rex, factorial.rex,
recursivo1.rex, por mencionar cualquiera, donde miprograma1, factorial y recursivo1 son
programas escritos en código REXX.
Se recomienda colocar los programas en una carpeta que sea fácil de reconocer, como por
ejemplo: “misprogramas”, o “programas REXX” dentro del disco de su computador.
4
VARIABLES
Para declarar una variable basta con agregar un nombre de variable y asignar un valor. El
valor de la variable siempre será una cadena. Si la cadena está entre comillas dobles se
define un texto pero si no tiene comillas y contiene números enteros o decimales, estará
definiendo variables numéricas.
Los nombres de variables no son sensibles a mayúsculas o minúsculas. Las variables pueden
contener números, underscore o guion bajo, debe comenzar con una letra pero pueden
combinarse con números.
/* textos */
nombre = “Douglas”
apellido = “Barrios”
nombreCompleto = nombre apellido

nombreFormal = “Sr. ” nombreCompleto
nombreFormal2 = “Sr. ” || nombreCompleto
/* números */
a=5
b = a + 10
sueldo = 1500.55
bono = 3000.0
aCobrar = sueldo + bono
En el ejemplo podemos ver cómo se pueden concatenar variables de textos. El comando ||

sirve para concatenar variables de texto, es opcional. También introducimos el operador
suma para variables numéricas.
5
CARACTERES ESPECIALES
Existen pocos caracteres especiales a incluir en el código lo que hace muy sencillo la
escritura de programas.
Cada instrucción se escribe en una sola línea, sin embargo, si el código es muy extenso se
agrega una coma al final para indicar al intérprete que el comando continúa en la siguiente
línea.
Si se desea agregar muchos comandos en la misma línea se necesita agregar punto y coma
como carácter de cierre de cada comando, lo cual no es recomendable, pues dificulta la
lectura del programa.
/* uso de la coma */
textoLargo = “ esto es ejemplo de un texto largo que ocupa dos líneas de comando. ” ,
|| “Este texto se anexa al final de la variable”
/* uso del punto y coma */

var1 = 5; var2 = 10; var3 = 25; var4= -15;
/* se pueden escribir por separado sin puntos y comas */

var1 = 5
var2 = 10
var3 = 25
var4= -15
6
ENTRADA Y SALIDA
Para imprimir valores por pantalla se usa el comando SAY y para leer un dato por pantalla
se usa PULL.
Para leer un campo sin cambiar a mayúsculas use el comando PARSE.
Para eliminar una variable de memoria se usa el comando DROP.
Para asignar un valor NULO a una variable solo asigne doble comillas.
nombre = “Pedro”
say nombre /* imprime Pedro */
say pedro /* imprime PEDRO como literal pues la variable no existe */
say “Ingrese el valor de n”

pull n
say “usted ha ingresado el número ” n
say “Ingrese la direccion”

pull parse direc
say direc
drop direc
say direc /* imprime DIREC como en el ejemplo anterior */
direc = “” /* asigna valor nulo a direc */

say direc
7
OPERADORES
OPERADORES ARITMETICOS
A continuación presentamos los operadores numéricos y de texto.
Operador Descripción Ejemplo

say 4 + 10
+ Suma dos variables u operandos
/* devuelve 14 */
say 10 – 5
- Resta dos variables u operandos
/* devuelve 5 */
say 2 * 4
* Multiplica dos variables u operadores
/* devuelve 8 */
say 10 / 2
/* devuelve 5 */
/ Divide dos variables u operandos
say 5 / 2
/* devuelve 2.5 */
say 10 // 2
// Residuo de la división entera entre 2 variables u /* devuelve 0 */
operadores say 5 // 2
/* devuelve 1 */
say 10 % 2
% Cociente de la división entera entre 2 variables /* devuelve 5 */
u operadores say 5 % 2
/* devuelve 2 */
** say 5 ** 2
Potencia
/* devuelve 25 */
Say,
Concatena dos variables o textos. Este
|| “hola” || “ mundo“
comando es opcional puesto que con asignar
/* devuelve “hola
dos variables a otra se concatenan los valores.
mundo” */
8
OPERADORES DE COMPARACION
A continuación presentamos los operadores de comparación también conocidos como
relacionales.

== Igual 2 == 2 retorna 1
< Menor que 4 < 5 retorna 1
<= Menor o igual que 5 <= 10 retorna 1
> Mayor que 10 > 5 retorna 1
>= Mayor o igual que 12 >= 10 retorna 1
<> /= \= >< Diferente 1 <> 2 retorna 1
/< No menor que 10 /< 2 retorna 1
/> No mayor que 10 /> 20 retorna 1
OPERADORES LOGICOS
A continuación presentamos los operadores de lógicos también conocidos como booleanos.

& AND 1 & 1 retorna 1
| OR 1 | 0 retorna 1
\ NOT \0 retorna 1
&& OR EXCLUSIVO 1 && 0 retorna 1
Veamos las tablas de verdad de los operadores lógicos:
Variable X Variable Y X OR Y X AND Y NOT X X XOR Y

V V V V F F
V F V F F V
F V V F V V
F F F F V F
Nota: V es verdadero y F es falso.
9
CONDICIONALES
Instrucciones que permiten bifurcar el flujo del programa a partir de condiciones
particulares.
Comando Descripción Sintaxis

IF (cond) THEN
IF Condicional simple
instrucción
IF (cond) THEN
IF ELSE Condicional compuesto instrucción ELSE
instrucción
SELECT
WHEN (cond) THEN
instrucción
WHEN (cond2)
SELECT Condicional estructurado
THEN instrucción
OTHERWISE
instrucción
END
IF (cond) THEN
DO
Instrucciones
END
DO END Bloque de instrucciones
ELSE
DO
Instrucciones
END
IF (cond) THEN
NOP No opera NOP ELSE
instrucción
Condicional Simple
say “ingrese la edad del individuo”
pull edad
if (edad < 18) then
say “el individuo es un menor de edad”
10
Condicional Compuesto
if (edad < 18) then
say “el individuo es un menor de edad”
else
say “el individuo es mayor de edad”
Condicional Anidado
If (edad >=0 & edad < 3) then
say “el individuo es un infante”
else
If (edad >=3 & edad < 18) then
say “el individuo es un joven”
else
If (edad >= 18 & edad < 60) then
say “el individuo es un adulto”
else
say “el individuo es un adulto mayor”
Bloque de Instrucciones
If (a // 10 == 0) then
do
say a “ es divisible por 10”
say a “ es par ya que es también divisible por 2”
say a “ es divisible por 5”
contador = contador + 1
end
Condicional Estructurado
say “ingrese la edad del individuo”
pull edad
select
when (edad < 3) then
say “el individuo es un infante”
say “el individuo es un joven”
say “el individuo es un adulto”
otherwise
say “el individuo es un adulto mayor”
end
11
NOP
/* nop no opera */
if (edad >= 100) then
nop
else
say “eres menor de 100 años”
12
CICLOS
Conjunto de instrucciones que se repiten de manera ordenada para efectuar alguna
operación.
Comando Descripción Sintaxis

Ciclo DO
DO n
DO n = limite
Instrucciones
END
Ciclo MIENTRAS
cond = condición
DO WHILE (cond)
DO WHILE de parada es
Instrucciones
verdadera
END
Ciclo HASTA
DO UNTIL (cond) cond = condición
DO UNTIL
Instrucciones de parada es falsa
END
Ciclo infinito
DO FOREVER
cond = condición
DO FOREVER Instrucciones
de parada
IF (cond) THEN LEAVE
END
Ciclo PARA n = limite
DO i = 1 TO n BY m FOR c m = paso por
DO estructurado
Instrucciones defecto es 1
END c = variable
LEAVE rompe el ciclo DO LEAVE
ITERATE Reinicia el ciclo DO ITERATE
Ciclo DO
Ciclo que ejecuta un bloque de instrucciones de manera repetitiva.
do 10
say “este texto se imprimirá de manera repetida”
end
Ciclo DO WHILE
Ciclo que se ejecuta mientras una condición se cumpla. En caso de no cumplirse la condición
no entra en el ciclo.
13
/* ejemplo de contador */
a=1
do while (a<11)
say a
a=a+1
end
Otro ejemplo de ciclo DO WHILE

/* ejemplo de acumulador */
/* cálculo del factorial de un numero n */
n=6
f=1
c=n
do while (c > 0)
f=f*c
c=c-1
end
say “el factorial de” n “=” f
/* Recuerde que 6! = 6*5*4*3*2*1 = 720 */
Ciclo DO UNTIL
Ciclo que ejecuta un bloque de instrucciones al menos una vez, hasta que se cumpla la
condición de parada.
/* contador de 1 al 5 */
j=1
do until (j > 5)
say j
j=j+1
end
Ciclo DO estructurado
Ciclo que ejecuta un bloque de instrucciones de inicio a fin de una variable.
/* ciclo para c de 1 hasta 5 hacer */
do c = 1 to 5
say c
end
/* imprime el valor de c de 1 hasta 5 */
14
Ciclo Infinito
Ciclo que se ejecuta infinitamente hasta que una condición del programa ejecute el
comando LEAVE.
do forever
say “ingrese un número menor que 10”
pull num
if num < 10 then
leave
end
Ciclo Anidado
Combinación de ciclos de cualquier tipo.
do oper1 = 1 hasta 5
say “tabla de multiplicar del ” oper1
do oper2 = 1 hasta 10
prod = oper1 * oper2
say oper1 “*” oper2 “=” prod
end oper2
end oper1
Otro ejemplo con el uso de ITERATE.

contador = 0
do forever
say “introduce 1 para salir del ciclo”
say “introduce 2 para reiniciar del ciclo”
say “introduce 0 para salir del programa”
say “presiona ENTER para mostrar el contador”
pull opt
if(opt == 1) then leave
if(opt == 2) then iterate
if(opt == 0) then exit
contador = contador + 1
say “contador =” contador
end
say “Ciclo terminado por el usuario!!”
15
GOTO ETIQUETA
La instrucción CALL ejecuta el goto hacia una etiqueta. Es la instrucción más rápida de todo
lenguaje de programación ya que solo hace un cambio de dirección de memoria en el
Program Counter (PC) del computador –consulte el Modelo de Von Newman o arquitectura
del computador moderno para entender este concepto.
n=5
f=1
cont = 1
ciclo:
f = f * cont
cont = cont + 1
if (cont > n) call salir
call ciclo
say “nunca pasa por esta instrucción”
salir:
say “el factorial de 5 =” f
En programación estructurada se condiciona el uso del GOTO para que solo se ejecute hacia
abajo y evitar la programación espagueti.
No es una buena práctica hacer uso del GOTO hacia arriba, use ciclos en ese caso.
cont = 1
do 10
say cont
cont = con + 1
if cont = 10 then call salir
end
salir:
exit
16
SUBRUTINAS
Bloque de instrucciones que son llamadas a voluntad desde el programa principal para que
ejecute una tarea cualquiera.
a=5
b=2
do forever
say “menu principal”
say “ingrese su opcion (1 al 4), 9 para salir”
pull opt
res = 0
if (opt = 1) then call suma
else
if (opt = 2) then call resta
else
if (opt = 3) then call multiplica
else
if (opt = 4) then call divide
else
if (opt = 9) then call salir
end
/* subrutinas */
suma:
res = a + b
say “resultado = ” res
return
resta:
res = a - b
return
multiplica:
res = a * b
return
divide:
res = a / b
return
salir:
say “hasta luego!! Feliz día”
exit
17
PROCEDIMIENTOS
Conjunto de instrucciones que reciben parámetros o no, y retornan un valor. La diferencia
con la subrutina es que no tienen acceso a las variables del cuerpo principal del programa
por lo que su acceso es limitado. Para solventar esto hacemos uso del comando ARG, de
este modo pasamos parámetros. El valor de retorno queda en RESULT.
say “ingrese el valor de a”
pull a
say “ingrese el valor de b”
pull b
call suma a, b
say “resultado de la suma es ” result
exit
/*
Procedimientos
*/
suma: procedure
arg op1, op2
sum = op1 + op2
return sum
18
FUNCIONES
Subrutinas y procedimientos se pueden comportar como funciones tal y como sucede con
otros lenguajes de programación. Los valores de retorno pueden asignarse directamente a
variables sin pasar por RESULT.
resultado = suma(10, 20)
say “resultado de la suma es ” resultado
exit
/* Procedimientos */
suma: procedure
arg op1, op2
sum = op1 + op2
return sum
Argumentos de una función

Gracias a la instrucción ARGS podemos saber cuántos argumentos se pasan a una función,
esto es bastante útil en el momento que queremos que la función reciba n parámetros y
retorne el resultado esperado.
say suma(100,200)
say suma(200, 350, 400, 1000)
/* rutina con pase de parámetros variable */

suma: procedure
arg op1, op2
tot = 0
do i=1 to args()
tot = tot + args(i)
end
return tot
Tipo de Datos
Otro aspecto que podemos considerar en el pase de parámetros es el tipo de dato, esto
puede hacer que la función se comporte de diferentes formas. Por ejemplo, si la función
SUMA recibe parámetros numéricos efectúa la suma, pero si recibe algún parámetro de tipo
texto entonces retorno los parámetros concatenados. Esto se conoce como sobre carga de
operadores. Guarda relación con el polimorfismo, pero este es otro tema a discutir,
interesante por demás.
19
El comando DATATYPE (cadena, tipo) permite explorar el tipo de datos de una variable. Si
no se especifica el tipo devuelve “NUM” para cadenas conformadas por números o “CHAR”
para cadenas de texto (combinación de letras y números). Si se especifica el tipo devuelve
1 si se cumple y 0 en caso contrario.
A continuación mostramos las opciones del parámetro tipo:
Comando Descripción
Alfanumérico. Devuelve 1 si "cadena" contiene solo caracteres entre a-
A
z, A-Z o 0-9.
B Binario. Devuelve 1 si "cadena" contiene solo los caracteres 0 o 1.
L Minúsculas. Devuelve 1 si "cadena" contiene solo caracteres entre a-z.
Mayúsculas. Devuelve 1 si "cadena" contiene solo caracteres entre A-
U
Z.
M Mixto. Devuelve 1 si "cadena" contiene solo caracteres entre a-z o A-Z.
N Número. Devuelve 1 si "cadena" contiene sólo números.
Símbolo. Devuelve 1 si "cadena" contiene sólo símbolos de REXX
S
valídos para etiquetas.
W Entero. Devuelve 1 si "cadena" es un número entero.
Hexadecimal. Devuelve 1 si "cadena" contiene sólo caracteres entre a-
X
f, A-F o 0-9.
Ejemplos:
say sum(1,2)
say sum(“casa”,”bonita”)
say sum(200,”casa”)
/*
función con verificación de tipos de parámetros
retorna la suma si ambos parámetros son numéricos, la concatenación de
textos si ambos son texto, o un mensaje en caso de no cumplirse las condiciones anteriores!!
*/
suma: procedure
arg op1 op2
if datatype(op1,n) == 1 & datatype(op2,n) == 1 then
valor = op1 + op2
else
if datatype(op1,a) & datatype(op2,a) then
valor = op1 || “ “ || op2
else
valor = “valores de operandos no definidos para esta funcion”
return valor
20
INSTRUCCIONES DE CONTROL
Instrucciones que permiten controlar la ejecución del programa y predecir situaciones
inesperadas.
RC
Código de retorno de un comando del sistema. Por lo general se captura ese código para
manejar el error de retorno.
RC = comando(parámetros)
IF RC <> 0 THEN instrucciones
SYSGETERRORTEXT (RC)
Nos proporciona información sobre un código de error cuando estamos ejecutando un
comando del sistema.
RC = comando(parámetros)
IF RC <> 0 THEN SAY SYSGETERRORTEXT(RC)
Códigos de errores más comunes:
Código Descripción
2 El sistema no puede encontrar el archivo especificado
3 El sistema no puede encontrar la ruta especificada
5 Acceso denegado
123 El nombre de archivo o el nombre de directorio no son correctos
183 No se puede crear un archivo que ya existe
21
TRACE
El comando TRACE nos va a permitir activar diferentes trazas o inspecciones en tiempo de
ejecución para ver cómo se va ejecutando el programa, es lo que se conoce como DEBUGIN.
Código Descripción
Muestra cualquier instrucción que genere un error. Esta opción viene
trace
activada por defecto en zOS.
A parte de mostrar los errores, imprime las líneas de código del
trace a
programa a medida que se van ejecutando.
A parte de mostrar los errores, imprime las líneas de código del
programa a medida que se van ejecutando. Además nos muestra el
trace r
valor que va tomando cada variable y el resultado al analizar
condiciones.
Para activar la traza interactiva, es decir, que se vaya parando la
trace ?
ejecución al analizar cada parte deseada esperando nuestra
trace ?a
interacción para seguir, pondremos el signo “?” antes de la opción
trace ?r
deseada.
Desactivamos TRACE con OFF. Podemos desactivarlo cuando ya
trace o
hayamos visto lo que queríamos ver.
Siendo n un número positivo. Desactivamos TRACE en las siguientes n
trace n
líneas.
22
MANEJO DE CADENAS
A continuación listamos las funciones para el manejo de cadenas de caracteres o STRINGS.
Función Descripción
left Retorna un número de caracteres de la cadena desde la izquierda
right Retorna un número de caracteres de la cadena desde la derecha
length Retorna el número de caracteres de la cadena
overlay Sobrepone cadenas dentro de otra
reverse Retorna los caracteres en forma invertida
substr Toma una cadena dentro de una más grande
Compara dos cadenas, si son iguales retorna 0. En caso contrario
compare
retorna el número de carácter donde comienza la diferencia
verify Verifica que una cadena esté dentro de otra, si hace match o no
copies Copia una cadena las veces especificadas
delstr Elimina una cadena dentro de otra
insert Inserta cadenas dentro de otras
pos Retorna la posición que ocupa una cadena dentro de otra
delstr Elimina una cadena contenida en otra
LEFT (cadena, longitud, relleno)

Va a extraer "longitud" caracteres de "cadena" empezando por la izquierda. Si "longitud" es
mayor que el número de caracteres de "cadena", se rellenará con lo indicado en "relleno".
En caso de que " longitud" sea menor, se cogerán solo los "longitud" caracteres que estén
más a la izquierda de "cadena". El relleno por defecto son espacios en blanco.
say left(“instructivo”,15) /* retorna “instructivo ” */
say left(“instructivo”,15,”-“) /* retorna “instructivo----” */
say left(“instructivo”,8) /* retorna “instruct” */
RIGHT (cadena, longitud, relleno)

Va a extraer caracteres al igual que LEFT pero esta vez desde la derecha.
say rigth(“instructivo”,15) /* retorna “ instructivo” */
say rigth (“instructivo”,15,”-“) /* retorna “----instructivo” */
say rigth (“instructivo”,4) /* retorna “tivo” */
23
LENGTH (cadena)
Devuelve el número de caracteres que tiene "cadena".
texto1 = “este texto tiene una longitud mediana”
texto2 = “este otro texto tiene muchos caracteres, pondremos palabras como ejemplo, “,
|| “pelota, variable, hombre, mujer, carro, computadora, pantalla, curso”
texto3 = “texto corto”
/* se imprimen los tamaños de los textos */
say length(texto1) /* imprime 37 */

OVERLAY (nueva, cadena, n, l, relleno)

Reemplaza caracteres en "cadena", poniendo los caracteres de "nueva", dependiendo de
los parámetros, si no se especifica ningún parámetro, se reemplazarán los primeros
caracteres.
"n" indica en qué carácter van a empezar a ser reemplazados los caracteres, el valor por
defecto es 1.
"l" indica el número de caracteres que vamos a insertar, por defecto "l" es la longitud de
"nueva", para insertar toda la cadena. Si "l" es menor que la longitud de "nueva", se cogerán
solo los primeros "l" caracteres de "nueva"; si es mayor se rellenará con "relleno" o con
espacios por defecto.
texto = “caracteres”
nuevo = “xyz”
say overlay(nuevo, texto) /* imprime xyzacteres */
say overlay(nuevo, texto, 5) /* imprime caraxyzres*/
say overlay(nuevo, texto, 4, 6, “*”) /* imprime carxyz***s*/
say overlay(nuevo, texto, 1, 2) /* imprime xyracteres*/
REVERSE (cadena)
Invierte la cadena.
otra = reverse(“abcdef”)
say otra /* imprime fedcba */
24
SUBSTR (cadena, n, l, relleno)

Extrae una parte de "cadena", comenzando en "n". La parte extraída tendrá una
longitud de "l", si no se indica, por defecto extraerá el resto de la cadena desde "n". Si se
indica una longitud mayor que lo que queda de cadena, se rellenará con "relleno" o por
defecto con espacios.
texto = “esto es una cadena de caracteres”
parte1 = substr(texto, 5)
parte2 = substr(texto, 12, 7)
parte3 = substr(texto, 22, 15, “.”)
/* imprimir las partes cortadas del texto */
say parte1 /* imprime es una cadena de caracteres */

say parte2 /* imprime cadena */
say parte3 /* imprime caracteres.... */
COMPARE (cadena1, cadena2, relleno)

Compara dos cadenas devolviendo 0 si son iguales. Si no son iguales, devolverá la posición
del primer caracter donde difieren. Para comparar, se rellena la cadena más corta con
"relleno", que por defecto son espacios.
cadena = “abc”
say compare(cadena, “abc”)

say compare(cadena, “abc ”,”*”)
say compare(cadena, “aaa”)
say compare(cadena, “xyz”)
/* resultados
0
4
2
1
*/
VERIFY (cadena, referencia, opción, n)

Comprueba que "cadena" sólo contiene caracteres que están en "referencia" devolviendo
0, o devolviendo la primera posición del carácter que no está en "referencia".
25
Las opciones pueden ser N de NOMATCH, que es la que opción por defecto y nos dice la
posición del primer caracter que no coincide, o M de MATCH, que nos dice la posición del
primer caracter que coincide.
Con "n" indicamos en qué posición tiene que empezar a comprobar, por defecto es 1.
texto = “murcielago”
/* los caracteres de las referencias existen */

say verify(texto, “aeiou”) /* imprime 1 */
say verify(texto, “mrclg”) /* imprime 2 */
/* posición donde no hace match */

texto = “abecedario”
say verify(texto, “abcde”, n, 4) /* imprime 8 */
/* posición donde si hace match */

texto = “abecedario”
say verify(texto, “abcde”, m, 4) /* imprime 4 (4 delante de la posición 4 especificada) */
COPIES (cadena, n)
Devuelve "n" repeticiones concatenadas de "cadena".
texto = “texto”
say copies(texto, 10) /* imprime textotextotextotextotextotextotextotextotextotexto */
say copies(“abc”,5) /* imprime abcabcabcabcabc */
DELSTR (cadena, n, l)
Devuelve "cadena", habiendo eliminado "l" caracteres empezando en "n". Si "l" no se
específica, eliminará toda la cadena desde "n" hasta el final.
texto = “douglas barrios”
say delstr(texto, 8) /* imprime douglas */
say delstr(texto, 1, 8) /* imprime barrios */
INSERT (nueva, cadena, n, l, relleno)

Inserta "nueva" en "cadena", dependiendo de los parámetros, si no se especifica ningún
parámetro, se inserta al inicio.
26
"n" indica después de que carácter de "cadena" se debe insertar "nueva", el valor por
defecto es 0. Si "n" es mayor que la longitud de "cadena", se insertará en la posición
indicada, rellenando los huecos con lo indicado "relleno", si no se indica nada, se rellenan
con espacios por defecto.
"l" indica el número de caracteres que queremos insertar, por defecto "l" es la longitud de
"nueva", para insertar toda la cadena. Si "l" es menor que la longitud de "nueva", se cogerán
solo los primeros "l" caracteres de "nueva"; si es mayor se rellenará con "relleno" o con
espacios por defecto.
texto = “franco”
t1 = insert(“barrios”, texto)
say t1
t2 = insert(“douglas”, t1)
say t2
texto2 = “123456789”
say insert(“abc”, texto2, 4)
say insert(“abc”, texto2, 4, 6, “.”)
say insert(“abcd”, texto2, , 3)
/* salida esperada
barriosfranco
douglasbarriosfranco
1234abc56789
1234abc...56789
abc123456789
*/
POS (cadena, original, n)

Devuelve la posición de “cadena” dentro de “original”. Puedo especificar desde que
columna “n” quiero buscar.
texto = “Venezuela es el mejor país del mundo”
say pos(“mundo”,texto) /* devuelve 32 */

say pos(“mejor”,texto) /* devuelve 17 */
say pos(“es”,texto) /* devuelve 11 */
texto = “el mejor es Venezuela, es el mejor, no hay otro mejor”
say pos(“mejor”,texto,1) /* devuelve 4*/

say pos(“mejor”,texto,40) /* devuelve 49, omite los primeros 40 caracteres*/
27
LASTPOS (cadena, original, n)

Devuelve la última posición de “cadena” dentro de “original”. Puedo especificar desde que
columna “n” quiero buscar.
Texto = “azul es la casa, la casa es azul”
Say lastpos(“casa”,texto) /* devuelve 21 */
Say lastpos(“casa”,texto, 20) /* devuelve 12 */
28
MANEJO DE PALABRAS
Funciones para el manejo de palabras.
Comprueba si una cadena es parte de los caracteres iniciales de la
abbrev
cadena original a manera de abreviatura
Reemplaza los espacios en blanco entre las palabras de una cadena y
space
permite reemplazar el espacio por el caracter de relleno indicado
Reemplaza los caracteres de una cadena por otros, si se omiten estos
translate
parámetros convierte la cadena a mayúsculas
words Devuelve el número de palabras que tiene una cadena
word Devuelve la palabra que esté en la posición "n" dentro de una cadena
Devuelve la posición que ocupa la primera palabra de una cadena entre
wordpos todas las palabras de otra. Se le puede indicar en qué número de
palabra comenzar, por defecto, empieza en la primera palabra
Extraer palabras de una cadena de caracteres. Se puede indicar desde
subword
donde comenzar y el número de palabras a extrater
Devuelve la posición del primer carácter de la palabra que está en la
wordindex
dentro de una cadena
Devuelve el número de caracteres de la palabra que está en una
wordlength
posición de la cadena dada
Permite borrar palabras de una cadena, podemos especificar donde
delword comenzar. Si no se especifica, por defecto borra todas las palabras
empezando en una posición dada
ABBREV (original, cadena, n)

Comprueba si "cadena" es una abreviatura de "original", es decir, si los caracteres de
"cadena" son los mismos que los primeros de "original" devuelve 1, en caso de que no lo
encuentre devuelve 0.
Con "l" indicamos el número de caracteres mínimos que tiene que tener "cadena", por
defecto es el número de caracteres de "cadena".
/* abreviaturas que funcionan, retornan 1 */
say abbrev("Si","S")
say abbrev("Douglas","Dou")
say abbrev("Doctor","Doc")
/* abreviaturas que NO funcionan, retornan 0 */
say abbrev("Si","s")
say abbrev("Douglas","dug")
say abbrev("Nueva York","NY")
29
SPACE (cadena, n, relleno)

Reemplaza los espacios en blanco entre las palabras de "cadena" por el caracter indicado
en "relleno", repitiéndolo "n" veces, además si hay espacios al principio y al final siempre
serán eliminados.
Por defecto, "n" vale 1 y "relleno" es un espacio. Con "n" a valor 0 se juntan todas las
palabras.
SAY SPACE(" la casa roja ")
SAY SPACE("la casa roja ",2,"-")
SAY SPACE("la casa roja ",0,"-")
/* resultados esperados */
la casa roja
la--casa--roja
lacasaroja
TRASLATE (cadena, nuevos, originales, relleno)

Reemplaza los caracteres que haya en "originales" de "cadena", por los indicados en
"nuevos", relacionando los caracteres según su posición. Si hay menos caracteres en
"nuevos" que en "originales", los caracteres de más serán reemplazados por "relleno", o
por espacios en su defecto.
Si solamente "cadena" es indicada, "cadena" será devuelto en mayúsculas.
Say transalate(“douglas barrios”)
Say translate(“douglas”, ”xy”, ”ua”)
Say translate(“douglas”, ”xy”, ”uas” ,”$”)
DOUGLAS BARRIOS
doxglys
doxgly$
30
WORDS (cadena)
Devuelve el número de palabras que tiene "cadena".
say words(“numero de palabras de la cadena”)
say words(“Douglas Raul Barrios Franco”)
say words(“supercalifragilisticoespialidoso”)
6
4
1
WORD (cadena, n)
Devuelve la palabra que esté en la posición "n" dentro de "cadena".
say word(“numero de palabras de la cadena”,3)
say word(“Douglas Raul Barrios Franco”,2)
say word(“super califragilistico espialidoso”,1)
palabras
Raul
super
WORDPOS (cadena, texto, n)

Devuelve la posición que ocupa la primera palabra de "cadena" de entre todas las palabras
en "texto". Se le puede indicar en qué número de palabra comenzar con "n", por defecto,
empieza en la primera palabra.
say wordpos(“de”,“numero de palabras de la cadena”)
say wordpos (“Franco”,“Douglas Raul Barrios Franco”)
say wordpos (“Douglas”,“Douglas Raul Barrios Franco”,4)
2
4
0
31
SUBWORD (cadena, n, l)
Extrae "l" palabras de "cadena" comenzando en "n". Si no se le indica "l" extraerá todas las
palabras a partir de la palabra que esté en la "n" posición, incluyendo esta palabra.
say subword("Nombre Apellido Telefono Trabajo",3)
say subword("Nombre Apellido Telefono Trabajo",2,2)
"Telefono Trabajo"
"Apellido Telefono"
WORDINDEX (cadena, n)
Devuelve la posición del primer caracter de la palabra que está en la "n" posición, dentro
de "cadena".
say wordindex("Nombre Apellido Telefono Trabajo",3)
say wordindex("Nombre Apellido Telefono Trabajo",14)
17
0
WORDLENGTH (cadena, n)
Devuelve el número de caracteres de la palabra de "cadena" que está en la posición "n".
say wordlength("Nombre Apellido Telefono Trabajo",3)
say wordlength("Nombre Apellido Telefono Trabajo",1)
8
6
32
DELWORD (cadena, n, l)
Elimina "l" palabras en "cadena", comenzando en "n". Si "l" no se especifica, por defecto
borra todas las palabras empezando desde "n".
SAY DELWORD("Nombre Apellido Telefono Trabajo",3)
SAY DELWORD("Nombre Apellido Telefono Trabajo",2,1)
Nombre Apellido
Nombre Telefono Trabajo
33
FUNCIONES MATEMATICAS
Funciones con manejo de valores numéricos.
abs Retorna el valor absoluto de una cifra dada
sign Devuelve el signo de un número cualquiera
max Retorna el número máximo de una lista de hasta 20 valores
min Retorna el número mínimo de una lista de hasta 20 valores
Devuelve una cadena con todos los caracteres comprendidos entre
xrange
"inicio" y "final"
Devuelve un número aleatorio de acuerdo con el parámetro
random
especificado
trunc Redondea un número con decimales
format Imprime un valor de acuerdo al formato especificado
ABS (número)
Devuelve el número sin signo.
positivo = abs(-5)
say positivo
positivo2 = abs(-10.50)
say positivo2
SIGN (número)
Comprueba el signo de "número". Devuelve 1 si "número" es mayor que 0, devuelve 0 si
"número" es 0, y devuelve -1 si "número" es menor que 0.
say sign(-5) /* retorna -1 */
say sign(10.5) /* retorna 1 */
say sign(0) /* retorna 0 */
MAX (n1 a n20)

Devuelve el mayor de una lista de 20 valores.
mayor = max(10 20 40 1 3 4 2 70 100 30 5)
say mayor
34
MIN (n1 a n20)

Devuelve el menor de una lista de 20 valores.
menor = min(10 20 40 1 3 4 2 70 100 30 5)
say menor
XRANGE
Construye la secuencia de caracteres a partir de los valores suministrados.
say xrange("A","Z") /* imprime "ABCDEFG...UVWXYZ" */
say xrange("a","z") /* imprime "abcdefg...uvwxyz" */
say xrange(0,9) /* imprime "0123456789" */
RANDOM (mínimo, máximo)

Genera un número al azar dentro del rango establecido entre "mínimo" y "máximo". Si no
se especifica ningún parámetro, el rango va a ir desde 0 a 999. El parámetro "mínimo" se
puede omitir, especificando solo “máximo”, en ese caso iría desde 0 hasta "máximo".
say random()
/* genera un numero entre 0 y 999 */
say random(10,200)
say random(-15,0)
/* genera un numero entre -15 y 0 */
say random(6)
35
TRUNC (número, n)
Trunca el parámetro "número" dejando solo "n" decimales. Por defecto "n" vale 0, es decir,
quita todos los decimales. No realiza el redondeo, el resto de decimales serán descartados
sin redondear. Si "n" es mayor al número de decimales actual, añadirá el número 0 tantas
veces como necesite.
say trunc(25.19)
say trunc(25.19,1)
say trunc(25.19,4)
/* valores esperados */
25
25.1
25.1900
FORMAT (número, entero, decimales)

Redondea el "número" indicado. Con "enteros" indicamos cuantos números tiene que
haber en la parte entera, y con "decimales" indicamos cuantos tiene que haber en la parte
decimal. El parámetro "número" es obligatorio, si se omiten los otros dos, el resultado
dependerá de lo que se necesite según el sistema.
say format(298.4596) /* imprime "298.4596" */
say format(2545498.4596) /* imprime "2545498.46" */
say format(1.86,4) /* imprime " 1.86" */
say format(1.86,4,0) /* imprime " 2" */
say format(0.57,2,1) /* imprime " 0.6" */
say format(-3.72,,1) /* imprime "-3.7" */
36
ARREGLOS
En REXX a los arreglos se les llama STEMS. Son variables que pueden ser referenciadas con
el uso de un índice.
Vectores o arreglos de una dimensión

/* cargando 10 números pares en un vector */
num = 2
do i = 1 to 10
say “asignado valor a vector.”i
vector.i = num * i
end
/* recorrer el vector */
do j = 1 to 10
say vector.j
end
/* vaciar un vector o colocar todas los posiciones vacías */

vector. = “”
/* cargar un valor en la posición i del vector */

vector.1 = 0
vector.2 = 2
/* copiar un vector */
nuevo. = vector.
Matrices o arreglos de dos dimensiones

Para crear una matriz se requieren dos índices.
mat.1.1 = 5
mat.1.2 = 4
mat.1.3 = -2
mat.2.1 = 10
mat.2.2 = 3
mat.2.3 = 9
do fila = 1 to 2
say “fila:” fila
do col = 1 to 3
say “col:” col “=” mat.fil.col
end col
end fila
37
Arreglos Multidimensionales
Al igual que la matriz, es posible crear arreglos de n dimensiones.
/* primera matriz del cubo */
cubo1.1.1 = 0
cubo1.1.2 = 0
cubo1.1.3 = 0
cubo1.1.4 = 0
cubo1.2.1 = 1
cubo1.2.2 = 1
cubo1.2.3 = 1
cubo1.2.4 = 2
/* segunda matriz del cubo */

cubo.2.1.1 = 5
cubo.2.1.2 = 6
cubo.2.1.3 = 7
cubo.2.1.4 = 8
cubo.2.2.1 = 3
cubo.2.2.2 = 9
cubo.2.2.3 = 10
cubo.2.2.4 = 13
/* recorrer la primera matriz del cubo */

do f = 1 to 2
say “fila: ” f
do c = 1 to 4
say cubo.1.f.c
end c
end f
38
MANEJO DE ARCHIVOS
A continuación se describen las funciones para el manejo de archivos.
lines Devuelve la cantidad de registros o líneas que contiene el archivo
linein lee el registro o línea de datos del archivo
Escribe en el archivo especificado, también sirve para cerrar el archivo
lineout
de salida
Ejemplos:
/* leer la primera línea del archivo */
line_str = linein(datos.txt)
say line_str
/* leer la segunda línea del archivo */

line_str = linein(datos.txt)
say line_str
lineout(datos.txt) /* cerrar el archivo */
/* recorrer todo el archivo */

tam = lines(datos.txt)
do i = 1 to tam
linea = linein(datos.txt)
say linea
end i
lineout(datos.txt) /* cerrar el archivo */
/* creación de un archivo */
do i = 1 to 10
rc = lineout(numeros.txt, i)
if (rc == 0) then say “escribiendo en numeros.txt”
else
do
say “ocurrio un error durante el proceso”
leave
end
endo i
/* guarda el archivo cuando lo cierra */

lineout(numeros.txt)
39
FUNCIONES DE ARCHIVOS
A continuación se describen las funciones para el tratamiento de archivos.
SYSFILEEXISTS Comprueba si un archivo existe, devolviendo 1 si existe o 0 si no existe.
Borra un archivo del sistema. Devuelve 0 si el archivo se ha borrado
SYSFILEDELETE
correctamente, u otro código en caso de error.
Copia un archivo de un sitio a otro. Si en el destino no indicamos la
ruta, el archivo será copiado en el directorio donde nos encontramos.
SYSFILECOPY
Devuelve código 0 si es copiado satisfactoriamente, u otro código en
caso de error.
Nos permite mover un archivo de un directorio a otro. Devuelve código
SYSFILEMOVE
0 si es movido satisfactoriamente, u otro código en caso de error.
DIRECTORY Nos devuelve la ruta del directorio o carpeta donde nos encontramos.
SYSFILEEXISTS (archivo)
Comprueba si un archivo existe, devolviendo 1 si existe o 0 si no existe.
RC = SYSFILEEXISTS(file1.txt)
/* Guarda 1 o 0 dentro de RC */
RC = SYSFILEEXISTS("C:\Otra carpeta\file1.txt")
SYSFILEDELETE (archivo)
Borra un fichero del sistema. Devuelve 0 si el archivo se ha borrado correctamente, u otro
código en caso de error.
RC = SYSFILEDELETE(file1.txt)
/* Guarda el código de retorno dentro de RC */
RC = SYSFILEDELETE("C:\Otra carpeta\file1.txt")
40
SYSFILECOPY (origen, destino)

Copia un fichero de un sitio a otro. Si en el destino no indicamos la ruta, el archivo será
copiado en el mismo directorio donde nos encontramos. Devuelve código 0 si es copiado
satisfactoriamente, u otro código en caso de error.
RC = SYSFILECOPY(file1.txt,"file1 copia.txt")
RC = SYSFILECOPY(file1.txt,"C:\Otra carpeta\file1.txt")
RC = SYSFILECOPY("C:\Otra carpeta\file1.txt",file1.txt)
SYSFILEMOVE (origen, destino)

Nos permite mover un archivo de un directorio a otro. Devuelve código 0 si es movido
satisfactoriamente, u otro código en caso de error.
rc = sysfilemove(ejemplo1.rex,"c:\programas\ ejemplo1. rex ")
if(rc == 0)
say “movimiento exitoso”
else
say “ha ocurrido un error, por favor revise que el archivo existe”
rc = sysfilemove("c:\descargas\ ejemplo2. rex ", ejemplo2. rex)
DIRECTORY
Nos devuelve toda la ruta del directorio donde nos encontramos.
SAY DIRECTORY()
41
COMANDOS DEL SISTEMA

Funciones que permiten ejecutar comandos del sistema operativo.
userid Devuelve el usuario que se ha conectado al sistema
date Retorna la fecha del día con un formato específico
time Retorna la hora del momento con el formato específico
USERID
Esta función va a devolver el nombre de usuario con el que nos hemos conectado al sistema.
No tiene parámetros.
say userid() /* muestra el usuario conectado al sistema */
DATE (formato1, fecha, formato2)

Usada para devolver la fecha basándose en ciertos parámetros. Si no se especifica nada,
saca la fecha con formato Normal.
Opciones Descripción
B Base, el número de días completos desde 1 de Enero del año 1.
D Días transcurridos del año (ddd)
E Europeo, de la forma dd/mm/yy
N Normal, dd mes (con 3 letras y en inglés) yyyy. Opción por defecto
O Ordenada, yy/mm/dd
S Estandar, yyyymmdd
U Estados Unidos, mm/dd/yy
M Mes en inglés
W Día de la semana en inglés
Ejemplos:
say date(M,"01/05/17",E) /* imprime "May" */
say date(W,"01/05/17",E) /* imprime "Monday" */
say date(U,"01/05/17",E) /* imprime "05/01/17" */
say date(,"60",D) /* imprime "29 Feb 2020" */
42
TIME (opción)
Usada para devolver la hora del sistema, u otra información dependiendo de la "opción"
indicada.
Opciones Descripción
C Hora civil: hh:mm am/pm
H Horas desde la media noche
M Minutos transcurridos desde la media noche
S Segundos transcurridos desde la media noche
L Formato largo: hh:mm:ss.microsegundos
N Formato normal: hh:mm:ss
Elapsed time, indica los segundos y microsegundos desde cuando se
E
reinició
R Reset Elapsed time, reinicia el Elapsed time en cero
Ejemplos:
TIME(E)
/* "0" segundos */
Instrucciones /* Ejecutamos nuestras instrucciones */
TIME(E)
/* X segundos transcurridos desde el primer TIME(E)*/
TIME(R)
/* X segundos transcurridos desde el primer TIME(E)*/
TIME(E)
/* X segundos transcurridos desde TIME(R)*/
43
EJERCICIOS
1. Escriba una función que permita contar la cantidad de dígitos de una cifra dada.
Emplee los operadores que calculan el cociente y el residuo de la división entera.
2. Escriba las funciones que conviertan un número de decimal a binario, a octal y a
hexadecimal a partir de divisiones sucesivas por 2, 8 y 16 respectivamente. Haga uso
de los operadores cociente y residuo.
3. Escriba las funciones que conviertan un número de binario, octal y hexadecimal a
decimal.
4. Escriba una función que permita contar los números de inicio a fin en un intervalo
dado. La funcione recibe los parámetros ini, fin y step. El ciclo debe imprimir los
números de ini a fin de step en step. Por ejemplo, ini = 10, fin = 20, step = 2, luego
debe imprimir 10, 12, 14, 16, 18, 20.
5. Dado un vector de números aleatorios de tamaño fijo, realice el programa que
ordene el vector usando el método de La Burbuja.
6. Cree un archivo de 100 números generados de manera aleatoria.
7. Escriba un programa que lea el archivo anterior, lo descargue en un vector para
luego ordenar los números de forma descendente, finalmente, guarde el vector en
un archivo nuevo. Emplee cualquier método de ordenamiento conocido.
8. Codifique la función PRIMO que determine si un número pasado como parámetro
es un número primo.
9. Codifique la función DIVISORES que cuente la cantidad de divisores de un número
cualquiera.
10. Construya un programa que calcule la multiplicación de dos números por sumas
sucesivas.
11. Construya un programa que efectúe la división por restas sucesivas.
12. Haga el programa que despliegue un menú de opciones para ayudar al usuario a
ejecutar las funciones multiplicación y división escritas en los pasos anteriores.
13. Incluya a ese programa la potencia por sumas sucesivas.
14. Escriba una función que calcule la raíz cuadrada aproximada. Hay muchos métodos
sencillos para tal fin.
44
Proyectos
1. Escriba las siguientes funciones de manera recursiva: PRIMO, DIVISORES,
MULTIPLICA, COCIENTE, RESIDUO, RAIZ2 y POTENCIA. Guarde este código en un
programa integrado.
2. Escriba un programa de CONVERSIÓN DE MONEDAS. Ingrese la cantidad a convertir
en la moneda local, el factor de conversión a moneda extranjera para que el
programa imprima la cantidad en dicha moneda. Guarde el factor de conversión en
el archivo factor.txt. Si el archivo existe, lea su contenido para mostrar el valor del
factor en las subsiguientes conversiones. Permita guardar los cambios.
3. Escriba un programa que simule EL JUEGO DE DADOS entre usted y la computadora.
El juego consiste en lanzar el dado por parte de cada jugador. Si usted saca un 1
puede volver a tirar. Si la computadora saca 1 pierde automáticamente. Gana aquel
jugador que saque el mayor número de los dos lanzamientos. Lleve el conteo de la
cantidad de juegos ganados y perdidos.
4. Escriba el programa que permita simular el juego de POKERDADO. El juego consiste
en lanzar 5 dados y explorar el resultado. Un PAR resulta de obtener dos números
iguales. Un TRIO resulta de obtener 3, POKER con 4 y SUPERPOKER con 5. El
FULLHOUSE resulta de sacar un TRIO y un PAR. La ESCALERA CHICA resulta de
obtener la secuencia del 1 al 5, y la ESCALERA GRANDE del 2 al 6. Anote la cantidad
de juegos ganados por tipo. Guarde los resultados en el archivo: pokerdado.txt.
5. Efectué los cambios necesarios para jugar POKERDADO con otro jugador. Con 5
jugadores. Incluya el manejo de apuestas. Lleve estadísticas de los ganadores y la
cantidad de apuestas en la moneda que usted decida.
45

Curso de Programacion Rexx

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Curso de Programacion Rexx

Cargado por

Copyright:

Formatos disponibles

Programación REXX Nivel Básico

SUBWORD (cadena, n, l)................................................................................................................ 32

PRIMER PROGRAMA REXX

nombreCompleto = nombre apellido

En el ejemplo podemos ver cómo se pueden concatenar variables de textos. El comando ||

/* uso del punto y coma */

/* se pueden escribir por separado sin puntos y comas */

say pedro /* imprime PEDRO como literal pues la variable no existe */

say “Ingrese el valor de n”

say “Ingrese la direccion”

direc = “” /* asigna valor nulo a direc */

Operador Descripción Ejemplo

Operador Descripción Ejemplo

Operador Descripción Ejemplo

Variable X Variable Y X OR Y X AND Y NOT X X XOR Y

Comando Descripción Sintaxis

Comando Descripción Sintaxis

Otro ejemplo de ciclo DO WHILE

Otro ejemplo con el uso de ITERATE.

say “nunca pasa por esta instrucción”

Argumentos de una función

/* rutina con pase de parámetros variable */

LEFT (cadena, longitud, relleno)

say left(“instructivo”,15,”-“) /* retorna “instructivo----” */

say left(“instructivo”,8) /* retorna “instruct” */

RIGHT (cadena, longitud, relleno)

say rigth (“instructivo”,15,”-“) /* retorna “----instructivo” */

say rigth (“instructivo”,4) /* retorna “tivo” */

/* se imprimen los tamaños de los textos */

say length(texto1) /* imprime 37 */

OVERLAY (nueva, cadena, n, l, relleno)

say overlay(nuevo, texto) /* imprime xyzacteres */

say overlay(nuevo, texto, 5) /* imprime caraxyzres*/

say overlay(nuevo, texto, 4, 6, “*”) /* imprime carxyz***s*/

say overlay(nuevo, texto, 1, 2) /* imprime xyracteres*/

SUBSTR (cadena, n, l, relleno)

/* imprimir las partes cortadas del texto */

say parte1 /* imprime es una cadena de caracteres */

COMPARE (cadena1, cadena2, relleno)

say compare(cadena, “abc”)

VERIFY (cadena, referencia, opción, n)

/* los caracteres de las referencias existen */

/* posición donde no hace match */

/* posición donde si hace match */

say copies(“abc”,5) /* imprime abcabcabcabcabc */

say delstr(texto, 8) /* imprime douglas */

say delstr(texto, 1, 8) /* imprime barrios */

INSERT (nueva, cadena, n, l, relleno)

POS (cadena, original, n)

say pos(“mundo”,texto) /* devuelve 32 */

texto = “el mejor es Venezuela, es el mejor, no hay otro mejor”

say pos(“mejor”,texto,1) /* devuelve 4*/

LASTPOS (cadena, original, n)

Say lastpos(“casa”,texto) /* devuelve 21 */

Say lastpos(“casa”,texto, 20) /* devuelve 12 */

ABBREV (original, cadena, n)

SPACE (cadena, n, relleno)

TRASLATE (cadena, nuevos, originales, relleno)

Say translate(“douglas”, ”xy”, ”ua”)

Say translate(“douglas”, ”xy”, ”uas” ,”$”)

say word(“Douglas Raul Barrios Franco”,2)

say word(“super califragilistico espialidoso”,1)

WORDPOS (cadena, texto, n)

say subword("Nombre Apellido Telefono Trabajo",2,2)

say overlay(nuevo, texto, 4, 6, “”) / imprime carxyz***s*/