|
3.
Listado alfabético de todas las rutinas
?
| Sintaxis: |
? x |
| Descripción: |
Es la forma abreviada de: pretty_print(1,
x, {}) - es decir, de imprimir el valor de una expresión
en la salida estándar, con llaves y sangría para
mostrar la estructura. |
| Ejemplo: |
|
|
? {1, 2} + {3, 4} -- mostrará {4, 6}
|
| Ver también: |
pretty_print,
print
|
abort
| Sintaxis: |
abort(i)
|
| Descripción: |
Aborta la ejecución de un programa.
El argumento 'i' es un entero pequeño para devolver el
estado al sistema operativo. Un valor 0 generalmente indica la
terminación exitosa del programa. Otros valores pueden
indicar distintos tipos de errores. Los programas por lotes DOS
(.bat) pueden leer este valor usando la función errorlevel.
Un programa Euphoria puede leer este valor usando system_exec().
|
| Comentarios: |
abort()
es útil cuando un programa está ejecutando llamadas
subrutinas anidadas y es necesario terminar la ejecución
inmediatamente, tal vez debido a la detección de un error
severo.
Si no se usa abort(),
ex.exe/exw.exe/exu terminarán
devolviendo normalmente el código de estado 0. Si el programa
falla debido a un error en tiempo de compilación o ejecución
detectado por Euphoria, entonces el código de estado de
terminación será 1. |
| Ejemplo: |
|
|
if x = 0 then
puts(ERR, "No se puede dividir por 0 !!!\n")
abort(1)
else
z = y / x
end if
|
| Ver también: |
crash_message,
system_exec
|
all_palette
| Plataforma: |
DOS32 |
| Sintaxis: |
include graphics.e
all_palette(s) |
| Descripción: |
Especifica nuevas intensidades de color
para un conjunto entero de colores en el modo gráfico en
uso. 's' es una secuencia de la forma:
{{r,g,b}, {r,g,b}, ..., {r,g,b}}*
Cada elemento especifica una nueva intensidad
de color {red, green, blue}* para el número de color correspondiente,
comenzando por el número de color 0. Los valores para rojo,
verde y azul tienen que estar dentro del rango 0 a 63.
* La terna {r,g,b}={red, green, blue} tal como
se la conoce en inglés es {rojo, verde, azul} en español.
|
| Comentarios: |
Esta rutina se ejecuta mucho más
rápido que si se usa palette()
para establecer las nuevas intensidades de los colores uno por
uno. Este procedimiento se puede usar con read_bitmap()
para mostrar rápidamente una imagen en pantalla. |
| Programa de ejemplo: |
demo\dos32\bitmap.ex |
| Ver también: |
get_all_palette,
palette,
read_bitmap,
video_config,
graphics_mode
|
allocate
| Sintaxis: |
include machine.e
a = allocate(i) |
| Descripción: |
Asigna 'i' bytes contiguos de memoria. Devuelve
la dirección del bloque de memoria, o devuelve 0 si no
la pudo asignar. La dirección devuelta será de al
menos 4 bytes alineados. |
| Comentarios: |
Al terminar de usar el bloque, debería
pasar su dirección a free().
Esta función liberará el bloque y dejará
la memoria disponible para otros usos. Euphoria no liberará
o reusará su bloque hasta que se llame explícitamente
a free().
Cuando termina su programa, el sistema operativo reclamará
toda la memoria para usarla con otros programas. |
| Ejemplo: |
|
|
buffer = allocate(100)
for i = 0 to 99 do
poke(buffer+i, 0)
end for
|
| Ver también: |
free,
allocate_low,
peek,
poke,
call
|
allocate_low
| Plataforma: |
DOS32 |
| Sintaxis: |
include machine.e
i2 = allocate_low(i1) |
| Descripción: |
Asigna 'i1' bytes contiguos de memoria baja,
es decir memoria convencional (direcciones por debajo de 1 Mb).
Devuelve la dirección del bloque de memoria, o devuelve
0 si no la pudo asignar. |
| Comentarios: |
Algunas interrupciones de software de DOS
requieren que les pase una o más direcciones en registros.
Esas direcciones tienen que estar dentro de las direcciones de
la memoria convencional para que DOS sea capaz de leerlas o escribir
en ellas. |
| Programa de ejemplo: |
demo\dos32\dosint.ex |
| Ver también: |
dos_interrupt,
free_low,
allocate,
peek,
poke
|
allocate_string
| Sintaxis: |
include machine.e
a = allocate_string(s) |
| Descripción: |
Asigna espacio para una secuencia de cadena
's'. Copia 's' dentro de este espacio, junto con el caracter 0
de terminación. Este es el formato esperado por las cadenas
de C. Se devuelve la dirección de memoria de la cadena.
Si no hay suficiente memoria disponible, se devuelve 0. |
| Comentarios: |
Para liberar la cadena, use free().
|
| Ejemplo: |
|
|
atom titulo
titulo = allocate_string("El Mago de Oz")
|
| Programa de ejemplo: |
demo\win32\window.exw |
| Ver también: |
allocate,
free
|
allow_break
| Sintaxis: |
include file.e
allow_break(i) |
| Descripción: |
Cuando 'i' valga 1 (verdadero), Ctrl+C y
Ctrl+Break pueden terminar el programa, cuando intenta leer la
entrada desde el teclado. Si 'i' vale 0 (falso), no se podrá
terminar el programa con Ctrl+C o Ctrl+Break. |
| Comentarios: |
El DOS mostrará ^C en pantalla, aún
cuando no se pueda terminar el programa.
Inicialmente, el programa se puede terminar
el programa en cualquier punto, donde intente leer una entrada
desde el teclado. También podría terminarse mediante
otra operación de E/S, dependiendo de las opciones que
el usuario haya establecido en el archivo config.sys. (Consultar
el manual de MS-DOS para el caso del comando BREAK). En algunos
programas, esta terminación abrupta podría dejar
cosas en un estado desordenado que podría provocar la pérdida
de datos. allow_break(0)
le permite evitar esta situación.
Se puede saber si el usuario presionó Ctrl+C o Ctrl+Break,
llamando a check_break().
|
| Ejemplo: |
|
|
allow_break(0) -- no permita que el usuario me aniquile!
|
| Ver también: |
check_break
|
and_bits
| Sintaxis: |
x3 = and_bits(x1, x2)
|
| Descripción: |
Ejecuta la operación lógica
AND sobre los bits correspondientes en 'x1' y 'x2'. El bit en
'x3' será 1 solamente si los bits correspondientes en 'x1'
y 'x2' son ambos 1. |
| Comentarios: |
Los argumentos se tienen que poder representar como números
de 32 bits, sean con o sin signo.
Si intenta manipular valores de 32 bits completos,
debería declarar sus variables como átomos,
en lugar de enteros. El tipo entero de Euphoria está limitado
a 31 bits.
Los resultados se tratan como números
con signo. Serán negativos cuando el bit de mayor orden
sea 1.
Para comprender la representación binaria
de un número debería mostrarlo en notación
hexadecimal. Para ello, use el formato %x de printf().
|
| Ejemplo 1: |
|
|
a = and_bits(#0F0F0000, #12345678)
-- a es #02040000
|
| Ejemplo 2: |
|
|
a = and_bits(#FF, {#123456, #876543, #2211})
-- a es {#56, #43, #11}
|
| Ejemplo 3: |
|
|
a = and_bits(#FFFFFFFF, #FFFFFFFF)
-- a es -1
-- Observe que #FFFFFFFF es un número positivo,
-- pero el resultado en una operación lógica bit a bit se interpreta
-- como un número con signo de 32 bits, por lo tanto es negativo.
|
| Ver también: |
or_bits,
xor_bits,
not_bits,
int_to_bits
|
append
| Sintaxis: |
s2 = append(s1, x) |
| Descripción: |
Crea una nueva secuencia idéntica
a 's1', pero con 'x' agregado al final como último elemento.
La longitud de 's2' será length(s1)
+ 1. |
| Comentarios: |
Si 'x' es un átomo, esto es equivalente a s2 = s1 &
x, si 'x' es una secuencia, no.
El almacenamiento adicional se asigna automáticamente
y en forma muy eficiente, debido a la asignación dinámica
de memoria de Euphoria. El caso donde 's1' y 's2' son la misma
variable (como en el Ejemplo 1) está altamente optimizado.
|
| Ejemplo 1: |
Puede usar append()
para hacer crecer una secuencia dinámicamente, por ejemplo: |
|
sequence x
x = {}
for i = 1 to 10 do
x = append(x, i)
end for
-- x ahora es {1,2,3,4,5,6,7,8,9,10}
|
| Ejemplo 2: |
Se puede agregar cualquier tipo de objeto de Euphoria a una secuencia,
por ejemplo: |
|
sequence x, y, z
x = {"juan", "pedro"}
y = append(x, "maría")
-- y ahora es {"juan", "pedro", "maría"}
z = append(append(y, "laura"), {"bum", "bum"})
-- z ahora es {"juan", "pedro", "maría", "laura", {"bum", "bum"}}
|
| Ver también: |
prepend,
concatenation operator &, sequence-formation
operator |
arccos
| Sintaxis: |
include misc.e
x2 = arccos(x1) |
| Descripción: |
Devuelve un ángulo cuyo coseno es igual a 'x1'. |
| Comentarios: |
El argumento 'x1' tiene que estar en el rango -1 a +1 inclusive.
Se devolverá un valor entre 0 y PI
radianes.
Esta función se puede aplicar a un átomo o a todos
los elementos de una secuencia.
arccos() no es
tan rápido como arctan().
|
| Ejemplo: |
|
|
s = arccos({-1,0,1})
-- s es {3.141592654, 1.570796327, 0}
|
| Ver también: |
cos,
arcsin,
arctan
|
arcsin
| Sintaxis: |
include misc.e
x2 = arcsin(x1) |
| Descripción: |
Devuelve un ángulo cuyo seno es igual a 'x1'. |
| Comentarios: |
El argumento 'x1' tiene que estar en el rango -1 a +1 inclusive.
Se devolverá un valor entre -PI/2
y +PI/2
(radianes).
Esta función se puede aplicar a un átomo o a todos
los elementos de una secuencia.
arcsin() no es
tan rápido como arctan().
|
| Ejemplo: |
|
|
s = arcsin({-1,0,1})
-- s es {-1.570796327, 0, 1.570796327}
|
| Ver también: |
sin,
arccos,
arctan
|
arctan
| Sintaxis: |
x2 = arctan(x1)
|
| Descripción: |
Devuelve un ángulo cuyo tangente es igual a 'x1'. |
| Comentarios: |
Se devolverá un valor entre -PI/2
y +PI/2
(radianes).
Esta función se puede aplicar a un átomo o a todos
los elementos de una secuencia.
arctan() es más
rápida que arcsin()
o arccos().
|
| Ejemplo: |
|
|
s = arctan({1,2,3})
-- s es {0.785398, 1.10715, 1.24905}
|
| Ver también: |
tan,
arcsin,
arccos
|
atom
| Sintaxis: |
i = atom(x) |
| Descripción: |
Devuelve 1 si 'x' es un átomo, 0 en caso contrario. |
| Comentarios: |
Sirve para definir el tipo átomo.
También puede llamarla como una función ordinaria
para determinar si un objeto es un átomo. |
| Ejemplo 1: |
|
|
atom a
a = 5.99
|
| Ejemplo 2: |
|
|
object line
line = gets(0)
if atom(line) then
puts(SCREEN, "fin del archivo\n")
end if
|
| Ver también: |
sequence,
object,
integer,
atoms and sequences |
atom_to_float32
| Sintaxis: |
include machine.e
s = atom_to_float32(a1) |
| Descripción: |
Convierte un átomo de Euphoria en
una secuencia de 4 valores de un byte. Esos 4 bytes contienen
la representación de un número de punto flotante
IEEE en formato de 32 bits. |
| Comentarios: |
Los átomos de Euphoria puden tener
valores que son números de punto flotante IEEE de 64 bits,
por lo tanto puede perder precisión al convertirlos a 32
bits (16 dígitos significativos contra 7). El rango del
exponente es mucho más grande en el formato de 64 bits
(10e308, contra 10e38), por lo que algunos átomos pueden
ser demasiado grandes o demasiado pequeños para representarlos
en 32 bits. En este caso, obtendrá uno de los valores especiales
de 32 bits: inf o -inf (infinito
o -infinito). Para evitar esto, puede usar atom_to_float64().
Los valores enteros se convertirán también al
formato de punto flotante de 32 bits. |
| Ejemplo: |
|
|
fn = open("numeros.dat", "wb")
puts(fn, atom_to_float32(157.82)) -- escribe 4 bytes a un archivo
|
| Ver también: |
atom_to_float64,
float32_to_atom
|
atom_to_float64
| Sintaxis: |
include machine.e
s = atom_to_float64(a1) |
| Descripción: |
Convierte un átomo de Euphoria en
una secuencia de 8 valores de un byte. Esos 8 bytes contienen
la representación de un número de punto flotante
IEEE en formato de 64 bits. |
| Comentarios: |
Todos los átomos Euphoria tiene valores
que se pueden representar como números IEEE de punto flotante
de 64 bits, por lo que puede convertir cualquier átomo
al formato de 64 bits sin perder precisión.
Los valores enteros se convertirán también al
formato de punto flotante de 64 bits. |
| Ejemplo: |
|
|
fn = open("numeros.dat", "wb")
puts(fn, atom_to_float64(157.82)) -- escribe 8 bytes a un archivo
|
| Ver también: |
atom_to_float32,
float64_to_atom
|
bits_to_int
| Sintaxis: |
include machine.e
a = bits_to_int(s) |
| Descripción: |
Convierte una secuencia de valores binarios
(1 y 0) a un número positivo. El bit menos significativo
es s[1]. |
| Comentarios: |
Si imprime 's', los bits aparecerán
en orden inverso, pero es conveniente para tener índices
crecientes que le den acceso a los bits en orden ascendente de
significación. |
| Ejemplo: |
|
|
a = bits_to_int({1,1,1,0,1})
-- a es 23 (binario 10111)
|
| Ver también: |
int_to_bits,
operations on sequences |
bk_color
| Sintaxis: |
include graphics.e
bk_color(i) |
| Descripción: |
Establece el color de fondo a uno de los
16 colores estándares. En los modos
gráficos de píxel la pantalla entera se afectará
inmediatamente. En los modos de texto
cualquier nuevo caracter que imprima tendrá el nuevo color
de fondo. |
| Comentarios: |
Los 16 colores estándares están definidos en graphics.e
En los modos gráficos
de píxel, el color 0 que normalmente es NEGRO, será
establecido al mismo valor {r,g,b}de paleta que el número
de color 'i'.
En algunos modos gráficos
de píxel, hay un color de borde que aparece
en los extremos de la pantalla. En los modos de 256 colores, este
es el 17º color en la paleta. Puede controlarlo como lo hace
con cualquier otro color.
En los modos de texto,
para recuperar el color de fondo original cuando termina su programa,
por ejemplo 0 - NEGRO, tiene que llamar a bk_color(0).
Si el cursor está en la última línea de la
pantalla, tiene que imprimir algo antes de terminar su programa.
Un '\n' puede ser suficiente. |
| Ejemplo: |
|
|
bk_color(BLACK)
|
| Ver también: |
text_color,
palette
|
bytes_to_int
| Sintaxis: |
include machine.e
a = bytes_to_int(s) |
| Descripción: |
Convierte una secuencia de 4 elementos de
valores byte en un átomo. Los elementos de 's' están
en el orden esperado por un entero de 32 bits en el 386+, es decir,
el byte menos significativo primero. |
| Comentarios: |
El resultado podría ser mayor que
lo que permite el tipo entero, por eso tiene que asignarlo a un
átomo.
's' normalmente podría contener valores
positivos que se pueden haber leido usando peek()
desde 4 posiciones consecutivas de memoria. |
| Ejemplo: |
|
|
atom int32
int32 = bytes_to_int({37,1,0,0})
-- int32 es 37 + 256*1 = 293
|
| Ver también: |
int_to_bytes,
bits_to_int,
peek,
peek4s,
peek4u,
poke
|
... continua
A a B | C
a D | E a G |
H a O |
P a R | S a T |
U a Z
|