palette

Plataforma: DOS32
Sintaxis: include graphics.e
x = palette(i, s)
Descripción:
Cambia el color para el número de color 'i' a 's', donde 's' es una secuencia de intensidades de color RGB: {rojo, verde, azul}. Cada valor en 's' puede ir de 0 a 63. Si la operación resulta existosa, se devolverá una secuencia de 3 elementos conteniendo el color previo de 'i' y todos los píxeles en pantalla de color 'i' cambiarán al nuevo color. En cambio, si la operación falla, se devolverá el átomo -1.
Ejemplo: 
x = palette(0, {15, 40, 10})
-- número de color 0 (normalmente negro) cambia a un matiz verdoso.
Ver también: all_palette

peek

Sintaxis: i = peek(a)
o ...
s = peek({a, i})
Descripción:
Devuelve un valor de un byte en el rango de 0 a 255 desde la dirección 'a' de la máquina, o una secuencia conteniendo 'i' bytes consecutivos, comenzando por la dirección 'a' en la memoria.
Comentarios:
Como las direcciones son números de 32 bits, pueden ser mayores que el entero más grande (31 bits). Las variables que mantengan direcciones tendrán que ser declaradas como átomos.

Es más rápido leer varios bytes de una vez usando el segundo método de peek(), que leer de a un byte por vez dentro de un ciclo.

Recuerde que peek() sólo toma un argumento, el cual en el segundo método se trata realmente de una secuencia de 2 elementos.

Ejemplo: Los siguientes son equivalentes: 
-- método 1
s = {peek(100), peek(101), peek(102), peek(103)}

-- método 2
s = peek({100, 4})
Ver también: poke, peek4s, peek4u, allocate, free, allocate_low, free_low, call

peek4s

Sintaxis: a2 = peek4s(a1)
o ...
s = peek4s({a1, i})
Descripción:
Devuelve valor de 4 bytes (32 bits) con signo en el rango de -2147483648 a +2147483647 desde la dirección de la máquina 'a1', o una secuencia conteniendo 'i' consecutivos valores de 4 bytes (32 bits) con signo, comenzando en la dirección 'a1' de memoria.
Comentarios:

Como las direcciones son números de 32 bits, pueden ser demasiado grandes para el tipo entero de Euphoria, las variables que mantengan direcciones tendrán que ser declaradas como átomos. El mismo caso se plantea para el valor devuelto por peek4s(), el cual también tendría que ser una variable declarada como átomo.

Es más rápido leer varios valores de 4 bytes de una vez usando el segundo método de peek4s(), que leer de a 4 bytes por vez dentro de un ciclo.

Recuerde que peek4s() sólo toma un argumento, el cual en el segundo método se trata realmente de una secuancia de 2 elementos.
Ejemplo: Los siguientes son equivalentes: 
-- método 1
s = {peek4s(100), peek4s(104), peek4s(108), peek4s(112)}

-- método 2
s = peek4s({100, 4})
Ver también: peek4u, peek, poke4, allocate, free, allocate_low, free_low, call

peek4u

Sintaxis: a2 = peek4u(a1)
o ...
s = peek4u({a1, i})
Descripción:
Devuelve un valor de 4 bytes (32 bits) sin signo en el rango de 0 a 4294967295 desde la dirección de la máquina 'a1', o una secuencia conteniendo 'i' valores de 4 bytes sin signo consecutivos, comenzando por la dirección 'a1' en memoria.
Comentarios:

Como las direcciones son números de 32 bits, pueden ser demasiado grandes para el tipo entero de Euphoria, las variables que mantengan direcciones tendrán que ser declaradas como átomos. El mismo caso se plantea para el valor devuelto por peek4u(), el cual también tendría que ser una variable declarada como átomo.

Es más rápido leer varios valores de 4 bytes de una vez usando el segundo método de peek4u(), que leer de a 4 bytes por vez dentro de un ciclo.

Recuerde que peek4u() sólo toma un argumento, el cual en el segundo método se trata realmente de una secuancia de 2 elementos.

Ejemplo: Los siguientes son equivalentes: 
-- método 1
s = {peek4u(100), peek4u(104), peek4u(108), peek4u(112)}

-- método 2
s = peek4u({100, 4})
Ver también: peek4s, peek, poke4, allocate, free, allocate_low, free_low, call

PI

Sintaxis: include misc.e
PI
Descripción: PI (3.14159...) ha sido definido como una constante global.
Comentarios:
Se usaron los dígitos suficientes para lograr la máxima exactitud posible para un átomo de Euphoria.
Ejemplo: 
x = PI  -- x es 3.14159...
Ver también: sin, cos, tan

pixel

Plataforma: DOS32
Sintaxis: pixel(x1, s)
Descripción:
Establece uno o más píxeles en una pantalla gráfica de píxeles, comenzando en el punto 's', donde 's' es una coordenada de pantalla de 2 elementos {x, y}. Si 'x1' es un átomo, un píxel se establecerá al color indicado por 'x1'. Si 'x1' es una secuencia, entonces se establecerá una cantidad de píxeles, comenzando en 's' y moviéndose hacia la derecha (incrementando el valor de x, lo mismo para el calor de y).
Comentarios:
Cuando 'x1' es una secuencia, se utiliza un algoritmo muy veloz para ubicar los píxeles en pantalla. Es mucho más veloz que llamar una vez a pixel(), con una secuencia de colores de píxeles, que llamarla varias veces, pintando el color del píxel de a uno por vez.

En gráficos de modo 19, pixel() está altamente optimizado.

Cualquier píxel que quede fuera de pantalla será seguramente recortado.

Ejemplo 1: 
pixel(BLUE, {50, 60})
-- el punto {50,60} se establece al color BLUE (azul)
Ejemplo 2: 
pixel({BLUE, GREEN, WHITE, RED}, {50,60})
-- {50,60} establecido a BLUE (azul)
-- {51,60} establecido a GREEN (verde)
-- {52,60} establecido a WHITE (blanco)
-- {53,60} establecido a RED (rojo)
Ver también: get_pixel, graphics_mode

platform

Sintaxis: i = platform()
Descripción:
platform() es una función interna del intérprete. Indica la plataforma en la que se está ejecutando el programa: DOS32, WIN32, Linux o FreeBSD.
Comentarios:
Cuando se está ejecutando ex.exe, la plataforma es DOS32. Cuando se está ejecutandoexw.exe la plataforma es WIN32. Cuando se está ejecutando exu la plataforma es Linux (o FreeBSD).

El archivo de inclusión misc.e contiene las siguiente constantes:

    global constant DOS32 = 1,
                    WIN32 = 2,
                    LINUX = 3,
                    FREEBSD = 3
Use platform() cuando quiera ejecutar código diferente según la plataforma en la que el programa se ejecute.

Se agregarán plataformas adicionales en la medida que Euphoria sea portado a nuevas máquinas y sistemas operativos.

La llamada a platform() no cuesta nada. Está optimizada en tiempo de compilación para los valores enteros adecuados: 1, 2 o 3.

Ejemplo 1: 
if platform() = WIN32 then
    -- llama a la rutina Beep del sistema
    err = c_func(Beep, {0,0})
elsif platform() = DOS32 then
    -- hace el beep
    sound(500)
    t = time()
    while time() < t + 0.5 do
    end while
    sound(0)
else
    -- no hace nada (Linux/FreeBSD)
end if
Ver también: platform.doc

poke

se almacena realmente en memoria.
Sintaxis: poke(a, x)
Descripción:
Si 'x' es un átomo, escribe un valor de un byte en la dirección de memoria 'a'. Si 'x' es una secuencia, escribe una secuencia de valores de un byte en posiciones consecutivas de memoria, comenzando a partir de la dirección 'a'.
Comentarios: En memoria, se almacenan realmente los 8 bits inferiores de cada byte, es decir, remainder(x,256).

Es más rápido escribir varios bytes por vez usando poke() con una secuencia de valores, que escribiendo un byte por vez dentro de un ciclo.

Escribir la memoria de pantalla con poke() puede ser mucho más rápido que usar puts() o printf(), pero la programación es más complicada. En la mayoría de los casos, no se necesita velocidad. Por ejemplo, el editor de Euphoria (ed), no usa poke().

Ejemplo: 
a = allocate(100)   -- ubica 100 bytes en memoria

-- poke() de un byte por vez:
poke(a, 97)
poke(a+1, 98)
poke(a+2, 99)

-- poke() de 3 bytes por vez:
poke(a, {97, 98, 99})
Programa de ejemplo: demo\callmach.ex
Ver también: peek, poke4, allocate, free, allocate_low, free_low, call, safe.e

poke4

Sintaxis: poke4(a, x)
Descripción:
Si 'x' es un átomo, escribe un valor de 4 bytes (32 bits) en la dirección de memoria 'a'. Si 'x' es una secuencia, escribe una secuencia de valores de 4 bytes en posiciones consecutivas de memoria, comenzando a partir de la dirección 'a'.
Comentarios: El o los valores a almacenarse no deben exceder los 32 bits de tamaño.

Es más rápido escribir varios valores de 4 bytes por vez usando poke4() con una secuencia de valores, que escribiendo un valor de 4 bytes por vez dentro de un ciclo.

Los valores de 4 bytes a almacenarse pueden ser positivos o negativos. Puede leerlos, tanto con peek4s() como con peek4u().

Ejemplo: 
a = allocate(100)   -- ubica 100 bytes en memory

-- poke4() de un valor de 4 bytes por vez:
poke4(a, 9712345)
poke4(a+4, #FF00FF00)
poke4(a+8, -12345)

-- poke4() de 3 valores de 4 bytes por vez:
poke4(a, {9712345, #FF00FF00, -12345})
Ver también: peek4u, peek4s, poke, allocate, allocate_low, call

polygon

Plataforma: DOS32
Sintaxis: include graphics.e
polygon(i1, i2, s)
Descripción:
Dibuja un polígono de 3 o más vértices dados en 's', en una pantalla de gráficos de píxel, usando un cierto color 'i1'. Si 'i2' vale 1, se rellena el área, en cambio, con 0 no.
Ejemplo: 
polygon(GREEN, 1, {{100, 100}, {200, 200}, {900, 700}})
-- hace un triángulo sólido de color verde.
Ver también: draw_line, ellipse

position

Sintaxis: position(i1, i2)
Descripción:
Posiciona el cursor en la línea 'i1', columna 'i2', donde la esquina superior izquierda es la línea 1, columna 1. El siguiente caracter que se muestra en pantalla se imprimirá en esa posición. position() informará un error si la ubicación está fuera de la pantalla.
Comentarios: position() trabaja en los modos de texto y gráfico de píxel.

El sistema de coordenadas para mostrar texto es diferente del usado para mostrar píxeles. Los píxeles se muestran de forma que eñ superior izquierdo es (x=0,y=0) y la primera coordenada controla la ubicación horizontal superior derecha. En los modos de gráfico de píxel puede mostrar tanto texto como píxeles. position() solamente establece la línea y columna para el texto que se muestra, no los píxeles que dibuja. No hay una rutina correspondiente para establecer la posición del píxel siguiente.

Ejemplo: 
position(2,1)
-- el cursor se mueve al comienzo de la segunda línea
-- desde arriba
Ver también: get_position, puts, print, printf

power

Sintaxis: x3 = power(x1, x2)
Descripción: Eleva 'x1' a la potencia 'x2'.
Comentarios:
Los argumentos de esta función pueden ser átomos o secuencias. Se aplican las reglas de operaciones sobre secuencias. Las potencias de 2 se calculan muy eficientemente.
Ejemplo 1: 
? power(5, 2)
-- se imrime 25
Ejemplo 2: 
? power({5, 4, 3.5}, {2, 1, -0.5})
-- se imprime {25, 4, 0.534522}
Ejemplo 3: 
? power(2, {1, 2, 3, 4})
-- {2, 4, 8, 16}
Ejemplo 4: 
? power({1, 2, 3, 4}, 2)
-- {1, 4, 9, 16}
Ver también: log, sqrt

prepend

Sintaxis: s2 = prepend(s1, x)
Descripción: Agrega 'x' al comienzo de la secuencia 's1'. La longitud de 's2' será length(s1) + 1.
Comentarios:
Si 'x' es un átomo, es lo mismo que s2 = x & s1. Si 'x' es una secuencia, definitivamente no es lo mismo.

El caso en el que 's1' y 's2' son la misma variable, se maneja muy eficientemente.

Ejemplo 1: 
prepend({1,2,3}, {0,0})   -- {{0,0}, 1, 2, 3}

-- Compare con la concatenación:

{0,0} & {1,2,3}           -- {0, 0, 1, 2, 3}
Ejemplo 2: 
s = {}
for i = 1 to 10 do
    s = prepend(s, i)
end for
-- s es {10,9,8,7,6,5,4,3,2,1}
Ver también: append, operador de concatenación &, operador de formación de secuencias

pretty_print

Sintaxis: include misc.e
pretty_print(fn, x, s)
Descripción:
Imprime a un archivo o dispositivo 'fn', un objeto 'x' usando llaves { , , , }, indentación, y varias líneas para mostrar la estructura.

Se pueden dar varias opciones en 's' para controlar la presentación. Pase {} para elegir los valores por defecto o establezca las opciones como se muestra:
[1] muestra caracteres ASCII:
* 0: nunca
* 1: junto con cualquier entero en el rango ASCII imprimible (por defecto)
* 2: muestra como "cadena" cuando todos los enteros de una secuencia están en el rango ASCII
* 3: muestra cadenas y caracteres encomillados (solo) para cualquier entero en el rango ASCII
[2] cantidad de sangría para cada nivel de anidamiento de secuencias - valor por defecto: 2
[3] columna en la que comenzamos - valor por defecto: 1
[4] columna aproximada para aplicar "wrapping" - valor por defecto: 78
[5] formato para usar con enteros - valor por defecto:"%d"
[6] formato para usar con números de puntos flotante - valor por defecto:"%.10g"
[7] mínimo valor ASCII imprimible - valor por defecto: 32
[8] máximo valor ASCII imprimible - valor por defecto: 127

Si la longitud de 's' es menor que 8, las opciones sin especificar al final de la secuencia, mantendrán sus valores por defecto. Por ejemplo, {0, 5} seleccionará "nunca mostrar caracteres ASCII", más 5 caracteres de indentación, con valores por defecto para el resto.

Comentarios:
La impresión comenzará en la posición actual del cursor. Normalmente querrá llamar a pretty_print() cuando el cursor está en la columna 1 (después de imprimir un caracter \n). Si desea comenzar en una columna diferente, debería llamar a position() y especificar un valor para la opción [3]. Esto asegurará de que la primera y última llaves en una secuencia se alineen verticalmente.
Ejemplo 1: 
pretty_print(1, "ABC", {})    

{65'A',66'B',67'C'}
Ejemplo 2: 
pretty_print(1, {{1,2,3}, {4,5,6}}, {})  
          
{
  {1,2,3},
  {4,5,6}
}
Ejemplo 3: 
pretty_print(1, {"Lenguaje", "de Programación", "Euphoria"}, {2})  

{
  "Lenguaje",
  "de Programación",
  "Euphoria"
}
Ejemplo 4: 
puts(1, "word_list = ") -- mueve el cursor a la columna 13
pretty_print(1, 
             {{"Euphoria", 8, 5.3}, 
              {"Programming", 11, -2.9}, 
              {"Language", 8, 9.8}}, 
             {2, 4, 13, 78, "%03d", "%.3f"}) -- primeras 6 de 8 opciones

word_list = {
                {
                    "Euphoria",
                    008,
                    5.300
                },
                {
                    "Programming",
                    011,
                    -2.900
                },
                {
                    "Language",
                    008,
                    9.800
                }
            }
Ver también: ?, print, puts, printf

print

Sintaxis: print(fn, x)
Descripción:
Imprime a un archivo o dispositivo 'fn', un objeto 'x' entre llaves { , , , } para mostrar la estructura.
Ejemplo 1: 
print(1, "ABC")  -- la salida es:  {65, 66, 67}
puts(1, "ABC")   -- la salida es:  ABC
Ejemplo 2: 
print(1, repeat({10,20}, 3))
-- la salida es: {{10,20},{10,20},{10,20}}
Ver también: ?, pretty_print, puts, printf, get

printf

Sintaxis: printf(fn, st, x)
Descripción:
Imprime 'x' a un archivo o dispositivo 'fn', usando la cadena de formato 'st'. Si 'x' es un átomo, entonces se imprimirá un valor simple. Si 'x' es una secuencia, el formato en 'st' se aplicará a los elementos sucesivos de 'x'. Así printf() siempre toma 3 argumentos exactamente. Solamente variará la longitud del último argumento que contiene los valores a imprimir. Los formatos básicos son:

%d - imprime un átomo como un entero decimal
%x - imprime un átomo como un entero hexadecimal
%o - imprime un átomo como un entero octal
%s - imprime una secuencia como una cadena de caracteres o un átomo como un solo caracter
%e - imprime un átomo como un número de punto flotante con notación científica (exponencial)
%f - imprime un átomo como un número de punto flotante con punto decimal, sin exponente
%g - imprime un átomo como un número de punto flotante usando el formato %f o %e según sea el más adecuado
%% - imprime el caracter '%' en sí mismo

Se pueden agregar los anchos de los campos al formato básico, por ejemplo, %5d, %8.2f, %10.4s. El número antes del punto decimal es el ancho mínimo del campo a usarse. El número después del punto decimal es la presición a utilizarse.

Si el ancho del campo es negativo, por ejemplo, %-5d entonces el valor estará alineado a la izquierda dentro del campo. Normalmente estará alineado a la derecha. Si el ancho del campo comienza con un 0, por ejemplo, %08d se suministrarán ceros para completar el campo. Si el ancho del campo comienza con un '+', por ejemplo, %+7d entonces el signo + se imprimirá para los valores positivos.

Comentarios: Observe el siguiente error común: 
    nombre="Juan Pérez"
    printf(1, "%s", nombre)     -- error!
Esto imprimirá solo el primer caracter del nombre (J), ya que cada elemento del nombre se toma para ser un valor separado que se ajustará a formato. Debería decir en su lugar:
 
    nombre="Juan Pérez"
    printf(1, "%s", {nombre})   -- correcto
Ahora, el tercer argumento de printf() es una secuencia de un elemento que contiene el ítem a formatearse.
Ejemplo 1: 
tasa = 7.875
printf(miarchivo, "La tasa de interés es: %8.2f\n", tasa)

      La tasa de interés es:     7.88
Ejemplo 2: 
nombre="Juan Pérez"
puntos=97
printf(1, "%15s, %5d\n", {nombre, puntos})

      Juan Pérez,    97
Ejemplo 3: 
printf(1, "%-10.4s $ %s", {"ABCDEFGHIJKLMNOP", "XXX"})

      ABCD       $ XXX
Ver también: sprintf, puts, open

profile

Sintaxis: profile(i)
Descripción:
Habilita o deshabilita el análisis de perfiles en tiempo de ejecución. Trabaja tanto por conteo de ejecución como por análisis por tiempo. Si 'i' vale 1, entonces se habilitará el análisis y se grabarán las muestras/conteos. Si 'i' vale 0, el análisis estará deshabilitado y no habrá registración de ninguna naturaleza.
Comentarios:
Después de una sentencia "with profile" o "with profile_time", el análisis se habilita en forma automática. Use profile(0) para desactivalo. Use profile(1) para activarlo nuevamente cuando la ejecución alcanza el código sobre el que desea enfocar el análisis.
Ejemplo 1: 
with profile_time
profile(0)
  ...
procedure slow_routine()
profile(1)
  ...
profile(0)
end procedure
Ver también: trace, análisis de perfiles de ejecución, sentencias especiales de alto nivel

prompt_number

Sintaxis: include get.e
a = prompt_number(st, s)
Descripción:
Le pide al usuario que ingrese un número. 'st' es una cadena de texto que se mostrará en pantalla. 's' es una secuencia de dos valores {inferior, superior} que determina el rango de valores que el usuario puede ingresar. Si el usuario ingresa un número que está fuera de este rango, se le pedirá nuevamente el ingreso. 's' puede estar vacía, {}, si no hay restricciones.
Comentarios:
Si esta rutina es demasiado simple para sus necesidades, sientase libre de copiarla y hacer una versión propia más especializada.
Ejemplo 1: 
edad = prompt_number("¿Cuál es su edad? ", {0, 150})
Ejemplo 2: 
t = prompt_number("Ingrese una temperatura en ºC:\n", {})
Ver también: get, prompt_string

prompt_string

Sintaxis: include get.e
s = prompt_string(st)
Descripción:
Le pide al usuario que ingrese una cadena de texto. 'st' es una cadena que se mostrará en pantalla. La cadena que el usuario escriba se devolverá como una secuencia, sin ningún caracter de nueva línea.
Comentarios: Si el usuario escribe Ctrl+Z (indicación de fin de archivo), se devolverá "".
Ejemplo: 
nombre = prompt_string("¿Cuál es su nombre? ")
Ver también: gets, prompt_number

put_screen_char

Plataforma: DOS32, Linux, FreeBSD
Sintaxis: include image.e
put_screen_char(i1, i2, s)
Descripción:
Escribe cero o más caracteres en pantalla junto con sus atributos. 'i1' especifica la línea, e 'i2' la columna donde se debería escribir el primer caracter. La secuencia 's' se ve como: {código ASCII1, atributo1, código ASCII2, atributo2, ...}. Cada par de elementos en 's' describe un caracter. El átomo "código ASCII" contiene el código ASCII del caracter. El átomo de atributos, contiene el color del texto, color del fondo y posiblemente otra información dependiente de la plaraforma que controle la manera en que se muestra el caracter en pantalla.
Comentarios:
La longitud de 's' tiene que ser múltiplo de 2. Si 's'tiene longitud 0, no se escribirá nada en la pantalla.

Es más rápido escribir varios caracteres en la pantalla con una llamada simple a put_screen_char() que escribir un caracter por vez.

Ejemplo: 
-- escribe AZ en la esquina superior izquierda de la pantalla
-- (los atributos son dependientes de la plataforma)
put_screen_char(1, 1, {'A', 152, 'Z', 131})
Ver también: get_screen_char, display_text_image

puts

Sintaxis: puts(fn, x)
Descripción:
Envía a un archivo o dispositivo 'fn', un byte único (átomo) o una secuencia de bytes. Los 8 bits de orden inferior de cada valor son los realmente enviados. Si 'fn' está en pantalla, verá los caracteres mostrados.
Comentarios:
Cuando envía una secuencia de bytes, ésta no tiene que tener ninguna (sub)secuencia dentro de ella. Tiene que ser únicamente una secuencia de átomos (Típicamente una cadena de códigos ASCII).

Evite enviar 0 a la pantalla o salida estándar. Su salida se puede truncar.

Ejemplo 1: 
puts(SCREEN, "Ingrese su nombre: ")
Ejemplo 2: 
puts(output, 'A')  -- el byte 65 se enviará a output
Ver también: printf, gets, open

rand

Sintaxis: x2 = rand(x1)
Descripción:
Devuelve un entero al azar desde 1 a 'x1', donde 'x1' puede ir desde 1 al valor positivo más grande del tipo entero (1073741823).
Comentarios: Esta función se puede aplicar a un átomo o a todos los elementos de una secuencia.
Ejemplo: 
s = rand({10, 20, 30})
-- s tiene que ser: {5, 17, 23} o {9, 3, 12} etc.
Ver también: set_rand

read_bitmap

Sintaxis: include image.e
x = read_bitmap(st)
Descripción:
'st' es el nombre de un archivo de mapa de bits (.bmp). El archivo debería estar en formato de mapa de bits. Están soportadas la mayoría de las variaciones del formato. Si se lee exitosamente el archivo, el resultado será una secuencia de 2 elementos. El primer elemento es la paleta, conteniendo valores de intensidad en el rango de 0 a 255. El segundo elementos es una secuencia 2D de secuencias que contiene una imagen de gráficos de píxel. Puede pasar la paleta a all_palette() (después de dividirla por 4 para escalarla). La imagen se puede pasar a display_image().

Están soportados los mapas de bits de 2, 4, 16 o 256 colores. Si el archivo no tiene el formato correcto, se devolverá en su lugar un código de error (átomo): 

    global constant BMP_OPEN_FAILED = 1,
                 BMP_UNEXPECTED_EOF = 2,
             BMP_UNSUPPORTED_FORMAT = 3
Comentarios:
Puede crear su propio archivo de imagen de mapa de bits usando el Paintbrush de Windows y algunos otros programas gráficos. También puede incorporar estas imágenes dentro de sus programas Euphoria.
Ejemplo: 
x = read_bitmap("c:\\windows\\arcade.bmp")
-- nota: se necesita la doble barra para obtener 
-- una barra simple en la cadena
Programa de ejemplo: demo\dos32\bitmap.ex
Ver también: palette, all_palette, display_image, save_bitmap

register_block

Sintaxis: include machine.e (or safe.e)
register_block(a, i)
Descripción:
Agrega un bloque de memoria a la lista de bloques seguros mantenida por safe.e (la versión de depuración de machine.e). El bloque comienza en la dirección 'a'. La longitud del bloque es de 'i' bytes.
Comentarios:
Esta rutina solamente tiene sentido para usarla con propósitos de depuración. safe.e rastrea los bloques de memoria en los que a su programa se le permite ejecutar peek(), poke(), mem_copy(), etc. Normalmente, estos son solo los bloques que se asignaron usando las rutinas Euphoria allocate() o allocate_low(), y que no se liberaron usando las rutinas Euphoria free() o free_low(). En algunos casos, puede adquirir bloques de memoria adicionales y externos, quizás como resultado de llamar una rutina de C. Si está depurando su programa usando safe.e, usted debe registrar estos bloques externos de memoria o safe.e evitará que usted los pueda acceder. Use unregister_block() para desregistrar un bloque externo cuando haya terminado de usarlo.

Al incluir machine.e, obtendrá distintas versiones de register_block() y unregister_block() que no hacen nada. Esto permite ir y venir rápidamente entre la ejecución y la depuración de su programa.

Ejemplo 1: 
atom addr

addr = c_func(x, {})
register_block(addr, 5)
poke(addr, "ABCDE")
unregister_block(addr)
Ver también: unregister_block, safe.e

remainder

Sintaxis: x3 = remainder(x1, x2)
Descripción:
Calcula el resto de la división de 'x1' por 'x2'. El resultado tendrá siempre el mismo signo que 'x1' y la magnitud será menor que 'x2'.
Comentarios:
Los argumentos para esta función pueden ser átomos o secuencias. Se aplican las reglas para operaciones sobre secuencias.
Ejemplo 1: 
a = remainder(9, 4)
-- a es 1
Ejemplo 2: 
s = remainder({81, -3.5, -9, 5.5}, {8, -1.7, 2, -4})
-- s es {1, -0.1, -1, 1.5}
Ejemplo 3: 
s = remainder({17, 12, 34}, 16)
-- s es {1, 12, 2}
Ejemplo 4: 
s = remainder(16, {2, 3, 5})
-- s es {0, 1, 1}
Ver también: floor

repeat

Sintaxis: s = repeat(x, a)
Descripción: Crea una secuencia de longitud 'a', donde cada elemento es 'x'.
Comentarios:
Cuando se repite una secuencia o un número de punto flotante, el intérprete realmente no hace múltiples copias en memoria, sino que una sola copia "se apunta a" una cantidad de veces.
Ejemplo 1: 
repeat(0, 10)      -- {0,0,0,0,0,0,0,0,0,0}
Ejemplo 2: 
repeat("JUAN", 4)  -- {"JUAN", "JUAN", "JUAN", "JUAN"}
-- El intérprete creará solamente una copia de "JUAN" en memoria
Ver también: append, prepend, operador de formación de secuencias

reverse

Sintaxis: include misc.e
s2 = reverse(s1)
Descripción: Invierte el orden de los elementos de una secuencia.
Comentarios:
Se crea una nueva secuencia, donde los elementos aparecen en orden inverso, en relación a la secuencia original.
Ejemplo 1: 
reverse({1,3,5,7})          -- {7,5,3,1}
Ejemplo 2: 
reverse({{1,2,3}, {4,5,6}}) -- {{4,5,6}, {1,2,3}}
Ejemplo 3: 
reverse({99})               -- {99}
Ejemplo 4: 
reverse({})                 -- {}
Ver también: append, prepend, repeat

routine_id

Sintaxis: i = routine_id(st)
Descripción:
Devuelve un número de identificación entero, conocido como routine id, para una función o procedimiento Euphoria definido por el usuario. El nombre de la función o procedimiento está dado por la secuencia de cadena 'st'. Si no puede encontrarse la rutina, se devuelve -1.
Comentarios:
El número de identificación puede pasarse a call_proc() o call_func(), para llamar indirectamente a la rutina mencionada por 'st'.

La rutina mencionada por 'st' debe estar visible, es decir llamable, en el lugar donde se usa routine_id() para obtener su número de identificación. Las llamadas indirectas a la rutina pueden aparecer en el programa antes que la definición de la rutina, pero el número de identificación se tiene que obtener después de difinir la rutina. Ver el ejemplo 2 más abajo.

Una vez obtenido un routine id válido, se lo puede usar en cualquier lugar del programa para llamar aindirectamente a una rutina mediante call_proc()/call_func().

Algunos usos típicos de routine_id() son:

1. Llamar a una rutina que está definida más adelante en el programa.
2. Crear una subrutina que toma como parámetro a otra rutina. (Ver el ejemplo 2 más abajo)
3. Usar una secuencia de routine id's para armar una sentencia case (switch).
4. Iniciar un sistema Orientado a Objetos.
5. Obteniendo el routine id, puede pasárselo a call_back(). (Ver platform.doc)

Observe que las rutinas C, llamables por Euphoria, también tienen un routine id. Ver define_c_proc() y define_c_func().

Ejemplo 1: 
procedure foo()
    puts(1, "Hola Mundo\n")
end procedure

integer foo_num
foo_num = routine_id("foo")

call_proc(foo_num, {})  -- es lo mismo que llamar a foo()
Ejemplo 2: 
function apply_to_all(sequence s, integer f)
    -- aplica una función a todos los elementos de una secuencia
    sequence result
    result = {}
    for i = 1 to length(s) do
        -- podemos llamar a add1() aquí, aunque venga después en el programa
        result = append(result, call_func(f, {s[i]}))
    end for
    return result
end function

function add1(atom x)
    return x + 1
end function

-- add1() está visible aquí, por lo que podemos pedir su routine id
? apply_to_all({1, 2, 3}, routine_id("add1"))
-- muestra {2,3,4}
Ver también: call_proc, call_func, call_back, define_c_func, define_c_proc, platform.doc

 

... continua
 
A a B   |   C a D   |   E a G   |   H a O   |   P a R   |   S a T   |   U a Z