| Plataforma: | WIN32 |
| Sintaxis: | include misc.e i = instance() |
| Descripción: | Devuelve un número identificador para el programa actual. |
| Comentarios: | Este valor número identificador se puede pasar
a varias rutinas de Windows para obtener información acerca del
programa que está corriendo. Cada vez que un usuario inicia su
programa, se creará una nueva instancia.
En C, este es el primer parámetro de WinMain(). En DOS32 y Linux/FreeBSD, instance() siempre devuelve 0. |
| Ver también: | platform.doc |
| Sintaxis: | include machine.e s = int_to_bits(a, i) |
| Descripción: | Devuelve los bits 'i' de orden bajo de 'a' como una
secuencia de 1 y 0. Los bits menos significativos vienen primero. Para
los números negativos, se devuelve el patrón en complemento
a 2. |
| Comentarios: | Puede usar subíndices,
subrangos, and/or/xor/not
de secuencias completas, etc. para manipular las secuencias de bits. Las
rotaciones y desplazamientos de bits son fáciles de realizar. |
| Ejemplo: | |
s = int_to_bits(177, 8)
-- s is {1,0,0,0,1,1,0,1} -- orden "inverso"
| |
| Ver también: | bits_to_int, and_bits, or_bits, xor_bits, not_bits, operaciones sobre secuencias |
| Sintaxis: | include machine.e s = int_to_bytes(a) |
| Descripción: | Convierte un entero en una secuencia de 4 bytes.
Esos bytes están en el orden esperado por el 386+, es decir, el
bit menos significativo primero. |
| Comentarios: | Usted puede ser que utilice esta rutina antes de
poner los 4 bytes en la memoria para el uso por un programa de lenguaje
de máquina.
El número entero puede ser negativo. Se devolverán los valores byte negativos, pero después de ponerlos en memoria recién tendrá la representación correcta (complemento a dos) para el 386+. Esta función convertirá correctamente valores enteros de hasta 32 bits. Para valores más grandes, solamente se convierten los 32 bits de orden inferior. El tipo entero de Euphoria permite solamente valores de hasta 31 bits, así que declare sus variables como átomos si necesita una gama más grande. |
| Ejemplo 1: | |
s = int_to_bytes(999)
-- s es {231, 3, 0, 0}
| |
| Ejemplo 2: | |
s = int_to_bytes(-999)
-- s es {-231, -4, -1, -1}
| |
| Ver también: | bytes_to_int, int_to_bits, bits_to_int, peek, poke, poke4 |
| Sintaxis: | i = integer(x) |
| Descripción: | Devuelve 1 si 'x' es un entero dentro del rango
-1073741824 to +1073741823. En cualquier otro caso, devuelve 0. |
| Comentarios: | Esta función sirve para definir el tipo entero.
También puede llamarla como una función ordinaria para determinar
si un objeto es un entero. |
| Ejemplo 1: | |
integer z z = -1 | |
| Ejemplo 2: | |
if integer(y/x) then
puts(SCREEN, "y es un múltiplo exacto de x")
end if
| |
| Ver también: | atom, sequence, floor |
| Sintaxis: | i = length(s) |
| Descripción: | Devuelve la longitud de 's'. 's' tiene que ser una secuencia. Ocurrirá un error si 's' es un átomo. |
| Comentarios: | La longitud de cada secuencia, la almacena internamente
el intérprete para acceso rápido (en otros lenguajes esta
operación requiere de una búsqueda en memoria para hallar
el caracter de terminación). |
| Ejemplo 1: | |
length({{1,2}, {3,4}, {5,6}}) -- 3
| |
| Ejemplo 2: | |
length("") -- 0
| |
| Ejemplo 3: | |
length({}) -- 0
| |
| Ver también: | sequence |
| Sintaxis: | include file.e i1 = lock_file(fn, i2, s) |
| Descripción: | Cuando varios procesos acceden a un archivo simultáneamente,
se puede nucesitar algún tipo de mecanismo de bloqueo para evitar
mutilar el contenido del archivo, o causar datos erróneos en la
lectura.
lock_file() intenta poner un bloqueo en un archivo abierto 'fn' para detener a otros procesos de usar el archivo mientras su programa lo está escribiendo o leyendo. Bajo Linux/FreeBSD, hay dos tipos de bloqueos que se pueden solicitar usando el parámetro 'i2' (bajo DOS32 y WIN32 el parámetro 'i2' se ignora, pero debería ser un entero). Solicite un bloqueo compartido cuando quiera leer un archivo y desee bloquearlo temporalmente para otros procesos que lo lean. Solicite un bloqueo exclusivo cuando quiera escribir en el archivo y desee bloquearlo temporalmente para otros procesos que lo lean o escriban en él. Muchos procesos pueden tener bloqueos compartidos aplicados simultáneamente sobre el mismo archivo, pero solamente un proceso puede tener bloqueo exclusivo, el cual solamente puede aplicarse cuando ningún otro procesos haya aplicado ningún bloqueo de cualquier clase sobre el archivo. file.e contiene la siguiente declaración: |
global constant LOCK_SHARED = 1,
LOCK_EXCLUSIVE = 2
| |
En DOS32
y WIN32 puede bloquear una
porción específica de un archivo usando el parámetro
's'. 's' es una secuencia de la forma: {primer byte, último byte}.
En ella se indican el primer y último byte de la porción
del archivo sobre la que se aplica el bloqueo. Especifique la secuencia
vacía {}, si quiere bloquear el archivo completo. En la versión
actual para Linux/FreeBSD,
los bloqueos siempre se aplican sobre el archivo completo y debería
especificar {} para este parámetro.
lock_file() devolverá 1, si se pudo obtener el bloqueo deseado; en caso contrario, se devolverá 0. lock_file() no espera otros procesos para abandonar sus bloqueos. Puede tener que llamarlo en varias ocasiones, antes que se conceda la petición del bloqueo. | |
| Comentarios: | En Linux/FreeBSD,
estos bloqueos se llaman bloqueos consultivos, lo que significa que no
son forzados por el sistema operativo. Esto es, los procesos que
utilizan un archivo particular cooperan uno con otro. Un proceso puede acceder
a un archivo sin primero bloquearlo. En WIN32
y DOS32, los bloqueos son
forzados por el sistema operativo. |
En DOS32,
lock_file() es más
útil cuando está habilitada la compartición de archivos.
Típicamente devuelve 0 (falla) bajo MS-DOS
plano, fuera de Windows.
|
|
| Ejemplo: | |
include misc.e
include file.e
integer v
atom t
v = open("visitor_log", "a") -- abre para agregar
t = time()
while not lock_file(v, LOCK_EXCLUSIVE, {}) do
if time() > t + 60 then
puts(1, "Un minuto ya... No puedo esperar por siempre!\n")
abort(1)
end if
sleep(5) -- permite correr a los demás procesos
end while
puts(v, "Otro visitante\n")
unlock_file(v, {})
close(v)
| |
| Ver también: | unlock_file, flush, sleep |
| Plataforma: | DOS32 |
| Sintaxis: | include machine.e lock_memory(a, i) |
| Descripción: | Evita el bloque de la memoria virtual que comienza
en la dirección 'a', de longitud 'i', siempre sea intercambiada
al disco. |
| Comentarios: | lock_memory() se debería usar solo en situaciones altamente especializadas, donde tenga que iniciar sus propios manejadores de interrupciones por hardware de DOS, usando código de máquina. Cuando ocurre una interrupción de hardware, no le es posible al sistema operativo devolver ningún código o dato que se haya intercambiado, por lo tanto, usted necesita proteger cualquier bloque de código de máquina o datos que necesite en el servicio de la interrupción. |
| Programa ejemplo: | demo\dos32\hardint.ex |
| Ver también: | get_vector, set_vector |
| Sintaxis: | x2 = log(x1) |
| Descripción: | Devuelve el logaritmo natural de 'x1'. |
| Comentarios: | Esta función se puede aplicar a un átomo
o a todos los elementos de una secuencia. Tenga presente que log está
definida solamente para números positivos. Si intenta tomar el
logaritmo de un número negativo o de cero, su programa se abortará
con un mensaje de error. |
| Ejemplo: | |
a = log(100) -- a es 4.60517 | |
| Ver también: | sin, cos, tan, sqrt |
| Sintaxis: | include wildcard.e x2 = lower(x1) |
| Descripción: | Convierte un átomo o secuencia a minúsculas. |
| Ejemplo: | |
s = lower("Euphoria")
-- s es "euphoria"
a = lower('B')
-- a es 'b'
s = lower({"Euphoria", "Programming"})
-- s es {"euphoria", "programming"}
| |
| Ver también: | upper |
| Sintaxis: | x1 = machine_func(a, x) |
| Descripción: | Ver machine_proc() debajo. |
| Sintaxis: | machine_proc(a, x) |
| Descripción: | Ejecuta una operación específica de
máquina, tal como un gráfico o efectos sonoros. Esta rutina
normalmente se debería llamar indirectamentea través de
las rutinas de librería de los archivos de inclusión de
Euphoria. Una llamada directa, hecha incorrectamente, provocaría
una excepción de la máquina. |
| Ver también: | machine_func |
| Sintaxis: | i = match(s1, s2) |
| Descripción: | Busca la coincidencia de 's1' contra un cierto subrango
de 's2'. Si resulta exitoso, devuelve el número de elemento de
's2' donde comienza (la primera) coincidencia del subrango, sino devuelve
0. |
| Ejemplo: | |
posicion = match("pho", "Euphoria")
-- posicion se establece a 3
| |
| Ver también: | find, compare, wildcard_match |
| Sintaxis: | mem_copy(a1, a2, i) |
| Descripción: | Copia un bloque de 'i' bytes de memoria desde la dirección 'a2' a la dirección 'a1'. |
| Comentarios: | Los byes de memoria se copiarán correctamente,
aún cuando el bloque en 'a2' se solape sobre el que comienza en
'a1'.
mem_copy(a1, a2, i) es equivalente a: poke(a1, peek({a2, i})), pero mucho más rápida. |
| Ejemplo: | |
dest = allocate(50)
src = allocate(100)
poke(src, {1,2,3,4,5,6,7,8,9})
mem_copy(dest, src, 9)
| |
| Ver también: | mem_set, peek, poke, allocate, allocate_low |
| Sintaxis: | mem_set(a1, i1, i2) |
| Descripción: | Establece 'i2' byte de memoria, comenzando en la dirección 'a1' al valor de 'i1'. |
| Comentarios: | Los 8 bits de orden inferior de 'i1' se almacenan realmente en cada byte.
mem_set(a1, i1, i2) es equivalente a: poke(a1, repeat(i1, i2)), pero mucho más rápida. |
| Ejemplo: | |
destination = allocate(1000) mem_set(destination, ' ', 1000) -- 1000 bytes consecutivos en memoria se establecerán a 32 -- (el código ASCII de ' ') | |
| Ver también: | mem_copy, peek, poke, allocate, allocate_low |
| Plataforma: | WIN32 |
| Sintaxis: | include msgbox.e i = message_box(s1, s2, x) |
| Descripción: | Muestra una ventana con título 's2', conteniendo
la cadena de mensaje 's1'. 'x' determina la combinación de botones
que estarán disponibles para que el usuario presione, y algunas
otras características. 'x' puede ser un átomo p una secuencia.
El valor de retorno 0, indica la falla en la inicialización de
la ventana. |
| Comentarios: | Ver la lista completa de valores posibles para 'x' e 'i' en msgbox.e . |
| Ejemplo: | |
response = message_box("¿Desea continuar?",
"Mi Programa",
MB_YESNOCANCEL)
if response = IDCANCEL or response = IDNO then
abort(1)
end if
| |
| Programa ejemplo: | demo\win32\email.exw |
| Plataforma: | DOS32, Linux |
| Sintaxis: | include mouse.e mouse_events(i) |
| Descripción: | Use este procedimiento para seleccionar los eventos
del ratón que desea que get_mouse()
informe. Por defecto, get_mouse()
informará todos los eventos. mouse_events()
se puede llamar en varios lugares de la ejecución del programa,
allí donde se necesite detectar los cambios en los eventos. Bajo
Linux, mouse_events()
actualmente no tiene efecto. |
| Comentarios: | Es una buena práctica ignorar los eventos
en los que no está interesado, particularmente el muy frecuente
evento MOVE, para reducir la ocasión quese perderá de un
evento significativo.
La primera llamada que hace a mouse_events() activará el puntero del ratón, o un caracter resaltado. |
| Ejemplo: | |
mouse_events(LEFT_DOWN + LEFT_UP + RIGHT_DOWN) -- restringirá get_mouse() a informar cuando el botón izquierdo -- sea presionado y liberado, y el botón derecho -- sea presionado. El resto de los eventos se ignorarán. | |
| Ver también: | get_mouse, mouse_pointer |
| Plataforma: | DOS32, Linux |
| Sintaxis: | include mouse.e mouse_pointer(i) |
| Descripción: | Si 'i' vale 0, se oculta el puntero del ratón,
en caso contrario se activará. Varias llamadas para ocultar el
puntero, necesitarán de varias llamadas para activarlo nuevamente.
La primera llamada tanto a get_mouse()
o a mouse_events(), también
activará el puntero (una vez). Bajo Linux,
mouse_pointer() actualmente
no tiene efecto. |
| Comentarios: | Puede ser necesario ocultar el puntero del ratón
en forma temporal, mientras actualiza la pantalla.
Después de llamar a text_rows() puede tener que llamar a mouse_pointer(1) para ver nuevamente el puntero del ratón. |
| Ver también: | get_mouse, mouse_events |
| Sintaxis: | x2 = not_bits(x1) |
| Descripción: | Ejecuta la operación lógica NOT a cada
bit de 'x1'. Un bit en 'x2' será 1 si el correspondiente en 'x1'
es 0 y viceversa. |
| Comentarios: | Los argumentos para la función pueden ser
átomos o secuencias. Se aplican las reglas para operaciones
sobre secuencias.
Los argumentos tienen que ser representables como números de 32 bits, sean con o sin signo. Si se prepone manipular valores 32-bit 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. |
| Ejemplo: | |
a = not_bits(#000000F7) -- a es -248 (es decir, FFFFFF08 interpretado como número negativo) | |
| Ver también: | and_bits, or_bits, xor_bits, int_to_bits |
| Sintaxis: | i = object(x) |
| Descripción: | Prueba si 'x' es de tipo objeto. Siempre será
verdadero, por lo que object()
siempre devolverá 1. |
| Comentarios: | Todos los tipos predefinidos
como los definidos por el usuario también
se pueden usar como funciones para probar si un valor pertenece a ese
tipo. object() se incluye
solo para completar. Siempre devuelve 1. |
| Ejemplo: | |
? object({1,2,3}) -- siempre imprime 1
| |
| Ver también: | integer, atom, sequence |
| Sintaxis: | fn = open(st1, st2) |
| Descripción: | Abre un archivo o dispositivo, para obtener el número
de archivo. Devuelve -1 si la operación falla. 'st1' es la ruta
del archivo o dispositivo. 'st2' es el modo en que se abre el archivo.
Los modos posibles son:
"r" - abre un archivo de texto para lectura Los archivos que se abren para leer o actualizar, tienen que existir. Los archivos que se abren para escribir o agregar, serán creados si es necesario. Un archivo abierto para escritura tendrá 0 bytes. La salida a un archivo abierto para agregar, comenzará en el final del archivo. La salida a archivos de texto tendrá caracteres de retrono de carro, agregados automáticamente antes de los caracteres de avance de línea. En la entrada, se quitarán estos caracteres de retorno de carro. El caracter Ctrl+Z (ASCII 26) indicará el fin del archivo. La E/S a archivos binarios no se modifica en forma alguna. Se puede leer o escribir cualquier valor de byte de 0 a 255. Algunos dispositivos típicos que puede abrir son: "CON" - consola (pantalla) |
| Comentarios: | DOS32: Al correr
bajo Windows 95 o posterior, puede abrir cualquier archivo existente que
tenga un nombre largo de archivo o directorio en su ruta (es decir, más
grande que el estándar 8.3 del DOS) usando cualquier modo de apertura
- leer, escribir, etc. Sin embargo, si intenta crear un archivo nuevo
(open con "w" o "a" y el archivo no existe aún) entonces se truncará
el nombre al estilo 8.3. En una futura versión, esperamos soportar
la creación de archivos con nombres largos.
WIN32, Linux and FreeBSD: Se soportan completamente los nombres largos en lectura, escritura y creación de archivos. |
| Ejemplo: | |
integer file_num, file_num95
sequence first_line
constant ERROR = 2
file_num = open("miarchivo", "r")
if file_num = -1 then
puts(ERROR, "No se puede abrir miarchivo\n")
else
first_line = gets(file_num)
end if
file_num = open("PRN", "w") -- abre la impresora para salida
-- en Windows 95:
file_num95 = open("nombreDeDirectorio\\nombreDeArchivo.abcdefg", "r")
if file_num95 != -1 then
puts(1, "funcionó!\n")
end if
| |
| Ver también: | close |
| Plataforma: | WIN32, Linux, FreeBSD |
| Sintaxis: | include dll.e a = open_dll(st) |
| Descripción: | Abre un archivo de librería de enlace dinámico
de Windows (.dll),
o un archivo de librería compartida de Linux
o FreeBSD. Se devolverá
una dirección de 32 bits, o 0 si no se puede encontrar el archivo.
'st' puede ser una ruta relativa o absoluta. Windows
usará la ruta normal para ubicar los archivos .dll. |
| Comentarios: | El valor devuelto por open_dll()
se puede pasar a define_c_proc(),
define_c_func(), o define_c_var().
Se puede abrir varias veces el mismo archivo .dll o .so. No se usa memoria extra y cada vez se devolverá el mismo número. Euphoria cerrará la .dll automáticamente al final de la ejecución. |
| Ejemplo: | |
atom user32
user32 = open_dll("user32.dll")
if user32 = 0 then
puts(1, "No se puede abrir user32.dll!\n")
end if
| |
| Ver también: | define_c_func, define_c_proc, define_c_var, c_func, c_proc, platform.doc |
| Sintaxis: | x3 = or_bits(x1, x2) |
| Descripción: | Ejecuta la operación lógica OR sobre
los bits correspondientes de 'x1' y 'x2'. Un bit en 'x3' valdrá
1 cuando el bit correspondiente tanto de 'x1' o 'x2' valga 1. |
| Comentarios: | Los argumentos para la función pueden ser
átomos o secuencias. Se aplican las reglas para operaciones
sobre secuencias.
Los argumentos tienen que ser representables como números de 32 bits, sean con o sin signo. Si se prepone manipular valores 32-bit 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. |
| Ejemplo 1: | |
a = or_bits(#0F0F0000, #12345678) -- a es #1F3F5678 | |
| Ejemplo 2: | |
a = or_bits(#FF, {#123456, #876543, #2211})
-- a es {#1234FF, #8765FF, #22FF}
| |
| Ver también: | and_bits, xor_bits, not_bits, int_to_bits |