Manual de Usuario 4GL

Manual de Usuario
Manual de Usuario
Sintaxis del lenguaje 4GL.
Al igual que un programa en C, un programa en 4GL consta de uno o varios
mdulos en los que se definen variables, funciones, formularios de entrada y
listados. La estructura de cada mdulo ser la siguiente:
[DATABASE<id>]
[declaracionesvariablesglobales]
funciones
[forms]
[reports]
En uno de los mdulos debe haber una funcin llamada 'main'. La

funcin main es la que se ejecuta al iniciarse el programa.
Si el programa accede a una base de datos, ser necesario especificar el
nombre de la misma en la primera lnea del programa, mediante la lnea
'DATABASE<nombre>'
Comentarios
Se pueden incluir comentarios dentro de los programas para que su cdigo
sea ms fcil de comprender. hy4GL permite introducir los comentarios entre
llaves, en el estilo de Informix-4GL o bien entre caracteres /* y */, al estilo de C.
El compilador detecta los comentarios anidados e ignora todo el cdigo que
encuentra entre las marcas de inicio y final de comentario.
Ej:
{Funcion:suma_totales;
calculaelimportetotaldeunafra.}
functionsuma_totales()
definejinteger/*jlousoparabucles*/
/*yanonecesitoestavariable.
definesumainteger/*paraircalculando...*/
*/
...
Declaraciones de variables:
Tipos de datos:
El lenguaje soporta los siguientes tipos de datos bsicos:
Integer
El rango permitido para nmeros enteros es el de un 'long int' de C.

Depender de la plataforma en la que se est trabajando. En Linux,
usando gcc 2.7, el rango es entre -2.147.483.647 y 2.147.483.648
Float
Este tipo permite usar nmeros reales. Se implementa mediante el tipo de

datos 'double' de C, por lo que la precisin depender del compilador de C
usado.
Char(x)
Permite usar cadenas de caracteres. No hay lmite para el tamao de la

cadena. A diferencia del lenguaje C, no es necesario reservar un carcter
para la marca de fin de cadena puesto que lo reserva el compilador
automticamente.
Se puede omitir la longitud de la cadena. En este caso, la variable tendr
una longitud de 1 carcter.
En este tipo de datos slo se podrn almacenar caracteres imprimibles. No
est pensado para almacenar datos binarios.
o
Date
Para almacenar fechas. Se permiten fechas desde el 1de Enero del ao 1
(d.C.) hasta bien pasado el ao 40.000 (creo que con esto no habr
problemas en el 2000).
Time
Permite almacenar horas con precisin hasta las milsimas de segundo.
Aunque el tipo de datos permite almacenar la hora con esa precisin, las
milsimas de segundo se pierden al realizar operaciones aritmticas.
o
Datetime
Almacena un instante, representado por fecha y hora. Las caractersticas
comentadas en los dos tipos anteriores son aplicables a ste.
Interval
Almacena un intervalo de tiempo, representado por un nmero de horas,
minutos y segundos. La diferencia entre dos 'datetimes' es un intervalo.
Adems de los tipos de datos bsicos, se permite definir registros, formados

por campos de tipos bsicos. No se permite que un campo de un registro sea, a su
vez, otro registro.
Declaracin de variables:
Como en cualquier lenguaje de programacin, hy4GL permite definir
variables en las que se almacenarn los datos con los que se est
trabajando.hy4GL es un lenguaje tipado: cada variable es de un tipo determinado,
aunque se ver ms adelante que el propio lenguaje realiza la conversin de tipos
automticamente.
El nombre de las variables debe empezar por una letra o un signo de
subrayado '_', y puede contener cualquier combinacin de letras, nmeros y
signos '_'.
El mbito de una variable depende de la parte del mdulo en la que se
declare. As, si una variable se declara dentro de una funcin, ser visible (se
podr acceder a su contenido) solamente desde dentro de esa misma funcin. Si
la variable se declara fuera de una funcin, ser visible desde cualquier funcin
de este mdulo. No es posible usar en un mdulo una variable que est declarada
en otro mdulo distinto.
La sintaxis de la declaracin de variables es la siguiente:
DEFINE<id>[,<id>,...]<tipo>
Ej:
defineiinteger
definehoratime
definehoy,ayerdate
defineahoradatetime
definenombre,apellidoschar(50)
defineteclachar
Si la aplicacin accede a bases de datos, es posible definir variables del

mismo tipo que determinado campo de una tabla en la base de datos. La sintaxis
para ello es:
DEFINE<id>LIKE<tabla>.<campo>
Para ello es necesario que se haya indicado el nombre de la base de datos en

la instruccin DATABASE<nombre>
Ej:
databasecontabilidad
definecuentalikecuentas.numero
defineimportelikemayor.importe
Es posible definir registros que agrupen varias variables en una sola

estructura. Para definir un registro se usar la siguiente sintaxis:
DEFINE<id>RECORD
<nombre><tipo>
...
ENDRECORD
Para acceder a un campo de un registro se especificar el nombre del registro
y el del campo separados por un punto. Para referirse a la lista completa de
campos de un registro, se usar el nombre del registro seguido de '.*'
Ej:
defineclienterecord
codigointeger
nombrechar(50)
apellidoschar(50)
endrecord
letcliente.nombre="JUAN"
letcliente.*=busca_cliente(cliente.nombre)
Se puede definir un registro con la misma estructura que una tabla de la base
de datos:
DEFINE<id>RECORDLIKE<tabla>.*
Por supuesto, ser necesario haber indicado el nombre de la base de datos
mediante la instruccin DATABASE
Ej:
databasecontabilidad
defineregrecordlikemayor.*
definerctarecordlikecuentas.*
Funciones:
Las funciones se declararn con la siguiente sintaxis:
FUNCTION<nombre>([par1[,par2,...]])
declaraciones variables locales y parmetros
sentencias
ENDFUNCTION
Si la funcin rebice parmetros, se relacionarn los nombres de los

parmetros formales entre los parntesis. Hay que tener en cuenta que los
parmetros habr que declararlos dentro de la funcin, junto con las variables
locales, si las hubiera.
Ej:
functiongraba_registro(r,donde)
definerrecordlikeclientes.*
definedondechar(20)
ifdonde="clientes"then
insertintoclientesvalues(r.*)
else
insertintoproveedoresvalues(r.*)
endif
endfunction
La funcin main, es una excepcin. Su sintaxis es:
MAIN
declaraciones variables locales
sentencias
ENDMAIN
La funcin main es, como se coment anteriormente, la primera funcin que

se ejecuta al lanzar la aplicacin. La variable global arg_count indica el nmero
de parmetros que se han enviado al programa, y la funcin arg_val(i) devuelve
el parmetro nmero i. Al igual que en C, el parmetro nmero cero es el nombre
del programa.
Ej:
main
defineparamchar(50)
ifarg_count=0then
display"Error.Numerodeparametroserroneo."
exitprogram
endif
letparam=arg_val(1)
...
endmain
Una funcin puede devolver varios parmetros usando la sentencia return,

cuya sintaxis es:
RETURN
[<expresion1>[,<expresion2>[,....<expresion_n>]]]
El lenguaje soporta recursividad sin que exista ms lmites que los impuestos
por el compilador de C usado
Ej:
functionfactorial(n)
defineninteger
ifn=0then
return1
else
returnn*(factorial(n1))
endif
endfunction
Expresiones:
Expresiones simples:
hy4GL soporta las siguientes expresiones simples:
Variable
Basta con indicar el nombre de la variable. El tipo de la expresin ser el
mismo que el tipo de la variable. La variable debe ser de un tipo bsico,
no permitindose para este tipo de expresiones nombres de registros.
Ej:
defineainteger
displaya
displayr.nombre
o
Nmero
Se pueden usar nmeros enteros o reales. Para indicar decimales se usa el
punto '.' y no se deben usar separadores para los miles. Si el nmero no
lleva el punto decimal, la expresin ser de tipo entero, mientras que
ser de tipo float en caso de llevarlo.
Ej:
display4
display4.5
Cadena
Se expresarn las cadenas entre comillas dobles "". Laexpresinserde

tipocadena.
Ej:
display"Error."
display"Noseencuentraelcliente"
Operadores USING, CLIPPED y [ ]:

Operador USING
El operador USING convierte
especificado en la mscara.
una
expresin
numrica
al
formato
La sintaxis es la siguiente:
expresionUSINGmascara
La mscara consistir en una serie de caracteres '-','#','&',',' y '.'. La mscara

es aplicada a la expresin numrica, devolviendo una cadena en la que los
caracteres '-','#' y '&' son sustituidos por los dgitos correspondientes. El smbolo
'#' es usado para rellenar con espacios a la izquierda; el smbolo '-' rellena
tambin con espacios, excepto en la primera posicin en la que no haya dgtos,
que ser sustituida por el signo '-' en caso de que el nmero sea negativo. El
smbolo '&' se usa para rellenar con ceros las posiciones correspondientes. Los
signos ',' se usan para separar los miles y el '.' para indicar la posicin del punto
decimal
Ej:
0using"##,###.##">"."
10.23using"##,###.##">"10.23"
1123.23using"##,###.##">"1,123.23"
1123.23using"&&,&&&.&&">"01,123.23"
1123.23using",&.&&">"1,123.23"
Operador CLIPPED
El operador CLIPPED corta los espacios finales de una cadena. La expresin

resultante es una nueva cadena. Su sintaxis es la siguiente:
expresionCLIPPED
Ej:
letnombre="JUAN"
letapellidos="PEREZ"
letnomape=nombre+apellidos/*nomape="JUANPEREZ"
*/
letnomape=nombreclipped+apellidos/*
nomape="JUANPEREZ"*/
letnomape=nombreclipped+""+apellidos/*
nomape="JUANPEREZ*/
Operador [ ]
El operador [ ] permite obtener una subcadena a partir de una expresin. La
nueva expresin resultante es de tipo cadena. Su sintaxis es la siguiente:
expresion[i,j]
expresion[i]
Entre los corchetes se indicarn la posicin de inicio y final de la subcadena

que se desea obtener. Se puede omitir la posicin de final, con lo que se tomar la
subcadena que comienza y termina en la posicin 'i'.
Ej:
definecccchar(20)
defineentidad,sucursalchar(4)
definedc1,dc2char
definecuentachar(10)
prompt"Introduzcasunumerodecuenta(20digitos)
"forccc
letentidad=ccc[1,4]
letsucursal=ccc[5,8]
letdc1=ccc[9]
letdc2=ccc[10]
letcuenta=ccc[11,20]
Llamadas a funciones
Los valores devueltos por una funcin son usados como expresiones. El tipo
de estas expresiones depender del tipo de los valores devueltos por la funcin.
Ej:
definehoratime
lethora=time()/*lafunciontime()devuelvela
horaactual*/
Operadores binarios
Los siguientes operadores transforman dos expresiones en una nueva
expresin. El tipo de la expresin resultante depender de los tipos de las
expresiones originales.
Operador +
Este operador toma dos expresiones y devuelve una nueva expresin,
resultado de sumar las dos expresiones originales. El significado
de sumardepende del tipo de las expresiones originales. En el siguiente cuadro se
detalla el comportamiento de este operador:
Char
("10")
Char
Integer
Float
Date
Time
Datetime
Interval
"10"
(5)
(5.5)
(10/12/1998)
(10:10:05)
(10/12/1998
10:10:05)
(123:10:20)
Char
Char
Char
Char
Char
Char
Char
"1010"
"105"
(105.5"
"1010-12-1998"
"1010:10:05"
"1010-12-1998
"10123:10:20"
10:10:05"
Char
Integer
Float
Date
Time
Datetime
Interval
"10"
(5)
(5.5)
(10/12/1998)
(10:10:05)
(10/12/1998
10:10:05)
(123:10:20)
Integer
Char
Integer
Float
Date
Time
Datetime
Interval
(5)
"510"
10
10.5
15/12/1998
10:10:10
10-12-1998
123:10:25
10:10:10"
Float
Char
Float
Float
Date
Time
Datetime
Interval
(5.5)
"5.500010"
10.5
11
15/12/1998
10:10:10
10-12-1998
123:10:25
10:10:10"
Date
(10-121998)
Char
Date
Date
"10-12-199810"
15-12-1998
15-12-1998
No permitido
Datetime
No permitido
No permitido
No permitido
Time
10-12-1998
10:10:05
Time
(10:10:05)
Char
Time
Time
Datetime
"10:10:05.00010"
10:10:10
10:10:10
10-12-1998
No permitido
13:20:25
10:10:05
Datetime
(10-12-1998
Char
Datetime
Datetime
10-12-1998
10:10:05.00010
10-12-1998
10-12-1998
10:10:10
10:10:10
Char
Interval
Interval
123:10:20.010
123:10:25
123:10:25
10:10:05)
Interval
(123:10:20)
No permitido
No permitido
No permitido
15-12-1998 13:20:25
No permitido
Time
Datetime
Interval
13:20:25
15-12-1998
246:20:40
13:20:25
Operador -
Datetime
Devuelve la expresin resultante de calcular la diferencia entre las dos

expresiones originales. El comportamiento de este operador, as como el tipo de
la expresin resultante depende de las expresiones originales:
Char
Char
Integer
Float
Date
Time
Datetime
Interval
"10"
(5)
(5.5)
(10/12/1998)
(10:10:05)
(10/12/1998
10:10:05)
(123:10:20)
No permitido
No
permitido
No
permitido
No permitido
No permitido
No permitido
No permitido
Integer
Integer
Float
No permitido
No permitido
No permitido
No permitido
-5
-0.5
Float
Float
Float
Float
No permitido
No permitido
No permitido
No permitido
(5.5)
-4.5
0.5
Date
No permitido
Date
Date
Integer
No permitido
Integer
No permitido
5-12-1998
15-12-1998
diferencia en dias
diferencia en dias
("10")
Integer
(5)
(10-12-1998)
Time
No permitido
(10:10:05)
Datetime
No permitido
(10-12-1998
10:10:05)
Interval
(123:10:20)
No permitido
Time
Time
No permitido
Time
No permitido
10:10:00
10:10:10
Datetime
Datetime
Interval
Datetime
Interval
Datetime
10-12-1998
10-12-1998
10:10:05
10-12-1998
00:00:00
00:00:00
5-12-1998 06:59:45
10:10:00
10:10:00
Interval
Interval
No permitido
No permitido
No permitido
Interval
123:10:15
123:10:15
00:00:00
Time
06:59:45
00:00:00
Operadores * y /
Estos operadores realizan las operaciones aritmticas de producto y divisin
respectivamente. Slo pueden operar entre nmeros, ya sean reales o enteros. La
expresin que se obtiene es de tipo real.
Si se intenta operar con expresiones que no son de tipo numrico, stas se
convierten automticamente a tipo real.
Operadores de comparacin
Para realizar comparaciones de expresiones se usan los operadores <, <=, =, !
=, >= y >
expresion1<expresion2
expresion1<=expresion2
expresion1=expresion2
expresion1!=expresion2
expresion1>=expresion2
expresion1>expresion2
Las expresiones numricas se comparan, como es de esperar, por su valor.
Las expresiones de tipo cadena se comparan segn su orden alfabtico, teniendo
en cuenta que todas las maysculas van delante de las minsculas.
Las expresiones de tipo fecha/hora se comparan segn su antigedad.
De esta manera, se cumple que:
01-01-1998 < 02-01-1998
01-01-1998 10:10:25 > 01-01-1998 10:10:24
Estas expresiones devuelve 1 si se cumple la condicin, y 0 en caso contrario.

Operadores lgicos
Las siguientes expresiones realizan las operaciones lgicas comunes:
!expresion
expresionANDexpresion
expresionORexpresion
Estas expresiones devuelven verdadero (1) o falso (0) segn se cumpla o no

la condicin.
Precedencia de operadores
La precedencia de los operadores en hy4GL es, de mayor a menor, la
siguiente:
!
USINGCLIPPED
[]
*/
+
<<==!=>>=
AND
OR
Se han colocado en la misma lnea aquellos operadores que tienen la misma

precedencia. Se pueden agrupar expresiones entre parntesis para conseguir que
las operaciones se realicen en un orden determinado
Sentencias:
C Embebido (ampliacin a Informix-4GL)
El lenguaje aporta una gran funcionalidad y permite al programador relizar la
mayora de las acciones necesarias para el desarrollo de una aplicacin de bases
de datos. Sin embargo, siempre hay acciones que no es posible realizar
directamente usando las sentencias del lenguaje 4GL o que por motivos de
eficiencia es preferible realizarlas en lenguaje C.
Para estos casos, hy4GL permite insertar sentencias en C dentro del fuente en
4GL. La sintaxis para ello es la siguiente:
...
sentencias4GL
.c
[declaracionesC]
sentenciasC
c.
sentencias4GL
...
Dentro del bloque de C se puede acceder a los datos almacenados en las
variables del programa. Vase la gua de implementacin para conocer los tipos
de datos con los que se implementan las variables. Tambin se pueden definir
variables cuyo mbito ser el del bloque de C exclusivamente.
Ej:
defineusuariochar(50)
definedirectoriochar(255)
/*leoelnombredeusuarioyeldirectorioactual
*
.c
strncpy(usuario,getenv("LOGNAME"),sizeof(usuario)
1);
getcwd(directorio,sizeof(directorio1));
c.
ifusuario="root"then
display"Nopuedeejecutarelprogramacomoroot."
exitprogram
endif
Asignacin:
Para asignar valores a variables se usar la sentencia LET. Su sintaxis es la
siguiente:
LET<id>=expresion
El lenguaje realiza la conversin automtica de tipos, por lo que no es

necesario que la expresin sea del mismo tipo que la variable de destino.
Ej:
definedtdatetime
defineddate
defineiinteger
definecchar(40)
letdt=datetime()/*Asignaadtlafechayhora
actual*/
letd=dt/*Asignaa'd'lafechaactual*/
/*Asignaa'c'unacadenaconlafechayhora
contenida
en'dt'enelformato"ddmmaaaaHH:MM:SS.mmm"*/
letc=dt
leti="50"+"20"/*Asignaa'i'elnumero5020*/
Asignaciones mltiples (ampliacin a Informix-4GL)
Se permite realizar varias asignaciones en una misma sentencia LET. La

sintaxis para ello es la siguiente1:
LET<id1>,<id2>,...=expresion1,expresion2,...
A la variable id1 se le asignar el valor de la expresin expresion1; a la

variable id2 el valor de la expresin expresion2, etc. Habr que prestar
especial atencin en que el nmero de variables de destino sea igual al nmero de
valores devueltos por las expresiones. Especial cuidado hay que tener al llamar a
funciones, ya que una funcin puede devolver varios valores:
definesw_encontradointeger
definenombre,apellidos,direccionchar(50)
LETsw_encontrado,nombre,apellidos=
datos_cliente("0001")
Esta construccin puede ser til para operaciones como intercambio de

valores entre variables (swap), para lo cual no es necesario una variable temporal:
LETa,b=b,a
Al igual que en cualquier situacin en la que se puede expresar una lista de

variables, es posible asignar valores a todos los campos de un registro de la
siguiente manera:
LET<id>.*=expresion1,expresion2,...
Ej:
LETcliente.*="JUAN","PEREZ","C/RABIDA,
10",21003,"HUELVA"
Estructuras condicionales y repetitivas:

hy4GL ofrece las siguientes construcciones para variar el flujo del programa:
EXIT PROGRAM
Esta sentencia provoca el final inmediato del programa. Se desconecta de la
base de datos (si estuviera conectado) y el terminal vuelve a su estado normal. No
se borra la pantalla.
Ej:
defineusuariolikeusuarios.nombre
prompt"Usuario:"forusuario
select*intousuariofromusuarioswhere
nombre=usuario
ifstatus=notfoundthen
display"Accesodenegado\n"
exitprogram
endif
Llamadas a funciones
Se puede realizar una llamada a una funcin mediante la sentencia CALL. La
sintaxis de esta sentencia es la siguiente:
CALLfuncion(expr1,expr2,...)[RETURNING
var1,var2,...]
En caso de que la funcin devuelva uno o ms valores, se usar la

clusula RETURNING para asignar estos valores a variables.
Ej:
defineclienterecordlikeclientes.*
prompt"Codigodelcliente:"forcliente.numero
callbusca_cliente(cliente.numero)returning
cliente.*
Condiciones IF... THEN... ELSE... END IF

Esta estructura permite la ejecucin de una serie de sentencias slo en caso de
que se cumpla una condicin. De manera opcional se puede indicar tambin un
conjunto de sentencias que se ejecutarn si la condicin no se cumple.
IF<condicion>THEN
sentencias1
[ELSE
sentencias2]
ENDIF
En primer lugar se evaluar la condicin. En caso de que sta se cumpla, se

ejecutar el grupo de sentencias sentencias1. Si la condicin no se cumple, se
ejecutar el grupo de sentencias sentencias2.
Ej:
ifdow(today())="Domingo"then
display"Cerrado."
exitprogram
else
callmenu_ppal()
endif
Bucles WHILE
Esta construccin permite ejecutar un conjunto de sentencias mientras se
cumpla una condicin. La condicin se evaluar antes de entrar en el bucle, por
lo que si sta no se cumple, es posible que no se entre nunca en el bucle.
WHILE<condicion>
sentencias
CONTINUEWHILE
EXITWHILE
...
ENDWHILE
Dentro del bucle se pueden usar las sentencias CONTINUE

WHILEyEXIT WHILE. La primera salta hasta el principio del bucle,
ignorando las sentencias que se encuentran despus de sta. EXITWHILE sale
del bucle directamente.
Ej:
definei,total,parcialinteger
leti=0
lettotal=0
/*Facturasquesumannuestroprimermillon*/
whiletotal<1000000
leti=i+1
/*lafacturanumero3nolasumo...*/
ifi=3then
continuewhile
endif
selectimporteintoparcialfromfacturaswhere
numero=i
display"Error...noseencuentralafacturan",i
lettotal=0
exitwhile
endif
display"Fra:",i,"Importe:",parcialusing
"###,###,##&"
lettotal=total+parcial
endwhile
Bucles FOR
Los bucles FOR son usados para ejecutar un conjunto de sentencias variando
el valor de una variable desde un valor inicial hasta un valor final.
La variable que se use para ir variando su valor debe ser de tipo numrico o
de tipo fecha. En la primera iteracin su valor ser el de la expresin1, y se ir
incrementando en una unidad hasta alcanzar el valor de la expresin2.
FOR<variable>=<expresion1>TO<expresion2>
sentencias
CONTINUEFOR
EXITFOR
...
ENDFOR
Al igual que en los bucles WHILE, se pueden usar las sentencias CONTINUE
FOR y EXITFOR para forzar una nueva iteracin o para salir inmediatamente
del bucle.
Ej:
{Mostramostodoslosdiaslaborablesdeestemes
apartirdehoy}
defineminteger
defineddate
letmes=month(today())
ford=today()totoday()+31
ifmonth(d)!=mesthen
exitfor
endif
ifdow(d)="Domingo"ordow(d)="Sabado"then
continuefor
endif
displayd
endfor
Interfaz de usuario
Operaciones con ventanas.
La informacin que aparece en pantalla se muestra dentro de ventanas. Todo
programa en hy4GL usa, al menos, una ventana que se crea automticamente al
iniciar el programa y que ocupa toda la pantalla.
OPEN WINDOW
Se pueden definir ventanas de cualquier tamao y en cualquier posicin,

siempre que quepan dentro de los lmites de la pantalla. Si se intenta crear una
ventana de mayor tamao que la pantalla, sta ser reducida hasta caber en
pantalla. La sentencia para crear una nueva ventana es OPENWINDOW, cuya
sintaxis es la siguiente2:
OPENWINDOW<nombre>AT<y>,<x>WITH<h>ROWS,<w>
COLUMNS
[ATTRIBUTE(<color>[OVER<color>][,BRIGHT]
[,BORDER])]
[TITLEexpresion]
Ej:
openwindoww1at1,1with10rows,78columns
attribute(whiteoverred,bright,border)
title"Tareasparaeldia"+today()
display"Estaventanasecerraren1segundo"
delay1
closewindoww1
Si se indica un atributo de color, la ventana se muestra con ese atributo, y

todo lo que se escriba dentro de ella tendr ese mismo atributo si no se indica lo
contrario. Si entre los atributos se incluye la opcin 'BORDER', la ventana se
muestra con un borde que la rodea. El borde se dibuja en las coordenadas
indicadas, y la parte til de la ventana queda reducida en dos lneas y dos
columnas, que son las que ocupa el borde3.
Una vez que se abre una nueva ventana, sta pasa a ser la ventana
activa.Todo lo que se muestre en pantalla a partir de ese instante aparecer en
esta ventana.
Las ventanas slo pueden ser referenciadas desde la funcin en la que se han
creado. No se puede cerrar ni realizar ninguna operacin sobre una ventana desde
una funcin distinta, excepto escribir en ella.
Las ventanas son apilables: se puede definir una ventana encima de otra sin
que se pierda el contenido de la ventana que queda oculta.
CURRENT WINDOW
Para cambiar la ventana activa se usa la sentencia CURRENTWINDOW, cuya

sentencia es:
CURRENTWINDOW<nombre>
Slo es posible activar una ventana desde la funcin en la que sta se ha

definido. Una vez activada una ventana, todo lo que se muestre en pantalla
aparecer en ella.
Ej:
currentwindowwmensajes
prompt"Noseencuentraelregistro."forchar
tecla
currentwindowwproceso
endif
La ventana pasa a estar en lo ms alto de la pila de ventanas. Si la ventana

estaba ocultada total o parcialmente por otra ventana, ahora ser visible
totalmente.
MOVE WINDOW
En ocasiones es necesario mover una ventana para poder abrir otra sin ocultar
la anterior. La sintaxis de la sentencia para mover una ventana es:
MOVEWINDOW<nombre>TO<y>,<x>
La ventana debe haberse creado en la misma funcin desde la que se mueve.

Esta sentencia no cambia el estado de la ventana en cuanto a si est o no activa, o
su posicin en la pila de ventanas.
CLEAR WINDOW
Esta sentencia borra el contenido de la ventana activa.
CLOSE WINDOW
Para cerrar una ventana se usa la sentencia CLOSE WINDOW. La ventana

debe haber sido creada desde la misma funcin en la que se cierra. Si sta era la
ventana activa, la nueva ventana activa pasa a ser la que estuviera
inmediatamente debajo de sta en la pila de ventanas (la ltima que estaba activa
antes que sta).
CLOSEWINDOW<nombre>
Presentacin en pantalla
Para mostrar datos en pantalla se usa la sentencia DISPLAY, cuya sintaxis es
la siguiente:
DISPLAYexpresion[,expresion...][ATy,x]
[ATTRIBUTE(color[overcolor][,bright])]
[,expresion...AT...ATTRIBUTE...]
Las expresiones son presentadas siempre en la ventana activa. Si no se

incluye la clusula AT,las expresiones son mostradas en la posicin actual del
cursor. Los atributos de color con los que aparecern las expresiones son los de la
ventana activa por defecto, o los indicados en la clusula ATTRIBUTE.
El cursor se mueve a la posicin del ltimo carcter despus de ejecutar la

sentencia DISPLAY. Si no se ha indicado la clusula AT, se imprimir un retorno
de carro despus de mostrar todas las expresiones. Si se ha llegado a la ltima
lnea de la ventana activa, todo el contenido de la misma subir una lnea.
Ej:
display"Nombre:",cliente.nombreat1,1
attribute(cyanoverblue,bright),
"Direccin:",cliente.direccionat2,1
attribute(cyanoverblue)
Introduccin de datos simples4

La instruccin PROMPT permite obterner el valor de una variable a travs del
teclado. El programa presentar en pantalla una expresin opcional, su ejecucin
se dentendr hasta que se introduzca una cadena y se pulse la tecla Intro. La
cadena es convertida al tipo de dato de la variable de destino.
Si se especifica la opcin CHAR, el valor de la primera tecla pulsada es
asignado a la variable de destino, sin que se espere a la pulsacin de la tecla
Intro.
La sintaxis de la sentencia PROMPT es la siguiente:
PROMPT[expresion]FOR[CHAR]<variable>
Ej:
defineteclachar
definei,jinteger
prompt"Introduceunnumero:"fori
display"Introduceotronumero:"
promptforj
prompt"Pulseunateclaparacontinuar..."forchar
tecla
Mens:
hy4GL ofrece la sentencia MENU para la definicin de mens de opciones.
Un men consiste en una serie de opciones, cada una de las cuales tiene asociada
un conjunto de sentencias que se ejecutarn en caso de ser seleccionadas.
Adems, es posible indicar un grupo de acciones que se ejecutarn al pulsar una
tecla determinada.
La sintaxis para la definicin de mens es la siguiente:
MENU[HORIZONTAL|VERTICAL]
[ATTRIBUTE(color[OVERcolor])[;(color[OVER
color])]]
COMMAND<expresion>[,<expresion>]
sentencias
ONKEY(<id>)
sentencias
...
EXITMENU
...
ENDMENU
Las distintas opciones se relacionarn en las clusulas COMMAND. La primera

expresin que sigue a la clusula es la cadena que se mostrar en pantalla. La
segunda expresin es opcional e indica un texto de ayuda asociado a la opcin.
Este texto aparecer en pantalla cuando el cursor se site sobre la opcin. Una
vez que el usuario pulse la tecla Intro, se ejecutarn las sentencias relacionadas
tras la clusula COMMAND correspondiente a la opcin seleccionada.
Las opciones aparecern en pantalla en la primera lnea de la ventana activa

(las que quepan), a no ser que se indique la opcin VERTICAL, en cuyo caso
aparecern una sobre otra. La opcin activa aparece marcada por un signo '-', y se
muestra con los colores invertidos. Es posible cambiar los colores por defecto
tanto de todas las opciones como de la opcin seleccionada mediante la clusula
ATTRIBUTE. El color de las opciones se indica en primer lugar y,
opcionalmente y separado del anterior por un punto y coma ';', se indicar el
atributo de color de la opcin activa.
Las teclas de movimiento del cursor permiten seleccionar la opcin. En caso
de que haya ms opciones de las que caben en pantalla, el movimiento del cursor
provocar que stas vayan apareciendo. La tecla 'Intro' selecciona una opcin y
provoca que se ejecuten las sentencias asociadas a la misma. Una vez ejecutadas
todas las sentencias, el men sigue activo y es posible seleccionar una nueva
opcin.
La clusula ON KEY permite indicar un conjunto de acciones que se
ejecutarn al presionar una tecla determinada.
La sentencia EXITMENU provoca la salida del men.
Ej:
openwindoww_menuat1,1with5rows,78columns
attribute(yellowoverblue,bright,border)
menu
command"Articulos","Gestiondealmacen"
callgest_almacen()
command"Clientes","Gestiondeclientes"
callgest_clientes()
command"Proveedores","Gestiondeproveedores"
callgest_prov
command"Salir","Findelaaplicacion"
exitmenu
onkey(F1)
openwindoww_ayudaat5,5with10rows,50columns
attribute(whiteoverred)
callayuda()
closewindoww_ayuda
onkey(F8)
exitmenu
endmenu
closewindoww_menu
exitprogram
Formularios de entrada:
Se vio anteriormente la sentencia PROMPT, que permite introducir
informacin por teclado. En esta seccin se ver el uso de formularios de entrada
de datos. Estos formularios permiten la introduccin y visualizacin de
informacin de una manera ms compleja que la ofrecida por la sentencia
PROMPT.
Los formularios de entrada permiten al usuario editar el valor de varias
variables al mismo tiempo, desplazndose con el cursor entre distintos campos.
Un formulario est compuesto por uno o ms campos de edicin, botones y
casillas de verificacin. Los campos de edicin aparecen en pantalla como
regiones rectangulares en las que se puede introducir un texto. Las casillas de
verificacin son cuadros de edicin que slo admiten los valores 'X' o ' '
(activado/desactivado). Los botones permiten ejecutar acciones al ser pulsados.
Formato
El formato del formulario se define fuera de las funciones y siguiendo la

siguiente sintaxis:
FORM<nombre>
INPUT<nombre>FROMy,xTOy2,x2
BUTTON<nombre>ATy,x
CHECK<nombre>ATy,x
ENDFORM
El formulario debe tener un nombre, con el que es accedido desde el

programa. Los objetos que lo componen se identifican tambin mediante un
nombre.
Al definir el formulario se pueden indicar los atributos de color que deben
tener los objetos. Si no se indica nada, tendrn los mismos que la ventana sobre
la que se muestre el formulario.
Manejo
CREATEFORM<nombre>
La primera accin que hay que realizar para poder usar un formulario de
entrada es crearlo. La sentencia CREATE FORM crea en memoria todas las
estructuras necesarias para el manejo del formulario. El formulario es creado y
asociado a la ventana actual. No se puede tener dos formularios activos al mismo
tiempo en la misma ventana.
DISPLAYFORM<nombre>
La sentencia CREATEFORM prepara el formulario para su uso, pero no lo
muestra en pantalla. Para ello, se necesita usar la sentencia DISPLAYFORM.
DISPLAYBYNAME<variables>
Esta sentencia muestra el valor de las variables especificadas. Cada variable

es mostrada dentro del campo del formulario cuyo nombre sea igual al de la
variable.
INPUTBYNAME<variables>
Esta sentencia es usada para obtener el valor de las variables indicadas a

travs del formulario. Al usuario se le presenta en pantalla el formulario y podr
ir introduciendo valores en los distintos campos y moverse entre ellos mediante

el uso de las teclas de movimiento de cursor. El programador puede definir una
serie de sentencias que se ejecutarn al salir de un campo determinado, al pulsar
una tecla determinada o al pulsar sobre un botn.
La sintaxis de esta sentencia es la siguiente:
INPUTBYNAME<variables>
ONKEY('x')
sentencias
ONBUTTON<nombre>
sentencias
AFTERFIELD<nombre>
sentencias
...
VALIDATEFIELD
...
EXITINPUT
...
NEXTFIELD<nombre>
...
AFTERFIELD<nombre>
...
ENDINPUT
Cuando el usuario sale de un campo (moviendo el cursor para entrar en un

nuevo campo), el contenido del buffer de edicin es asignado a la variable de
destino. El programador puede entonces usar las clusulas AFTERFIELD para
controlar la validez del dato o para realizar cualquier tipo de accin.
La sentencia VALIDATEFIELD puede ser usada dentro de un bloque de
cdigo que se ejecuta al pulsar sobre una tecla. Esta sentencia fuerza a que se
actualice el valor de la variable de destino con el contenido del campo activo
actualmente. Esto es necesario hacerlo dentro de las sentencias que se ejecutan en
una clusula ONKEY, ya que el valor de las variables de destino no se actualiza
normalmente hasta que no se ha salido del campo.
Si alguna de las sentencias modifica el valor de una variable que se est
editando, ser necesario enviar al formulario el nuevo valor de la variable
mediante el uso de la sentencia 'DISPLAYBYNAME'.
Desde dentro del propio formulario es posible mover el cursor a un campo
determinado usando la sentencia 'NEXTFIELD' o terminar la edicin mediante
la sentencia EXITINPUT
Ej:
formf_clientes
inputcodigofrom1,10to1,6
inputnombrefrom2,10to2,30
inputdireccionfrom3,10to3,30
checkfacturarat4,10
buttonaceptarat2,40
buttoncancelarat3,40
endform
functioneditar_cliente
definesw_aceptadointeger
definerrecord
codigointeger
nombrechar(20)
direccionchar(20)
facturarinteger
endrecord
letsw_aceptado=0
createformf_clientes
displayformf_clientes
inputbynamer.*
onkey(F1)
callayuda()
onbuttonaceptar
validatefield
letsw_aceptado=1
exitinput
onbuttoncancelar
letsw_aceptado=0
exitinput
afterfieldcodigo
ifr.codigo<100then
letr.codigo=0
displaybynamer.codigo
nextfieldr.codigo
endif
endinput
endfunction
Acceso a Bases de Datos. Sentencias SQL

El objetivo de este manual no es explicar la sintaxis del lenguaje SQL, sino
ver de qu forma se integra este lenguaje en el 4GL implementado.
Transacciones
PostgreSQL es un gestor de bases de datos transaccional. Permite agrupar
operaciones dentro de transacciones y anular todas las actualizaciones realizadas
por una transaccin si es necesario. Las sentencias para indicar el comienzo y
final de una transaccin son:
BEGINTRANSACTION
Indica el comienzo de una transaccin. Todas las actualizaciones que se
realicen sobre la base de datos no sern definitivas hasta que se ejecute la
sentencia COMMITTRANSACTION
COMMITTRANSACTION
Esta sentencia indica que se ha llegado al final de una transaccin y que se
deben fijar todas las actualizaciones realizadas sobre la base de datos.
ABORTTRANSACTION
Con esta sentencia se cancela una transaccin. Todas las actualizaciones
realizadas desde la sentencia BEGINTRANSACTION son desechadas.
Hay que tener cuidado de no anidar transacciones. Es comn cometer el error

de comenzar una transaccin y llamar a una funcin que no sabemos que tambin
comienza otra transaccin. Hasta ah no hay problema. El problema llega cuando
la segunda transaccin ejecuta un 'COMMITTRANSACTION'. En ese momento
se estn aceptando TODAS las actualizaciones realizadas a la base de datos, no
slo las de la ltima transaccin; sin embargo, la transaccin inicial an no ha

terminado.
Consultas
La sentencia SELECT de SQL busca en una o varias tablas aquellos registros
que cumplan determinadas condiciones.
SELECT<lista_campos>[INTO<lista_variables>]
FROM<lista_tablas>
[WHERE<condicion>]
[ORDERBY<lista_campos>]
Si se indica la clusula INTO, los valores de los campos devueltos son

asignados a las variables que se indiquen. Si la consulta devuelve ms de una
tupla, se asignarn los valores de los campos de la primera de ellas, y se presenta
un aviso en pantalla.
Es posible conocer si una consulta no ha devuelto ninguna tupla. La variable
global 'status' tendr el valor notfound en caso de no encontrar registros
que cumplan la condicin.
Ej:
prompt"Codigo:"forr.codigo
select*intor.*fromclientes
wherecodigo=r.codigo
display"Noseencuentraelcliente",r.codigo
else
display"Elcliente",r.codigo,"sellama
",r.nombre
endif
Insercin de valores
La sentencia de SQL para insertar valores dentro de una tabla es INSERT.
En hy4GL se usa con la misma sintaxis que en SQL:
INSERT INTO <tabla> VALUES ( <expresiones> )
Ej:
inputbynamer_cliente.*
onbuttonaceptar
ifconfirmar()="SI"then
insertintoclientesvalues(r_cliente.*)
ifstatus=okthen
exitinput
else
callmensaje_error("Nosepuedeinsertarel
registro")
exitprogram
endif
endif
endinput
La insercin de valores puede fallar por diversas causas (que el usuario no

tenga permiso para escribir en al tabla, que ya exista un registro con la misma
clave primaria, etc). Para conocer si una instruccin INSERT ha conseguido o no
su cometido, se puede consultar el valor de la variable global status. sta valdr
ok si la insercin ha sido correcta.
Borrado de valores
Para borrar valores de una tabla se usa la sentencia DELETE de SQL. Su
sintaxis es la siguiente:
DELETEFROM<tabla>[WHERE<condicion>]
Si no se indica ninguna condicin se borrarn TODOS los registros de la

tabla.
Ej:
prompt"Deseaborrarelalbarn"+num_albaran+
"ahoraqueestfacturado?(S/N)"forcharsino
ifsino="s"orsino="S"then
deletefromalbaraneswherenumero=num_albaran
endif
Cursores
Una consulta a la base de datos puede devolver varias tuplas. PostgreSQL
ofrece dos mtodos para acceder a los datos devueltos por estas consultas. Por un
lado, se pueden obtener del servidor de bases de datos todas las tuplas devueltas
por la consulta y, una vez en memoria, tratarlas de manera local. Por otra parte, se
puede declarar un cursor e ir obteniendo las tuplas una a una para tratarlas. La
desventaja de este ltimo mtodo es que PostgreSQL solamente permite hacerlo
dentro de una transaccin, mientras que el primero no se puede usar si la consulta
devuelve gran cantidad de tuplas.
hy4GL ofrece una interfaz homognea para usar ambos mtodos. En ambos
ser necesario declarar un cursor. Si se opta por el primer mtodo, se incluir el
atributo de local en la declaracin del cursor.
La sintaxis de la declaracin de un cursor es la siguiente:
DECLARE<nombre>[LOCAL]CURSORFORselect...
DECLARE<nombre>[LOCAL]CURSORFORexpresion
Ej:
declareclocalcursorfor
select*fromclienteswhereult_compra<"111998"
Ej:
letconsulta=
"selectprovincia,count(*)fromclientesgroupby
provincia"
declareccursorforconsulta
Un cursor slo se puede declarar una vez en el mdulo fuente.

Antes de poder usar los datos devueltos por la consulta hay que abrir el
cursor. Al abrir un cursor se evalan las expresiones que se hayan incluido en las
clusulas where de la consulta y se ejecuta la misma.
La sentencia para abrir un cursor es la siguiente:
OPEN<cursor>
El propio compilador comprueba si se trata de un cursor declarado como

local o no. En caso de que se haya declarado como local, ejecuta la consulta y
obtiene del servidor TODAS las tuplas resultantes. Si no se ha declarado como
local, simplemente se abre el cursor en el servidor.
Una vez abierto un cursor se pueden obtener las tuplas resultantes de la

consulta con la sentencia FETCH, cuya sintaxis es la siguiente
FETCH[NEXT|PREVIOUS]<cursor>INTO
<lista_variables>
Si el cursor se ha declarado como local, se asignan directamente a las

variables de destino los valores de los campos de la siguiente tupla, que ya est
en memoria. Si el cursor no se ha declarado como local, se obtiene en ese
momento del servidor la siguiente tupla y sus campos son asignados a las
variables.
Es posible obtener la tupla anterior en lugar de la siguiente usando la
opcin PREVIOUS
Si se ha llegado al final de la consulta (o al principio, si se ha
usado PREVIOUS), la variable global status tomar el valor de notfound
Al finalizar el trabajo con el cursor es necesario cerrar el mismo. La
sentencia CLOSE cierra el cursor y libera la memoria usada por el mismo (y por
las tuplas resultantes de la consulta, en caso de que el cursor estuviera declarado
como local). Su sintaxis es:
CLOSE<cursor>
Ej:
declareclocalcursorforselect*fromclientes
wherecodigo<10
openc
fetchcintor.*
whilestatus!=notfound
display"Cliente",r.codigo,"",r.nombre
fetchcintor.*
endwhile
closec
EXEC_SQL
hy4GL no soporta la sintaxis completa del lenguaje SQL, sin embargo ofrece
esta sentencia para permitir al programador ejecutar sentencias SQL no
soportadas por el lenguaje.
Su sintaxis es la siguiente:
EXEC_SQL<expresion>[INTO<lista_variables>]
Si la sentencia ejecutada devuelve valores, stos pueden ser asignados a

variables mediante la clusula INTO, y se podr usar la variable
globalstatus para conocer si se han obtenido o no valores (status!
=notfound). Por contra, si se trata de una sentencia que no devuelve valores, la
variable global status tomar el valor ok si se ha ejecutado con xito
Ej:
EXEC_SQL"createtabletmp_numeros(iinteger);"
ifstatus!=okthen
display"nosehapodidocrearlatablatemporal"
endif
Ej:
EXEC_SQL"selectmax(numero)fromfacturas"INTO
num_fac
FOREACH
La estructura FOREACH se usa para recorrer un cursor desde el pricipio
hasta el final. La sintaxis de esta estructura repetitiva es la siguiente:
FOREACH<cursor>INTO<lista_variables>
sentencias
...
CONTINUEFOREACH
...
EXITFOREACH
...
ENDFOREACH
El cursor debe estar declarado, pero no abierto. El cursor se abrir

automticamente al entrar en el FOREACH. Por cada tupla del mismo, sus
campos son asignados a la lista de variables y se ejecutan las sentencias.
La sentencia CONTINUE FOREACHfuerza a que se avance hasta la

siguiente tupla. , mientras que la sentencia EXITFOREACH cierra el cursor y
sale del bucle.
Cuando el cursor llega hasta el final ste se cierra automticamente y termina
la ejecucin del bucle.
Ej:
definerrecordlikediario.*
definenum_ctalikediario.cta
declareccursorforselect*fromdiariowhere
cta=num_cta
lettotal=0
foreachcintor.*
ifr.debe_haber="D"then
lettotal=totalr.importe
else
lettotal=total+r.importe
endif
endforeach
display"saldo:",total
BROWSE (ampliacin a Informix-4GL)

Esta sentencia es usada para presentar en pantalla el resultado de una consulta
a la base de datos. Es necesario definir un cursor con la consulta que se pretende
visualizar. El cursor hay que declararlo como LOCAL.
BROWSE<cursor>INTO<lista_variables>
[FROMy,xTOyy,xx]
[TITLE<expresion]
DISPLAY<expresiones>
ONKEY(id)
sentencias
ONKEY(num)
sentencias
ONKEY(cadena)
sentencias
...
EXITBROWSE
ENDBROWSE
Al llegar el programa a esta sentencia, se abre automticamente el cursor, se

ejecuta la consulta y se obtienen todas las tuplas resultantes. Para imprimir cada
una de ellas, se asignan los distintos campos de la tupla actual a las variables
indicadas en la clusula INTO, y se imprimen las expresiones de la
clusula DISPLAY.
A partir de este momento, el usuario podr desplazarse por las tuplas
resultantes usando las teclas de movimiento de cursor. Pulsando la tecla ESCape,
se abandona la sentencia BROWSE y se cierra el cursor.
El programador puede definir una serie de sentencias a ejecutar cuando el
usuaro pulse una tecla determinada. Entre estas sentencias puede incluirEXIT
BROWSE, que abandonar el BROWSE y cerrar el cursor.
Ej:
definerprecordlikeprovincias.*
declareclocalcursorforselect*fromprovincias
browsecintorp.*
title"MatriculaProvincia"
displayrp.mat+""+rp.nombre
onkey(F1)
callayuda()
onkey(KEY_ENTER)
callver_provincia(rp.*)
onkey(F8)
exitbrowse
endbrowse
Generador de Listados
El lenguaje 4GL ofrece una sintaxis sencilla a la vez que potente para generar
listados. El generador de listados controla los saltos de pgina, encabezamientos
y los cambios de grupo, lo que facilita enormemente la tarea al programador.
Formato del listado
Los listados se definen fuera de las funciones con la siguiente sintaxis:
REPORT<nombre>(parametros)
declaracioneslocales
OUTPUT
REPORTTO<fichero>
REPORTTOPIPE<comando>
PAGEWIDTH<num>
PAGEHEIGTH<num>
FORMAT
FIRSTPAGEHEADER
sentencias
PAGEHEADER
sentencias
BEFOREGROUPOF<lista_variables>
sentencias
ONEVERYROW
sentencias
AFTERGROUPOF<lista_variables>
sentencias
PAGEFOOTER
sentencias
ONLASTROW
sentencias
ENDREPORT
Un listado debe tener un nombre y recibir unos parmetros, que sern la base
de la informacin que se imprima. Al igual que una funcin, un listado puede
usar variables locales para realizar sus clculos internos. Estas variables habr
que definirlas junto con los parmetros formales.
La definicin de un listado tiene dos secciones: la primera, OUTPUT, en la
que se indica el nombre del fichero de salida o un comando que se ejecutar y al
que se va a enviar la salida del listado. En esta seccin se especifica tambin el
tamao (lineas y columnas) de una pgina, para permitir la deteccin automtica
de los saltos de pgina.
En la segunda seccin, FORMAT, se indica la apariencia que va a tomar el
listado. Consta de varias condiciones (todas ellas opcionales) y de las sentencias
que se deben ejecutar al cumplirse cada una de las condiciones.
FIRSTPAGEHEADER
Sentencias que se deben ejecutar al comenzar el listado.
PAGEHEADER
Sentencias que se deben ejecutar al comenzar cada pgina
BEFOREGROUPOF<var1>,<var2>,...
Sentencias que se ejecutarn cuando se vaya a producir un cambio en los
valores de las variables indicadas
ONEVERYROW
Sentencias que se ejecutan en cada lnea
AFTERGROUPOF
Sentencias que se ejecutan despus de producirse el cambio en los valores
de las variables.
PAGETRAILER
Sentencias que se ejecutan al final de cada pgina
ONLASTROW
Sentencias que se ejecutan al final del listado
Para enviar realmente una lnea al listado se usa la sentencia PRINT. Esta
sentencia deber estar incluida en alguna/s de las condiciones de la
seccinFORMAT de la definicin del listado si se quiere que el listado produzca
alguna salida.
Dentro de un listado se pueden usar las variables pageno y lineno, que
indican el nmero de pgina y el nmero de lnea dentro de la pgina
respectivamente.
Sentencias de control de listados

Para generar un listado se usan las siguientes sentencias:
STARTREPORT<nombre>
Esta sentencia indica el comienzo del listado. Al ejecutarla se preparan
todas las estructuras internas y se crean tablas temporales para almacenar
la informacin que va a generar el listado.
o
OUTPUTTOREPORT<nombre>(param1,
param2,...)
Enva al generador de listados los parmetros indicados.
o
FINISHREPORT<nombre>
Da por finalizado el listado. Al ejecutar esta sentencia es cuando se genera
realmente el listado a partir de todos los parmetros recibidos mediante
sentencias OUTPUTTOREPORT
Ej:
functionlistar_alumnos()
definerrecordlikealumnos.*
declareccursorforselec*fromalumnosorderby
grupo
startreportr1
foreachcintor.*
outputtoreportr1(r.grupo,r.nombre)
endforeach
finishreportr1
endfunction
reportr1(grupo,nombre)
definegrupochar(5)
definenombrechar(40)
outputreporttopipe"lpdlaser"
pagewidth78
pagelength64
format
firstpageheader
print"LISTADODEALUMNOSPORGRUPOFecha:"+today()
print""
print"Nombreyapellidos"
print""
pageheader
print"LISTADODEALUMNOSPORGRUPOPag:"+pageno
print""
print"Nombreyapellidos"
print""
beforegroupofgrupo
print
print"Grupo:",grupo
print""
oneveryrow
printnombre
endreport
Uso del compilador de 4GL.

El programa con el que se invoca al compilador es hy4gl. Se trata de un
script que comprueba el tipo de cada uno de los archivos que recibe como
parmetro y ejecuta el programa necesario para compilarlo.
hy4gl solamente procesa aquellos archivos con extension .4gl. El resto de
archivos, as como todos los dems parmetros que reciba son enviados al
compilador de C.
Si no se especifica el parmetro o (para indicarle al compilador de C el
nombre del ejecutable que debe generar, en lugar de a.out), se generar un
ejecutable con el mismo nombre que el primer archivo que se mande como
parmetro a hy4gl, y con extensin .e
Ej:
Para generar alumnos.e a partir de alumnos.4gl:
hy4glalumnos.4gl
o
Para
generar gestion.ea
profesores.4glyalumnos.4gl:
partir
demenu.4gl,
hy4glogestion.emenu.4glprofesores.4gl
alumnos.4gl
o
Para compilar profesores.4gl y obtener el modulo objeto, pero no
generar ejecutable:
hy4glcprofesores.4gloprogesores.o
Variables de entorno
Las siguientes variables de entorno pueden influir en el comportamiento del
compilador:
o
HYVERB: Si existe esta variable de entorno, el compilador muestra
en pantalla el cdigo generado.
o
C_LIBRARY_PATH: Indica la lista de directorios en los que el
enlazador va a buscas las libreras
o
C_INCLUDE_PATH: Indica la lista de directorios en los que el
compilador de C va a buscar los archivos de cabecera.
Las siguientes variables de entorno pueden influir en el comportamiento de

las aplicaciones generadas:
o
HY4GLHOST y HY4GLPORT: si existen, indican el nombre del
host y el puerto TCP/IP del servidor de PostgreSQL.
Indice
Sintaxis del lenguaje 4GL. 1

Comentarios 1
Declaraciones de variables: 2
Tipos de datos: 2
Declaracin de variables: 3
Funciones: 5
Expresiones: 7
Expresiones simples: 7
Operadores USING, CLIPPED y [ ]: 8
Operador USING 8
Operador CLIPPED 8
Operador [ ] 9
Llamadas a funciones 10
Operadores binarios 10
Operador + 10
Operador - 11
Operadores * y / 11
Operadores de comparacin 12
Operadores lgicos 12
Precedencia de operadores 13
Sentencias: 14
C Embebido (ampliacin a Informix-4GL) 14
Asignacin: 15
Asignaciones mltiples (ampliacin a Informix-4GL) 15
Estructuras condicionales y repetitivas: 17
EXIT PROGRAM 17
Llamadas a funciones 17
Condiciones IF... THEN... ELSE... END IF 18
Bucles WHILE 18
Bucles FOR 20
Interfaz de usuario 21
Operaciones con ventanas. 21
OPEN WINDOW 21
CURRENT WINDOW 22
MOVE WINDOW 22
CLEAR WINDOW 22
CLOSE WINDOW 22
Presentacin en pantalla 23
Introduccin de datos simples 23
Mens: 24
Formularios de entrada: 26
Formato 26
Manejo 26
Acceso a Bases de Datos. Sentencias SQL 30
Transacciones 30
Consultas 30
Insercin de valores 31
Borrado de valores 32
Cursores 32
EXEC_SQL 34
FOREACH 34
BROWSE (ampliacin a Informix-4GL) 35
Generador de Listados 37
Formato del listado 37
Sentencias de control de listados 39
Uso del compilador de 4GL. 41
Variables de entorno 41
1Nota para los usuarios de Informix-4GL: En Informix-4GL se usa la coma ',' para concatenar cadenas.
Una consecuencia directa de esto es que no se puedan concatenar cadenas al enviar parmetros a
funciones, debiendo asignar primero las cadenas a una variable y despus enviar dicha variable a la
funcin. Para evitar estos problemas, hy4GL usa el operador '+' para concaternar cadenas.
2La opcin TITLE es una ampliacin a la sintaxis de Informix-4GL.
3Informix-4GL muestra un borde 'exterior' a la ventana.
4Vase tambin la seccin 'Formularios de Entrada'.
hy4GL: compilador de lenguaje 4GL para PostgreSQL 2-43

Manual de Usuario 4GL

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Manual de Usuario 4GL

Uploaded by

Copyright:

Available Formats

Manual de Usuario

En uno de los mdulos debe haber una funcin llamada 'main'. La

El rango permitido para nmeros enteros es el de un 'long int' de C.

Este tipo permite usar nmeros reales. Se implementa mediante el tipo de

Permite usar cadenas de caracteres. No hay lmite para el tamao de la

Adems de los tipos de datos bsicos, se permite definir registros, formados

Si la aplicacin accede a bases de datos, es posible definir variables del

Para ello es necesario que se haya indicado el nombre de la base de datos en

Es posible definir registros que agrupen varias variables en una sola

Si la funcin rebice parmetros, se relacionarn los nombres de los

La funcin main, es una excepcin. Su sintaxis es:

La funcin main es, como se coment anteriormente, la primera funcin que

Una funcin puede devolver varios parmetros usando la sentencia return,

Se expresarn las cadenas entre comillas dobles "". Laexpresinserde

Operadores USING, CLIPPED y [ ]:

La mscara consistir en una serie de caracteres '-','#','&',',' y '.'. La mscara

El operador CLIPPED corta los espacios finales de una cadena. La expresin

Entre los corchetes se indicarn la posicin de inicio y final de la subcadena

Devuelve la expresin resultante de calcular la diferencia entre las dos

Estas expresiones devuelve 1 si se cumple la condicin, y 0 en caso contrario.

Estas expresiones devuelven verdadero (1) o falso (0) segn se cumpla o no

Se han colocado en la misma lnea aquellos operadores que tienen la misma

El lenguaje realiza la conversin automtica de tipos, por lo que no es

Asignaciones mltiples (ampliacin a Informix-4GL)

Se permite realizar varias asignaciones en una misma sentencia LET. La

A la variable id1 se le asignar el valor de la expresin expresion1; a la

Esta construccin puede ser til para operaciones como intercambio de

Al igual que en cualquier situacin en la que se puede expresar una lista de

Estructuras condicionales y repetitivas:

En caso de que la funcin devuelva uno o ms valores, se usar la

Condiciones IF... THEN... ELSE... END IF

En primer lugar se evaluar la condicin. En caso de que sta se cumpla, se

Dentro del bucle se pueden usar las sentencias CONTINUE

Se pueden definir ventanas de cualquier tamao y en cualquier posicin,

Si se indica un atributo de color, la ventana se muestra con ese atributo, y

Para cambiar la ventana activa se usa la sentencia CURRENTWINDOW, cuya

Slo es posible activar una ventana desde la funcin en la que sta se ha

La ventana pasa a estar en lo ms alto de la pila de ventanas. Si la ventana

La ventana debe haberse creado en la misma funcin desde la que se mueve.

Esta sentencia borra el contenido de la ventana activa.

Para cerrar una ventana se usa la sentencia CLOSE WINDOW. La ventana

Las expresiones son presentadas siempre en la ventana activa. Si no se

El cursor se mueve a la posicin del ltimo carcter despus de ejecutar la

Introduccin de datos simples4

La sintaxis de la sentencia PROMPT es la siguiente:

Las distintas opciones se relacionarn en las clusulas COMMAND. La primera

Las opciones aparecern en pantalla en la primera lnea de la ventana activa

El formato del formulario se define fuera de las funciones y siguiendo la

El formulario debe tener un nombre, con el que es accedido desde el

Esta sentencia muestra el valor de las variables especificadas. Cada variable

Esta sentencia es usada para obtener el valor de las variables indicadas a

ir introduciendo valores en los distintos campos y moverse entre ellos mediante

Cuando el usuario sale de un campo (moviendo el cursor para entrar en un

Acceso a Bases de Datos. Sentencias SQL

Hay que tener cuidado de no anidar transacciones. Es comn cometer el error

slo las de la ltima transaccin; sin embargo, la transaccin inicial an no ha

Si se indica la clusula INTO, los valores de los campos devueltos son

La insercin de valores puede fallar por diversas causas (que el usuario no

Si no se indica ninguna condicin se borrarn TODOS los registros de la

La sintaxis de la declaracin de un cursor es la siguiente:

Un cursor slo se puede declarar una vez en el mdulo fuente.

El propio compilador comprueba si se trata de un cursor declarado como

Una vez abierto un cursor se pueden obtener las tuplas resultantes de la