Página 1

Manual de referencia de Lua 5.4

de Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes
Copyright © 2020 Lua.org, PUC-Rio. Libremente disponible bajo los términos delLicencia Lua .
contenidos · índice · otras versiones

1. Introducción
Lua es un lenguaje de scripting potente, eficiente, ligero e integrable. Es compatible con la programación de
procedimientos,
programación orientada a objetos, programación funcional, programación impulsada por datos y descripción de datos.
Lua combina una sintaxis de procedimiento simple con poderosas construcciones de descripción de datos basadas en
matrices asociativas
y semántica extensible. Lua se escribe dinámicamente, se ejecuta interpretando el código de bytes con un virtual
basado en registros.
máquina, y tiene administración automática de memoria con una recolección de basura generacional, lo que la hace
ideal para
configuración, secuencias de comandos y creación rápida de prototipos.
Lua se implementa como una biblioteca, escrita en C limpio , el subconjunto común de Standard C y C ++. El lua
La distribución incluye un programa anfitrión llamado lua, que usa la biblioteca Lua para ofrecer un Lua completo e
independiente.
intérprete, para uso interactivo o por lotes. Lua está diseñado para ser utilizado como un potente, ligero e integrable
lenguaje de secuencias de comandos para cualquier programa que lo necesite, y como un potente, ligero y eficiente
idioma.
Como lenguaje de extensión, Lua no tiene la noción de un programa "principal": funciona integrado en un cliente
host, llamado
programa de incrustación o simplemente el anfitrión . (Con frecuencia, este host es el programa lua independiente).
puede invocar funciones para ejecutar un fragmento de código Lua, puede escribir y leer variables Lua y puede
registrar
Funciones C para ser llamadas por código Lua. Mediante el uso de funciones C, Lua se puede aumentar para hacer
frente a una amplia
variedad de dominios diferentes, creando así lenguajes de programación personalizados que comparten un marco
sintáctico.
Lua es un software gratuito y se proporciona como de costumbre sin garantías, como se indica en su licencia. La
implementación
descrito en este manual está disponible en el sitio web oficial de Lua, www.lua.org.
Como cualquier otro manual de referencia, este documento está seco en algunos lugares. Para una discusión de las
decisiones detrás del
diseño de Lua, consulte los documentos técnicos disponibles en el sitio web de Lua. Para obtener una introducción
detallada a la programación en
Lua, vea el libro de Roberto, Programación en Lua .

2 - Conceptos básicos
Esta sección describe los conceptos básicos del idioma.
2.1 - Valores y tipos
Lua es un lenguaje escrito dinámicamente. Esto significa que las variables no tienen tipos; sólo los valores lo hacen.
No existen
escriba definiciones en el idioma. Todos los valores tienen su propio tipo.
Todos los valores en Lua son valores de primera clase. Esto significa que todos los valores se pueden almacenar en
variables, pasados como
argumentos a otras funciones y se devuelven como resultados.
Hay ocho tipos básicos en Lua: nil , boolean , number , string , function , userdata , thread y table . El tipo nulo
tiene un valor único, nil , cuya propiedad principal es ser diferente de cualquier otro valor; a menudo representa el
ausencia de un valor útil. El tipo booleano tiene dos valores, falso y verdadero . Tanto cero como falso hacen una
condición
falso; colectivamente se denominan valores falsos . Cualquier otro valor hace que una condición sea verdadera.
El número de tipo representa tanto números enteros como números reales (de punto flotante), utilizando dos subtipos:
entero

Página 2
y flotar . Lua estándar utiliza enteros de 64 bits y flotantes de doble precisión (64 bits), pero también puede compilar
Lua para
que utiliza enteros de 32 bits y / o flotantes de precisión simple (32 bits). La opción con 32 bits para enteros y
Los flotadores son especialmente atractivos para máquinas pequeñas y sistemas empotrados. (Ver macro
LUA_32BITS en archivo
luaconf.h.)
A menos que se indique lo contrario, cualquier desbordamiento al manipular valores enteros se envuelve , de acuerdo
con el habitual
reglas de la aritmética de dos complementos. (En otras palabras, el resultado real es el único entero representable que
es
igual módulo 2 n al resultado matemático, donde n es el número de bits del tipo entero).
Lua tiene reglas explícitas sobre cuándo se usa cada subtipo, pero también convierte entre ellos automáticamente
como
necesario (ver §3.4.3 ). Por lo tanto, el programador puede optar por ignorar principalmente la diferencia entre
números enteros
y flota o para asumir el control total sobre la representación de cada número.
El tipo de cadena representa secuencias inmutables de bytes. Lua es limpio de 8 bits: las cadenas pueden contener
cualquier valor de 8 bits,
incluyendo ceros incrustados ('\ 0'). Lua también es independiente de la codificación; no hace suposiciones sobre el
contenido de un
cuerda. La longitud de cualquier cadena en Lua debe caber en un entero Lua.
Lua puede llamar (y manipular) funciones escritas en Lua y funciones escritas en C (ver §3.4.10 ). Ambos son
representado por la función de tipo .
El tipo userdata se proporciona para permitir que se almacenen datos C arbitrarios en variables Lua. Un valor de
datos de usuario representa
un bloque de memoria bruta. Hay dos tipos de datos de usuario: datos de usuario completos , que son un objeto con
un bloque de memoria.
administrado por Lua, y datos de usuario ligeros , que es simplemente un valor de puntero C. Userdata no tiene
operaciones predefinidas en
Lua, excepto asignación y prueba de identidad. Al usar metatablas , el programador puede definir operaciones para
valores de datos de usuario (ver §2.4 ). Los valores de datos de usuario no se pueden crear ni modificar en Lua, solo a
través de la API de C. Esta
garantiza la integridad de los datos que pertenecen al programa anfitrión y las bibliotecas C.
El tipo hilo representa hilos de ejecución independientes y se utiliza para implementar corrutinas (ver §2.6 ).
Los hilos de Lua no están relacionados con los hilos del sistema operativo. Lua admite corrutinas en todos los
sistemas, incluso en aquellos que
no admiten subprocesos de forma nativa.
La tabla de tipos implementa matrices asociativas, es decir, matrices que pueden tener como índices no solo números,
sino cualquier
Valor Lua excepto nil y NaN. ( Not a Number es un valor especial de punto flotante utilizado por el estándar IEEE
754 para
representan resultados numéricos indefinidos, como 0/0.) Las tablas pueden ser heterogéneas ; es decir, pueden
contener
valores de todos los tipos (excepto nulo ). Cualquier clave asociada al valor nulo no se considera parte de la tabla. En
cambio,
cualquier clave que no forme parte de una tabla tiene un valor asociado nulo .
Las tablas son el único mecanismo de estructuración de datos en Lua; se pueden utilizar para representar matrices,
listas,
tablas de símbolos, conjuntos, registros, gráficos, árboles, etc. Para representar registros, Lua usa el nombre del
campo como índice. los
language apoya esta representación proporcionando a.name como azúcar sintáctico para un ["nombre"]. Hay varios
formas convenientes de crear tablas en Lua (ver §3.4.9).
Al igual que los índices, los valores de los campos de la tabla pueden ser de cualquier tipo. En particular, debido a
que las funciones son valores de primera clase,
los campos de la tabla pueden contener funciones. Por tanto, las tablas también pueden contener métodos
(ver§3.4.11 ).
La indexación de tablas sigue la definición de igualdad bruta en el idioma. Las expresiones a [i] y a [j]
denotar el mismo elemento de tabla si y solo si i y j son iguales en bruto (es decir, iguales sin metamétodos). En
en particular, los flotantes con valores integrales son iguales a sus respectivos números enteros (por ejemplo, 1.0 ==
1). Para evitar ambigüedades,
cualquier flotante utilizado como clave que sea igual a un número entero se convierte en ese número entero. Por
ejemplo, si escribe un [2.0] =
cierto, la clave real insertada en la tabla será el entero 2.
Las tablas, funciones, subprocesos y valores de datos de usuario (completos) son objetos : las variables en realidad no
contienen estos valores,
sólo referencias a ellos. La asignación, el paso de parámetros y los retornos de función siempre manipulan referencias
a
tales valores; estas operaciones no implican ningún tipo de copia.
La función de biblioteca type devuelve una cadena que describe el tipo de un valor dado (ver tipo ).
2.2 - Medio ambiente y medio ambiente global
Como veremos más adelante en §3.2 y§3.3.3 , cualquier referencia a un nombre libre (es decir, un nombre no
vinculado a ningún
declaración) var se traduce sintácticamente a _ENV.var. Además, cada fragmento se compila en el alcance de un
variable local externa llamada _ENV (ver §3.3.2 ), por lo que _ENV en sí mismo nunca es un nombre libre en un
fragmento.
A pesar de la existencia de esta variable externa _ENV y de la traducción de nombres libres, _ENV es una
nombre regular. En particular, puede definir nuevas variables y parámetros con ese nombre. Cada referencia a un
free name usa el _ENV que es visible en ese punto del programa, siguiendo las reglas de visibilidad habituales de Lua
(ver

Página 3
§3.5 ).
Cualquier tabla utilizada como valor de _ENV se denomina entorno .
Lua mantiene un entorno distinguido llamado entorno global . Este valor se mantiene en un índice especial en el
Registro C (ver §4.3 ). En Lua, la variable global _G se inicializa con este mismo valor. ( _G nunca se usa
internamente,
por lo que cambiar su valor afectará solo a su propio código).
Cuando Lua carga un fragmento, el valor predeterminado para su variable _ENV es el entorno global (consulte
carga ). Por lo tanto,
de forma predeterminada, los nombres libres en el código Lua se refieren a entradas en el entorno global y, por lo
tanto, también se denominan
variables globales . Además, todas las bibliotecas estándar se cargan en el entorno global y algunas funciones allí
operar en ese entorno. Puede usar load (oloadfile ) para cargar un fragmento con un entorno diferente. (En
C, tienes que cargar el fragmento y luego cambiar el valor de su primer upvalue; verlua_setupvalue .)
2.3 - Manejo de errores
Varias operaciones en Lua pueden generar un error. Un error interrumpe el flujo normal del programa, lo que puede
continúe detectando el error.
El código Lua puede generar explícitamente un error llamando a la función de error . (Esta función nunca regresa).
Para detectar errores en Lua, puede hacer una llamada protegida , usandopcall (oxpcall ). La funciónpcall llama a un
dado
funciona en modo protegido . Cualquier error mientras se ejecuta la función detiene su ejecución y el control regresa
inmediatamente a pcall, que devuelve un código de estado.
Debido a que Lua es un lenguaje de extensión integrado, el código Lua comienza a ejecutarse mediante una llamada
desde el código C en el host
programa. (Cuando usa Lua de forma independiente, la aplicación lua es el programa anfitrión). Por lo general, esta
llamada está protegida;
por lo tanto, cuando ocurre un error sin protección durante la compilación o ejecución de un fragmento de Lua, el
control
vuelve al host, que puede tomar las medidas adecuadas, como imprimir un mensaje de error.
Siempre que hay un error, se propaga un objeto de error con información sobre el error. Lua solo
genera errores cuyo objeto de error es una cadena, pero los programas pueden generar errores con cualquier valor
como error
objeto. Depende del programa Lua o de su anfitrión manejar tales objetos de error. Por razones históricas, un objeto
de error es
a menudo se denomina mensaje de error , aunque no tiene que ser una cadena.
Cuando usas xpcall (olua_pcall , en C) puede dar un manejador de mensajes para que sea llamado en caso de errores.
Esta
La función se llama con el objeto de error original y devuelve un nuevo objeto de error. Se llama antes de que se
desenvuelva el error.
la pila, para que pueda recopilar más información sobre el error, por ejemplo, inspeccionando la pila y creando
un seguimiento de pila. Este gestor de mensajes todavía está protegido por la llamada protegida; entonces, un error
dentro del mensaje
handler volverá a llamar al gestor de mensajes. Si este bucle se prolonga demasiado, Lua lo rompe y devuelve un
mensaje apropiado. El controlador de mensajes se llama solo para errores de tiempo de ejecución regulares. No se
llama para la memoria.
errores de asignación ni errores al ejecutar finalizadores u otros controladores de mensajes.
Lua también ofrece un sistema de advertencias (veradvertir ). A diferencia de los errores, las advertencias no
interfieren de ninguna manera con el programa.
ejecución. Por lo general, solo generan un mensaje para el usuario, aunque este comportamiento se puede adaptar
desde C (ver
lua_setwarnf).
2.4 - Metatables y metamétodos
Cada valor en Lua puede tener una metatabla . Esta metatabla es una tabla Lua ordinaria que define el
comportamiento del
valor original bajo ciertos eventos. Puede cambiar varios aspectos del comportamiento de un valor estableciendo
campos en su metatabla. Por ejemplo, cuando un valor no numérico es el operando de una suma, Lua busca una
función en el campo "__add" de la metatabla del valor. Si encuentra uno, Lua llama a esta función para realizar la
suma.
La clave para cada evento en una metatabla es una cadena con el nombre del evento precedido por dos guiones bajos;
la
el valor correspondiente se llama metavalor . Para la mayoría de los eventos, el metavalor debe ser una función, que
luego es
llamado metamétodo . En el ejemplo anterior, la clave es la cadena "__add" y el metamétodo es la función
que realiza la suma. A menos que se indique lo contrario, un metamétodo puede ser de hecho cualquier valor
invocable, que es
ya sea una función o un valor con un metamétodo __call.
Puede consultar la metatabla de cualquier valor utilizando la función getmetatable . Lua consulta metamétodos en
metatablas usando un acceso sin formato (ver rawget ).
Puede reemplazar la metatabla de tablas usando la función setmetatable . No puedes cambiar la metatabla de
otros tipos del código Lua, excepto mediante el uso de la biblioteca de depuración (§6.10 ).

Página 4
Las tablas y los datos de usuario completos tienen metatablas individuales, aunque varias tablas y datos de usuario
pueden compartir sus
metatablas. Los valores de todos los demás tipos comparten una única metatabla por tipo; es decir, hay una única
metatabla para
todos los números, uno para todas las cadenas, etc. De forma predeterminada, un valor no tiene metatabla, pero la
biblioteca de cadenas establece una metatabla para
el tipo de cadena (ver §6.4 ).
A continuación se proporciona una lista detallada de las operaciones controladas por metatablas. Cada evento se
identifica por su correspondiente
llave. Por convención, todas las claves de metatabla utilizadas por Lua están compuestas por dos guiones bajos
seguidos de minúsculas
Letras latinas.
__add: la operación de suma (+). Si algún operando de una suma no es un número, Lua intentará llamar a un
metamétodo. Comienza verificando el primer operando (incluso si es un número); si ese operando no define un
metamétodo para __add, entonces Lua comprobará el segundo operando. Si Lua puede encontrar un metamétodo,
llama al
metamétodo con los dos operandos como argumentos, y el resultado de la llamada (ajustado a un valor) es el
resultado de la operación. De lo contrario, si no se encuentra ningún metamétodo, Lua genera un error.
__sub: la operación de resta (-). Comportamiento similar al de la operación de suma.
__mul: la operación de multiplicación (*). Comportamiento similar al de la operación de suma.
__div: la operación de división (/). Comportamiento similar al de la operación de suma.
__mod: la operación módulo (%). Comportamiento similar al de la operación de suma.
__pow: la operación de exponenciación (^). Comportamiento similar al de la operación de suma.
__unm: la operación de negación (unaria -). Comportamiento similar al de la operación de suma.
__idiv: la operación de división de piso (//). Comportamiento similar al de la operación de suma.
__band: la operación AND (&) bit a bit. Comportamiento similar a la operación de suma, excepto que Lua intentará
un
metamétodo si algún operando no es un número entero ni un flotante coercible a un entero (ver §3.4.3 ).
__bor: la operación OR (|) bit a bit. Comportamiento similar al de la operación AND bit a bit.
__bxor: la operación OR (binaria ~) exclusiva bit a bit. Comportamiento similar al de la operación AND bit a bit.
__bnot: la operación NOT (unaria ~) bit a bit. Comportamiento similar al de la operación AND bit a bit.
__shl: la operación de desplazamiento a la izquierda (<<) bit a bit. Comportamiento similar al de la operación AND
bit a bit.
__shr: la operación de desplazamiento a la derecha (>>) bit a bit. Comportamiento similar al de la operación AND
bit a bit.
__concat: la operación de concatenación (..). Comportamiento similar al de la operación de suma, excepto que Lua
pruebe un metamétodo si algún operando no es ni una cadena ni un número (que siempre es coercible a una cadena).
__len: la operación de longitud (#). Si el objeto no es una cadena, Lua probará su metamétodo. Si hay un
metamétodo, Lua lo llama con el objeto como argumento y el resultado de la llamada (siempre ajustado a uno
value) es el resultado de la operación. Si no hay metamétodo pero el objeto es una tabla, entonces Lua usa el
operación de longitud de mesa (ver §3.4.7 ). De lo contrario, Lua genera un error.
__eq: la operación de igualdad (==). Comportamiento similar a la operación de suma, excepto que Lua intentará un
metamétodo solo cuando los valores que se comparan son ambas tablas o ambos datos de usuario completos y son
no primitivamente iguales. El resultado de la llamada siempre se convierte en booleano.
__lt: la operación menor que (<). Comportamiento similar a la operación de suma, excepto que Lua intentará un
metamétodo solo cuando los valores que se comparan no son ni números ni cadenas. Es más,
el resultado de la llamada siempre se convierte en booleano.
__le: la operación menos igual (<=). Comportamiento similar al de la operación menor que.
__index: la tabla de operaciones de acceso de indexación [clave]. Este evento ocurre cuando la mesa no es una mesa
o
cuando la clave no está presente en la tabla. El metavalor se busca en la metatabla de la tabla.
El metavalor de este evento puede ser una función, una tabla o cualquier valor con un metavalor __index. Si se
es una función, se llama con tabla y clave como argumentos, y el resultado de la llamada (ajustado a un valor)
es el resultado de la operación. De lo contrario, el resultado final es el resultado de indexar este metavalor con key.
Esta indexación es regular, no sin formato y, por lo tanto, puede activar otro metavalor __index.
__newindex: la tabla de asignación de indexación [clave] = valor. Al igual que el evento de índice, este evento
ocurre
cuando la tabla no es una tabla o cuando la clave no está presente en la tabla. El metavalor se busca en el
metatabla de mesa.
Al igual que con la indexación, el metavalor de este evento puede ser una función, una tabla o cualquier valor con un
__newindex metavalor. Si es una función, se llama con la tabla, la clave y el valor como argumentos.
De lo contrario, Lua repite la asignación de indexación sobre este metavalor con la misma clave y valor. Esta
La asignación es regular, no cruda y, por lo tanto, puede activar otro metavalor __newindex.
Siempre que se invoca un metavalor __newindex, Lua no realiza la asignación primitiva. Si es necesario,
el metamétodo en sí mismo puede llamar rawset para hacer la tarea.
__call: La operación de llamada func (args). Este evento ocurre cuando Lua intenta llamar a un valor no funcional.
(es decir, func no es una función). El metamétodo se busca en func. Si está presente, el metamétodo se llama
con func como primer argumento, seguido de los argumentos de la llamada original (args). Todos los resultados de la
llamada
son los resultados de la operación. Este es el único metamétodo que permite múltiples resultados.

Página 5
Además de la lista anterior, el intérprete también respeta las siguientes claves en las metatablas: __gc (ver §2.5.3 ),
__close (ver §3.3.8 ), __mode (ver§2.5.4 ) y __nombre. (La entrada __name, cuando contiene una cadena, puede ser
usado por tostring y en mensajes de error.)
Para los operadores unarios (negación, longitud y NOT bit a bit), el metamétodo se calcula y se llama con un
segundo operando ficticio, igual al primero. Este operando adicional es solo para simplificar los aspectos internos de
Lua (al hacer
estos operadores se comportan como una operación binaria) y pueden eliminarse en versiones futuras. Para la
mayoría de los usos, este extra
operando es irrelevante.
Debido a que las metatablas son tablas regulares, pueden contener campos arbitrarios, no solo los nombres de eventos
definidos anteriormente.
Algunas funciones en la biblioteca estándar (por ejemplo, tostring ) usan otros campos en metatablas para sus propios
propósitos.
Es una buena práctica agregar todos los metamétodos necesarios a una tabla antes de configurarla como metatabla de
algún objeto. En
en particular, el metamétodo __gc funciona solo cuando se sigue este orden (ver §2.5.3 ). También es una buena
práctica
establecer la metatabla de un objeto justo después de su creación.
2.5 - Recolección de basura
Lua realiza la gestión automática de la memoria. Esto significa que no tiene que preocuparse por asignar
memoria para nuevos objetos o liberarla cuando los objetos ya no sean necesarios. Lua gestiona la memoria
automáticamente
ejecutando un recolector de basura para recoger todos los objetos muertos . Toda la memoria utilizada por Lua está
sujeta a
gestión: cadenas, tablas, datos de usuario, funciones, hilos, estructuras internas, etc.
Un objeto se considera muerto tan pronto como el recolector pueda estar seguro de que no se volverá a acceder al
objeto en el
ejecución normal del programa. ("Ejecución normal" aquí excluye a los finalizadores, que pueden resucitar objetos
muertos
(ver §2.5.3 ), y también excluye las operaciones que utilizan la biblioteca de depuración.) Tenga en cuenta que el
momento en que el recopilador puede
asegurarse de que un objeto está muerto puede no coincidir con las expectativas del programador. Las únicas
garantías son que
Lua no recopilará un objeto al que aún se pueda acceder en la ejecución normal del programa, y lo hará
eventualmente recolectar un objeto que es inaccesible de Lua. (Aquí, inaccesible desde Lua significa que ni un
variable ni otro objeto en vivo se refieren al objeto.) Debido a que Lua no tiene conocimiento sobre el código C,
nunca recopila
objetos accesibles a través del registro (ver §4.3 ), que incluye el entorno global (ver§2.2 ).
El recolector de basura (GC) en Lua puede funcionar en dos modos: incremental y generacional.
El modo GC predeterminado con los parámetros predeterminados es adecuado para la mayoría de los usos. Sin
embargo, los programas que desperdician un
gran parte de su tiempo para asignar y liberar memoria puede beneficiarse de otras configuraciones. Tenga en cuenta
que el
El comportamiento de GC no es portátil tanto en plataformas como en diferentes versiones de Lua; por lo tanto,
ajustes óptimos
tampoco son portátiles.
Puede cambiar el modo y los parámetros de GC llamando a lua_gc en C o a collectgarbage en Lua. Tú también
puedes
utilice estas funciones para controlar el colector directamente (por ejemplo, para detenerlo y reiniciarlo).
2.5.1 - Recolección de basura incremental
En el modo incremental, cada ciclo de GC realiza una colección de marca y barrido en pequeños pasos intercalados
con el
ejecución del programa. En este modo, el recolector usa tres números para controlar sus ciclos de recolección de
basura:
pausa del recolector de basura , el multiplicador del paso del recolector de basura y el tamaño del paso del
recolector de basura .
La pausa del recolector de basura controla cuánto tiempo espera el recolector antes de comenzar un nuevo ciclo. El
coleccionista comienza
un nuevo ciclo cuando el uso de la memoria alcanza el n% del uso después de la colección anterior. Los valores
mayores hacen
coleccionista menos agresivo. Los valores iguales o inferiores a 100 significan que el colector no esperará para iniciar
un nuevo ciclo. A
El valor de 200 significa que el colector espera a que la memoria total en uso se duplique antes de comenzar un nuevo
ciclo. los
el valor predeterminado es 200; el valor máximo es 1000.
El multiplicador de pasos del recolector de basura controla la velocidad del recolector en relación con la asignación
de memoria, es decir, cómo
muchos elementos marca o barre por cada kilobyte de memoria asignado. Los valores mayores hacen que el colector
agresivo, sino que también aumenta el tamaño de cada paso incremental. No debe utilizar valores inferiores a 100,
porque hacen que el recolector sea demasiado lento y pueden hacer que el recolector nunca termine un ciclo. El valor
predeterminado
es 100; el valor máximo es 1000.
El tamaño del paso del recolector de basura controla el tamaño de cada paso incremental, específicamente cuántos
bytes
El intérprete asigna antes de realizar un paso. Este parámetro es logarítmico: un valor de n significa que el intérprete
asignará 2 n bytes entre pasos y realizará un trabajo equivalente durante el paso. Un valor grande (por ejemplo, 60)
hace
el coleccionista un coleccionista de stop-the-world (no incremental). El valor predeterminado es 13, lo que significa
pasos de
aproximadamente 8 Kbytes.

Página 6
2.5.2 - Recolección de basura generacional
En modo generacional, el coleccionista realiza frecuentes colecciones menores , que atraviesa solo objetos creados
recientemente.
Si después de una colección menor el uso de la memoria todavía está por encima de un límite, el coleccionista hace
una parada principal.
colección, que atraviesa todos los objetos. El modo generacional utiliza dos parámetros: el multiplicador menor y el
el mayor multiplicador .
El multiplicador menor controla la frecuencia de las colecciones menores. Para un multiplicador menor x , una nueva
colección menor
hacerse cuando la memoria crezca un x% más que la memoria en uso después de la colección principal anterior. Por
ejemplo,
para un multiplicador de 20, el recolector hará una recolección menor cuando el uso de memoria sea un 20% mayor
que el uso
después de la colección principal anterior. El valor predeterminado es 20; el valor máximo es 200.
El multiplicador principal controla la frecuencia de las colecciones principales. Para un multiplicador mayor x , una
nueva colección mayor
hacerse cuando la memoria crezca un x% más que la memoria en uso después de la colección principal anterior. Por
ejemplo,
para un multiplicador de 100, el recolector hará una recolección mayor cuando el uso de la memoria sea mayor al
doble del
utilizar después de la colección anterior. El valor predeterminado es 100; el valor máximo es 1000.
2.5.3 - Metamétodos de recolección de basura
Puede establecer metamétodos recolectores de basura para tablas y, utilizando la API de C, para datos de usuario
completos (consulte §2.4 ). Estos
Los metamétodos, llamados finalizadores , se invocan cuando el recolector de basura detecta que la tabla o
userdata está muerto. Los finalizadores le permiten coordinar la recolección de basura de Lua con la administración
de recursos externos
como cerrar archivos, conexiones de red o bases de datos, o liberar su propia memoria.
Para que un objeto (tabla o datos de usuario) se finalice cuando se recopile, debe marcarlo para su finalización.
Marcas un
objeto para su finalización cuando establece su metatabla y la metatabla tiene un campo indexado por la cadena
"__gc". Nota
que si configura una metatabla sin un campo __gc y luego crea ese campo en la metatabla, el objeto no se
marcado para finalización.
Cuando un objeto marcado muere, el recolector de basura no lo recolecta de inmediato. En cambio, Lua lo pone
en una lista. Después de la colección, Lua revisa esa lista. Para cada objeto de la lista, comprueba el __gc del objeto.
metamétodo: si está presente, Lua lo llama con el objeto como su único argumento.
Al final de cada ciclo de recolección de basura, los finalizadores se llaman en el orden inverso al que fueron los
objetos.
marcados para finalización, entre los recopilados en ese ciclo; es decir, el primer finalizador que se llama es el
asociado con el objeto marcado en último lugar en el programa. La ejecución de cada finalizador puede ocurrir en
cualquier momento.
durante la ejecución del código regular.
Dado que el finalizador debe seguir utilizando el objeto que se recopila, ese objeto (y otros objetos accesibles
solo a través de él) debe ser resucitado por Lua. Por lo general, esta resurrección es transitoria y la memoria del
objeto se libera
en el próximo ciclo de recolección de basura. Sin embargo, si el finalizador almacena el objeto en algún lugar global
(por ejemplo, un
variable), entonces la resurrección es permanente. Además, si el finalizador marca un objeto de finalización para su
finalización
nuevamente, su finalizador será llamado nuevamente en el siguiente ciclo donde el objeto está muerto. En cualquier
caso, la memoria de objetos
se libera solo en un ciclo de GC en el que el objeto está muerto y no está marcado para finalización.
Cuando cierra un estado (ver lua_close ), Lua llama a los finalizadores de todos los objetos marcados para
finalización, siguiendo
el orden inverso al que fueron marcados. Si algún finalizador marca objetos para su colección durante esa fase, estos
las marcas no tienen efecto.
Los finalizadores no pueden ceder. Excepto por eso, pueden hacer cualquier cosa, como generar errores, crear nuevos
objetos o incluso
ejecutar el recolector de basura. Sin embargo, debido a que pueden ejecutarse en tiempos impredecibles, es una buena
práctica restringir
cada finalizador al mínimo necesario para liberar correctamente su recurso asociado.
Cualquier error al ejecutar un finalizador genera una advertencia; el error no se propaga.
2.5.4 - Tablas débiles
Una tabla débil es una tabla cuyos elementos son referencias débiles . Una referencia débil es ignorada por la basura.
coleccionista. En otras palabras, si las únicas referencias a un objeto son referencias débiles, entonces el recolector de
basura
recoger ese objeto.
Una tabla débil puede tener claves débiles, valores débiles o ambos. Una tabla con valores débiles permite la
recopilación de sus
valores, pero impide la recopilación de sus claves. Una tabla con claves débiles y valores débiles permite la colección
de claves y valores. En cualquier caso, si se recopila la clave o el valor, el par completo se elimina del
mesa. La debilidad de una tabla está controlada por el campo __mode de su metatabla. Este metavalor, si está
presente, debe
ser una de las siguientes cadenas: "k", para una tabla con claves débiles; "v", para una tabla con valores débiles; o
"kv", para un
tabla con claves y valores débiles.

Página 7
Una tabla con claves débiles y valores fuertes también se llama tabla de efemérides . En una tabla de efemérides, un
valor es
se considera accesible solo si su clave es accesible. En particular, si la única referencia a una clave proviene de su
valor, el par se elimina.
Cualquier cambio en la debilidad de una tabla puede tener efecto solo en el siguiente ciclo de recolección. En
particular, si cambia
la debilidad a un modo más fuerte, Lua aún puede recolectar algunos elementos de esa tabla antes de que el cambio
surta efecto.
Solo los objetos que tienen una construcción explícita se eliminan de las tablas débiles. Valores, como números y luz
Las funciones C no están sujetas a la recolección de basura y, por lo tanto, no se eliminan de las tablas débiles (a
menos que su
se recopilan los valores asociados). Aunque las cadenas están sujetas a recolección de basura, no tienen un código
explícito
construcción y su igualdad es por valor; se comportan más como valores que como objetos. Por tanto, no son
eliminado de las tablas débiles.
Objetos resucitados (es decir, objetos finalizados y objetos accesibles solo a través de objetos finalizados)
tienen un comportamiento especial en tablas débiles. Se eliminan de los valores débiles antes de ejecutar sus
finalizadores, pero
se eliminan de las claves débiles solo en la siguiente colección después de ejecutar sus finalizadores, cuando dichos
objetos se
realmente liberado. Este comportamiento permite al finalizador acceder a las propiedades asociadas con el objeto a
través de
mesas.
Si una mesa débil está entre los objetos resucitados en un ciclo de recolección, es posible que no se borre
correctamente hasta el próximo
ciclo.
2.6 - Corutinas
Lua admite corrutinas, también llamadas multiproceso colaborativo . Una corrutina en Lua representa una
hilo de ejecución. Sin embargo, a diferencia de los subprocesos en los sistemas multiproceso, una corrutina solo
suspende su ejecución
llamar explícitamente a una función de rendimiento.
Creas una corrutina llamando coroutine.create . Su único argumento es una función que es la función principal de
la corrutina. La función de creación solo crea una nueva corrutina y le devuelve un identificador (un objeto de tipo
hilo ); no inicia la corrutina.
Ejecutas una corrutina llamando coroutine.resume . Cuando llamas por primera vezcoroutine.resume , pasando como
su
primer argumento un hilo devuelto por coroutine.create , la coroutine comienza su ejecución llamando a su
función. Se pasan argumentos adicionales acoroutine.resume se pasan como argumentos a esa función. Después de la
coroutine comienza a ejecutarse, se ejecuta hasta que termina o cede .
Una corrutina puede terminar su ejecución de dos formas: normalmente, cuando su función principal regresa
(explícitamente o
implícitamente, después de la última instrucción); y de forma anormal, si hay un error desprotegido. En caso de
rescisión normal,
coroutine.resume devuelve verdadero , más cualquier valor devuelto por la función principal de coroutine. En caso
de errores,
coroutine.resume devuelve falso más el objeto de error. En este caso, la corrutina no desenrolla su pila, por lo que
que es posible inspeccionarlo después del error con la API de depuración.
Una coroutine cede llamando a coroutine.yield . Cuando una corrutina cede, el correspondiente
coroutine.resume regresa inmediatamente, incluso si el rendimiento ocurre dentro de llamadas a funciones anidadas
(es decir, no en el
función principal, pero en una función llamada directa o indirectamente por la función principal). En el caso de un
rendimiento,
coroutine.resume también devuelve verdadero , más cualquier valor pasado aCoroutine.yield . La próxima vez que
reanudar la misma corrutina, continúa su ejecución desde el punto en el que cedió, con la llamada a
coroutine.yield devolviendo cualquier argumento adicional pasado acoroutine.resume .
Como coroutine.create , elLa función coroutine.wrap también crea una corrutina, pero en lugar de devolver la
coroutine en sí, devuelve una función que, cuando se llama, reanuda la corrutina. Cualquier argumento pasado a este
la función va como argumentos adicionales para coroutine.resume . coroutine.wrap devuelve todos los valores
devueltos por
coroutine.resume, excepto el primero (el código de error booleano). A diferencia de coroutine.resume , la función
creado por coroutine.wrap propaga cualquier error a la persona que llama. En este caso, la función también cierra el
corrutina (ver coroutine.close ).
Como ejemplo de cómo funcionan las corrutinas, considere el siguiente código:
función foo (a)
imprimir ("foo", a)
return coroutine.yield (2 * a)
fin
co = coroutine.create (función (a, b)
print ("co-cuerpo", a, b)

Página 8
local r = foo (a + 1)
print ("co-cuerpo", r)
local r, s = coroutine.yield (a + b, ab)
print ("co-cuerpo", r, s)
return b, "fin"
fin)
print ("principal", coroutine.resume (co, 1, 10))
print ("main", coroutine.resume (co, "r"))
print ("main", coroutine.resume (co, "x", "y"))
print ("main", coroutine.resume (co, "x", "y"))
Cuando lo ejecuta, produce el siguiente resultado:
co-cuerpo 1 10
foo 2
principal verdadero 4
co-cuerpo r
principal verdadero 11-9
co-cuerpo xy
principal verdadero 10 final
principal falso no se puede reanudar la corrutina muerta
También puede crear y manipular corrutinas a través de la API de C: ver funciones lua_newthread ,lua_resume ,
y lua_yield .

3 - El idioma
Esta sección describe el léxico, la sintaxis y la semántica de Lua. En otras palabras, esta sección describe
qué tokens son válidos, cómo se pueden combinar y qué significan sus combinaciones.
Las construcciones del lenguaje se explicarán utilizando la notación BNF extendida habitual, en la que { a } significa
0 o más a ,
y [ a ] significa un opcional a . Los no terminales se muestran como no terminales, las palabras clave se muestran
como kword y
otros símbolos de terminal se muestran como ' = '. La sintaxis completa de Lua se puede encontrar en §9 al final de
este
manual.
3.1 - Convenciones léxicas
Lua es un lenguaje de forma libre. Ignora espacios y comentarios entre elementos léxicos (tokens), excepto como
delimitadores entre dos tokens. En el código fuente, Lua reconoce como espacios los espacios en blanco estándar
ASCII
espacio de caracteres, avance de página, nueva línea, retorno de carro, tabulación horizontal y tabulación vertical.
Los nombres (también llamados identificadores ) en Lua pueden ser cualquier cadena de letras latinas, dígitos árabe-
índicos y guiones bajos, no
comenzando con un dígito y no siendo una palabra reservada. Los identificadores se utilizan para nombrar variables,
campos de tabla y
etiquetas.
Las siguientes palabras clave están reservadas y no se pueden utilizar como nombres:
y romper hacer
más elseif final
falso para la función goto si
en
local nil no o
repetir regreso
entonces cierto hasta mientras
Lua es un lenguaje que distingue entre mayúsculas y minúsculas: y es una palabra reservada, pero Y y Y son dos
nombres válidos diferentes. Como un
convención, los programas deben evitar crear nombres que comiencen con un guión bajo seguido de uno o más
letras mayúsculas (como _VERSIÓN ).
Las siguientes cadenas denotan otros tokens:
+ - * /% ^ #
& ~ | << >> //
== ~ = <=> = <> =
() {} [] ::
; :,. .. ...

Página 9
Una cadena literal corta se puede delimitar haciendo coincidir comillas simples o dobles, y puede contener lo
siguiente en forma de C
secuencias de escape: '\ a' (campana), '\ b' (retroceso), '\ f' (alimentación de formulario), '\ n' (nueva línea), '\ r'
(retorno de carro), '\ t'
(tabulación horizontal), '\ v' (tabulación vertical), '\\' (barra invertida), '\ "' (comillas [comillas dobles]) y '\' '(apóstrofo
[una frase]). Una barra invertida seguida de un salto de línea da como resultado una nueva línea en la cadena. La
secuencia de escape '\ z'
omite el siguiente intervalo de caracteres de espacio en blanco, incluidos los saltos de línea; es particularmente útil
para romper y
sangra una cadena literal larga en varias líneas sin agregar nuevas líneas y espacios en el contenido de la cadena. A
La cadena literal corta no puede contener saltos de línea sin escape ni escapes que no formen una secuencia de escape
válida.
Podemos especificar cualquier byte en una cadena literal corta, incluidos los ceros incrustados, por su valor numérico.
Esto puede hacerse
con la secuencia de escape \ x XX , donde XX es una secuencia de exactamente dos dígitos hexadecimales, o con el
escape
secuencia \ ddd , donde ddd es una secuencia de hasta tres dígitos decimales. (Tenga en cuenta que si una secuencia
de escape decimal
debe ir seguido de un dígito, debe expresarse utilizando exactamente tres dígitos).
La codificación UTF-8 de un carácter Unicode se puede insertar en una cadena literal con la secuencia de escape \ u {
XXX }
(con llaves de cierre obligatorias), donde XXX es una secuencia de uno o más dígitos hexadecimales que representan
el
punto de código de carácter. Este punto de código puede tener cualquier valor menor que 2 31 . (Lua usa la
especificación UTF-8 original
aquí, que no está restringido a puntos de código Unicode válidos).
Las cadenas literales también se pueden definir utilizando un formato largo entre corchetes largos . Definimos una
apertura larga
corchete del nivel n como un corchete de apertura seguido de n signos iguales seguidos de otro cuadrado de apertura
soporte. Entonces, un corchete largo de apertura del nivel 0 se escribe como [[, un corchete largo de apertura del nivel
1 se escribe como [=
[, etcétera. Un paréntesis largo de cierre se define de manera similar; por ejemplo, un corchete largo de cierre del
nivel 4 se escribe como
] ====]. Un literal largo comienza con un corchete largo de apertura de cualquier nivel y termina en el primer
corchete largo de cierre de
el mismo nivel. Puede contener cualquier texto excepto un corchete de cierre del mismo nivel. Literales en esta forma
entre corchetes
puede ejecutarse para varias líneas, no interpreta ninguna secuencia de escape e ignora los corchetes largos de
cualquier otro nivel. Alguna
tipo de secuencia de fin de línea (retorno de carro, nueva línea, retorno de carro seguido de nueva línea o nueva línea
seguida de
retorno de carro) se convierte en una nueva línea simple. Cuando el corchete largo de apertura es seguido
inmediatamente por un
nueva línea, la nueva línea no está incluida en la cadena.
Por ejemplo, en un sistema que usa ASCII (en el que 'a' se codifica como 97, la nueva línea se codifica como 10 y el
'1' se codifica
como 49), las cinco cadenas literales a continuación denotan la misma cadena:
a = 'alo \ n123 "'
a = "alo \ n123 \" "
a = '\ 97lo \ 10 \ 04923 "'
a = [[alo
123 "]]
a = [== [
alo
123 "] ==]
Cualquier byte de una cadena literal no afectado explícitamente por las reglas anteriores se representa a sí mismo. Sin
embargo, Lua abre archivos
para analizar en modo texto, y las funciones de archivo del sistema pueden tener problemas con algunos caracteres de
control. Así es
Es más seguro representar datos binarios como un literal entre comillas con secuencias de escape explícitas para los
caracteres que no son de texto.
Se puede escribir una constante numérica (o numeral ) con una parte fraccionaria opcional y un exponente decimal
opcional,
marcado por una letra 'e' o 'E'. Lua también acepta constantes hexadecimales, que comienzan con 0x o 0X.
Hexadecimal
las constantes también aceptan una parte fraccionaria opcional más un exponente binario opcional, marcado por una
letra 'p' o 'P'.
Una constante numérica con un punto de base o un exponente denota un flotante; de lo contrario, si su valor encaja en
un número entero o es
una constante hexadecimal, denota un número entero; de lo contrario (es decir, un número entero decimal que se
desborda),
denota un flotador. Los números hexadecimales sin un punto de base ni un exponente siempre denotan un valor
entero;
si el valor se desborda, se ajusta para que quepa en un entero válido.
Ejemplos de constantes enteras válidas son
3345 0xff 0xBEBADA
Ejemplos de constantes flotantes válidas son
3.0 3.1416 314.16e-2 0.31416E1 34e1
0x0.1E 0xA23p-4 0X1.921FB54442D18P + 1
Un comentario comienza con un guión doble (-) en cualquier lugar fuera de una cadena. Si el texto inmediatamente
después - no es un
abriendo corchetes largos, el comentario es un comentario corto , que se extiende hasta el final de la línea. De lo
contrario, es un largo
comentario , que se ejecuta hasta el corchete largo de cierre correspondiente.

Página 10
3.2 - Variables
Las variables son lugares que almacenan valores. Hay tres tipos de variables en Lua: variables globales, variables
locales,
y campos de tabla.
Un solo nombre puede denotar una variable global o una variable local (o el parámetro formal de una función, que es
un
tipo particular de variable local):
var :: = Nombre
Nombre denota identificadores (ver §3.1 ).
Se supone que cualquier nombre de variable es global a menos que se declare explícitamente como local (consulte
§3.3.7 ). Las variables locales son
de ámbito léxico : se puede acceder libremente a las variables locales mediante funciones definidas dentro de su
ámbito (ver §3.5 ).
Antes de la primera asignación a una variable, su valor es nulo .
Los corchetes se utilizan para indexar una tabla:
var :: = prefixexp ' [ ' exp ' ] '
El significado de los accesos a los campos de la tabla se puede cambiar a través de metatablas (ver §2.4 ).
La sintaxis var.Name es simplemente azúcar sintáctica para var ["Name"]:
var :: = prefixexp ' . ' Nombre
Un acceso a una variable global x es equivalente a _ENV.x. Debido a la forma en que se compilan los fragmentos, la
variable
_ENV en sí nunca es global (ver §2.2 ).
3.3 - Declaraciones
Lua admite un conjunto de declaraciones casi convencionales, similares a las de otros lenguajes convencionales. Este
conjunto
incluye bloques, asignaciones, estructuras de control, llamadas a funciones y declaraciones de variables.
3.3.1 - Bloques
Un bloque es una lista de declaraciones, que se ejecutan secuencialmente:
bloque :: = {stat}
Lua tiene declaraciones vacías que le permiten separar declaraciones con punto y coma, comenzar un bloque con
punto y coma
o escriba dos puntos y comas en secuencia:
stat :: = ' ; '
Tanto las llamadas a funciones como las asignaciones pueden comenzar con un paréntesis abierto. Esta posibilidad
conduce a una ambigüedad en
Gramática de Lua. Considere el siguiente fragmento:
a=b+c
(imprimir o io.write) ('hecho')
La gramática podría ver este fragmento de dos formas:
a = b + c (imprimir o io.write) ('hecho')
a = b + c; (imprimir o io.write) ('hecho')
El analizador actual siempre ve tales construcciones en la primera forma, interpretando el paréntesis abierto como el
inicio
de los argumentos a una llamada. Para evitar esta ambigüedad, es una buena práctica preceder siempre con un punto y
coma
declaraciones que comienzan con un paréntesis:
; (imprimir o io.write) ('hecho')
Un bloque se puede delimitar explícitamente para producir una sola declaración:
stat :: = do block end
Los bloques explícitos son útiles para controlar el alcance de las declaraciones de variables. Los bloques explícitos
también se utilizan a veces para

Página 11
agregue una declaración de retorno en el medio de otro bloque (vea §3.3.4 ).
3.3.2 - Trozos
La unidad de compilación de Lua se llama chunk . Sintácticamente, un fragmento es simplemente un bloque:
trozo :: = bloque
Lua maneja un fragmento como el cuerpo de una función anónima con un número variable de argumentos (ver
§3.4.11 ).
Como tal, los fragmentos pueden definir variables locales, recibir argumentos y devolver valores. Además, tan
anónimo
La función se compila como en el alcance de una variable local externa llamada _ENV (ver §2.2 ). La función
resultante
siempre tiene _ENV como su única variable externa, incluso si no usa esa variable.
Un fragmento se puede almacenar en un archivo o en una cadena dentro del programa anfitrión. Para ejecutar un
fragmento, Lua primero lo carga ,
precompilar el código del fragmento en instrucciones para una máquina virtual, y luego Lua ejecuta el código
compilado
con un intérprete para la máquina virtual.
Los fragmentos también se pueden precompilar en forma binaria; ver el programa luac y la funciónstring.dump para
detalles. Los programas en formato fuente y compilado son intercambiables; Lua detecta automáticamente el tipo de
archivo y
actúa en consecuencia (ver carga ).
3.3.3 - Cesión
Lua permite múltiples asignaciones. Por lo tanto, la sintaxis de asignación define una lista de variables en el lado
izquierdo.
y una lista de expresiones en el lado derecho. Los elementos de ambas listas están separados por comas:
stat :: = varlist ' = ' lista exp
varlist :: = var {' , ' var}
explist :: = exp {' , ' exp}
Las expresiones se discuten en §3.4 .
Antes de la asignación, la lista de valores se ajusta a la longitud de la lista de variables. Si hay mas valores
de lo necesario, los valores en exceso se desechan. Si hay menos valores de los necesarios, la lista se amplía con
nil 's. Si la lista de expresiones termina con una llamada de función, todos los valores devueltos por esa llamada
ingresan a la lista de valores,
antes del ajuste (excepto cuando la llamada está entre paréntesis; ver §3.4 ).
La instrucción de asignación primero evalúa todas sus expresiones y solo entonces se realizan las asignaciones. Por lo
tanto
el código
i=3
yo, a [i] = i + 1, 20
establece a [3] en 20, sin afectar a [4] porque la i en a [i] se evalúa (a 3) antes de que se le asigne 4.
Del mismo modo, la línea
x, y = y, x
intercambia los valores de xey, y
x, y, z = y, z, x
permuta cíclicamente los valores de x, y y z.
Una asignación a un nombre global x = val es equivalente a la asignación _ENV.x = val (ver §2.2 ).
El significado de las asignaciones a campos de tabla y variables globales (que en realidad también son campos de
tabla) puede ser
cambiado a través de metatablas (ver §2.4 ).
3.3.4 - Estructuras de control
Las estructuras de control if , while y repeat tienen el significado habitual y la sintaxis familiar:
stat :: = while exp do block end
stat :: = repetir bloque hasta exp
stat :: = if exp then block { elseif exp then block} [ else block] end
Lua también tiene una declaración for , en dos sabores (ver§3.3.5 ).

Pagina 12
La expresión de condición de una estructura de control puede devolver cualquier valor. Tanto falso como nulo
prueba falsa. Todos los valores
diferente de cero y falsa prueba verdadera. En particular, el número 0 y la cadena vacía también son verdaderos.
En el ciclo repeat - until , el bloque interno no termina en la palabra clave hasta , sino solo después de la condición.
Entonces el
condición puede referirse a variables locales declaradas dentro del bloque de bucle.
La instrucción goto transfiere el control del programa a una etiqueta. Por razones sintácticas, las etiquetas en Lua se
consideran
declaraciones también:
stat :: = goto Name
stat :: = etiqueta
label :: = ' :: ' Nombre ' :: '
Una etiqueta es visible en todo el bloque donde está definida, excepto dentro de funciones anidadas. Un goto puede
saltar a cualquier
etiqueta visible siempre que no entre en el ámbito de una variable local. No se debe declarar una etiqueta donde
La etiqueta con el mismo nombre es visible, incluso si esta otra etiqueta se ha declarado en un bloque adjunto.
Las etiquetas y las declaraciones vacías se denominan declaraciones nulas , ya que no realizan acciones.
La instrucción break termina la ejecución de un while , repeat o for loop, saltando a la siguiente instrucción después
de
el lazo:
stat :: = romper
Una ruptura finaliza el bucle envolvente más interno.
La declaración de retorno se usa para devolver valores de una función o un fragmento (que se maneja como anónimo
función). Las funciones pueden devolver más de un valor, por lo que la sintaxis de la declaración de retorno es
stat :: = return [explist] [' ; ']
La declaración de retorno solo se puede escribir como la última declaración de un bloque. Si es necesario regresar
en el medio
de un bloque, entonces se puede usar un bloque interno explícito, como en el idioma do return end, porque ahora
return es el
última sentencia en su bloque (interno).
3.3.5 - Para declaración
La instrucción for tiene dos formas: una numérica y otra genérica.
El bucle for numérico
El bucle for numérico repite un bloque de código mientras una variable de control pasa por una progresión aritmética.
Eso
tiene la siguiente sintaxis:
stat :: = for Name ' = ' exp ' , ' exp [' , ' exp] do block end
El identificador dado (Nombre) define la variable de control, que es una nueva variable local al cuerpo del bucle (
bloque ).
El ciclo comienza evaluando una vez las tres expresiones de control. Sus valores se denominan respectivamente el
inicial
valor , el límite y el paso . Si el paso está ausente, el valor predeterminado es 1.
Si tanto el valor inicial como el paso son números enteros, el ciclo se realiza con números enteros; tenga en cuenta
que el límite puede no ser un
entero. De lo contrario, los tres valores se convierten en flotantes y el bucle se realiza con flotantes. Cuidado con la
flotación
precisión de puntos en este caso.
Después de esa inicialización, el cuerpo del bucle se repite con el valor de la variable de control pasando por una
aritmética
progresión, comenzando por el valor inicial, con una diferencia común dada por el paso. Un paso negativo hace
secuencia decreciente; un paso igual a cero genera un error. El bucle continúa mientras el valor es menor que o
igual al límite (mayor o igual a para un paso negativo). Si el valor inicial ya es mayor que el límite
(o menor que, si el paso es negativo), el cuerpo no se ejecuta.
Para los bucles enteros, la variable de control nunca cambia; en cambio, el bucle termina en caso de desbordamiento.
No debe cambiar el valor de la variable de control durante el ciclo. Si necesita su valor después del ciclo, asigne
a otra variable antes de salir del bucle.
El bucle for genérico

Página 13
La instrucción for genérica funciona sobre funciones, llamadas iteradores . En cada iteración, se llama a la función
iteradora para
producir un nuevo valor, deteniéndose cuando este nuevo valor es nulo . El bucle for genérico tiene la siguiente
sintaxis:
stat :: = para namelist en explist do block end
namelist :: = Name {' , ' Name}
A para una declaración como
para var_1 , ···, var_n en explist do body end
funciona de la siguiente manera.
Los nombres var_i declaran variables de bucle locales al cuerpo del bucle. La primera de estas variables es la
variable de control .
El ciclo comienza evaluando explist para producir cuatro valores: una función de iterador , un estado , un valor inicial
para el
variable de control y un valor de cierre .
Luego, en cada iteración, Lua llama a la función iteradora con dos argumentos: el estado y la variable de control. los
Los resultados de esta llamada se asignan a las variables de ciclo, siguiendo las reglas de asignaciones múltiples (ver
§3.3.3). Si la variable de control se vuelve nula , el ciclo termina. De lo contrario, el cuerpo se ejecuta y el bucle
pasa a la siguiente iteración.
El valor de cierre se comporta como una variable a cerrar (ver §3.3.8 ), que se puede utilizar para liberar recursos
cuando
termina el bucle. De lo contrario, no interfiere con el bucle.
No debe cambiar el valor de la variable de control durante el ciclo.
3.3.6 - Llamadas a funciones como declaraciones
Para permitir posibles efectos secundarios, las llamadas a funciones se pueden ejecutar como declaraciones:
stat :: = functioncall
En este caso, todos los valores devueltos se desechan. Las llamadas a funciones se explican en§3.4.10 .
3.3.7 - Declaraciones locales
Las variables locales se pueden declarar en cualquier lugar dentro de un bloque. La declaración puede incluir una
inicialización:
stat :: = attnamelist local [' = ' explist]
attnamelist :: = Name attrib {' , ' Name attrib}
Si está presente, una asignación inicial tiene la misma semántica de una asignación múltiple (ver §3.3.3 ). De lo
contrario, todos
las variables se inicializan con nil .
Cada nombre de variable puede tener un atributo (un nombre entre paréntesis angulares):
attrib :: = [' < ' Nombre ' > ']
Hay dos atributos posibles: const, que declara una variable constante, es decir, una variable que no se puede
asignado después de su inicialización; y cerrar, que declara una variable por cerrar (ver §3.3.8 ). Una lista de
las variables pueden contener como máximo una variable por cerrar.
Un fragmento también es un bloque (consulte §3.3.2 ), por lo que las variables locales se pueden declarar en un
fragmento fuera de cualquier bloque explícito.
Las reglas de visibilidad para las variables locales se explican en §3.5 .
3.3.8 - Variables por cerrar
Una variable por cerrar se comporta como una variable local constante, excepto que su valor se cierra siempre que el
la variable sale del alcance, incluida la terminación normal del bloque, la salida de su bloque mediante break / goto /
return o la salida
por un error.
Aquí, cerrar un valor significa llamar a su metamétodo __close. Al llamar al metamétodo, el valor en sí es
se pasa como primer argumento y el objeto de error que provocó la salida (si lo hubiera) se pasa como segundo
argumento; si
no hubo error, el segundo argumento es nulo .
El valor asignado a una variable por cerrar debe tener un metamétodo __close o ser un valor falso. ( nulo y
false se ignoran como valores a cerrar).

Página 14
Si varias variables por cerrar quedan fuera del alcance en el mismo evento, se cierran en el orden inverso al que
fueron declarados.
Si hay algún error al ejecutar un método de cierre, ese error se maneja como un error en el código regular donde
se definió la variable. Sin embargo, Lua puede llamar al método una vez más.
Después de un error, se seguirán llamando a los otros métodos de cierre pendientes. Los errores en estos métodos
interrumpen la
método respectivo y generan una advertencia, pero de lo contrario se ignoran; el error informado es solo el original.
Si una corrutina cede y nunca se reanuda de nuevo, es posible que algunas variables nunca salgan del alcance y, por
lo tanto,
nunca se cerrará. (Estas variables son las creadas dentro de la corrutina y dentro del alcance en el punto donde
la corrutina cedió.) De manera similar, si una corrutina termina con un error, no desenrolla su pila, por lo que no se
cierra
cualquier variable. En ambos casos, puede utilizar finalizadores o llamarcoroutine.close para cerrar las variables.
Sin embargo, si la coroutine se creó mediante coroutine.wrap, entonces su función correspondiente cerrará el
Coroutine en caso de errores.
3.4 - Expresiones
Las expresiones básicas en Lua son las siguientes:
exp :: = prefijoexp
exp :: = nulo | falso | cierto
exp :: = Numeral
exp :: = LiteralString
exp :: = functiondef
exp :: = tableconstructor
exp :: = ' ... '
exp :: = exp binop exp
exp :: = unop exp
prefixexp :: = var | functioncall | ' ( ' exp ' ) '
Los números y las cadenas literales se explican en §3.1 ; las variables se explican en §3.2 ; las definiciones de
funciones son
explicado en §3.4.11 ; las llamadas a funciones se explican en §3.4.10 ; Los constructores de tablas se explican en
§3.4.9 . Vararg
las expresiones, denotadas por tres puntos ('...'), solo se pueden usar cuando están directamente dentro de una función
vararg; son
explicado en §3.4.11.
Los operadores binarios comprenden operadores aritméticos (ver §3.4.1 ), operadores bit a bit (ver§3.4.2 ),
operadores relacionales
(ver §3.4.4 ), operadores lógicos (ver§3.4.5 ) y el operador de concatenación (ver§3.4.6 ). Operadores unarios
comprenden el menos unario (ver §3.4.1 ), el bit unario NOT (ver§3.4.2 ), el no lógico unario(ver§3.4.5 ),
y el operador de longitud unaria (ver§3.4.7 ).
Tanto las llamadas a funciones como las expresiones vararg pueden dar como resultado varios valores. Si una
llamada a función se usa como declaración
(ver §3.3.6 ), entonces su lista de retorno se ajusta a elementos cero, descartando así todos los valores devueltos. Si
una expresión
se utiliza como el último (o el único) elemento de una lista de expresiones, entonces no se realiza ningún ajuste (a
menos que el
expresión está entre paréntesis). En todos los demás contextos, Lua ajusta la lista de resultados a un elemento, ya sea
descartando todos los valores excepto el primero o agregando un solo cero si no hay valores.
Aquí hay unos ejemplos:
F()
- ajustado a 0 resultados
g (f (), x)
- f () se ajusta a 1 resultado
g (x, f ())
- g obtiene x más todos los resultados de f ()
a, b, c = f (), x - f () se ajusta a 1 resultado (c obtiene cero)
a, b = ...
- a obtiene el primer argumento vararg, b obtiene
- el segundo (tanto a como b pueden ser nulos si hay
- no hay un argumento vararg correspondiente)
a, b, c = x, f () - f () se ajusta a 2 resultados
a, b, c = f ()
- f () se ajusta a 3 resultados
volver f ()
- devuelve todos los resultados de f ()
regreso ...
- devuelve todos los argumentos vararg recibidos
return x, y, f () - devuelve x, y, y todos los resultados de f ()
{F()}
- crea una lista con todos los resultados de f ()
{...}
- crea una lista con todos los argumentos vararg
{f (), cero}
- f () se ajusta a 1 resultado

Página 15
Cualquier expresión entre paréntesis siempre da como resultado un solo valor. Por tanto, (f (x, y, z)) es siempre un
único
valor, incluso si f devuelve varios valores. (El valor de (f (x, y, z)) es el primer valor devuelto por f o nil si f no
no devuelve ningún valor.)
3.4.1 - Operadores aritméticos
Lua admite los siguientes operadores aritméticos:
+: adición
-: resta
*: multiplicación
/: división flotante
//: división de piso
%: módulo
^: exponenciación
-: unario menos
Con la excepción de la exponenciación y la división flotante, los operadores aritméticos funcionan de la siguiente
manera: Si ambos operandos
son enteros, la operación se realiza sobre enteros y el resultado es un entero. De lo contrario, si ambos operandos son
números, luego se convierten en flotantes, la operación se realiza siguiendo las reglas de la máquina para
aritmética de puntos (generalmente el estándar IEEE 754), y el resultado es un flotante. (La biblioteca de cadenas
obliga a las cadenas a
números en operaciones aritméticas; ver§3.4.3 para obtener más detalles).
La exponenciación y la división flotante (/) siempre convierten sus operandos en flotantes y el resultado siempre es
flotante.
La exponenciación usa la función ISO C pow, por lo que también funciona para exponentes no enteros.
Floor division (//) es una división que redondea el cociente hacia menos infinito, lo que da como resultado el piso de
la división
de sus operandos.
El módulo se define como el resto de una división que redondea el cociente hacia menos infinito (división del piso).
En caso de desbordamientos en aritmética de enteros, todas las operaciones se completan .
3.4.2 - Operadores bit a bit
Lua admite los siguientes operadores bit a bit:
&: bit a bit Y
|: bit a bit OR
~: OR exclusivo bit a bit
>>: desplazamiento a la derecha
<<: desplazamiento a la izquierda
~: unario bit a bit NOT
Todas las operaciones bit a bit convierten sus operandos en enteros (ver §3.4.3 ), operan en todos los bits de esos
enteros y dan como resultado
en un número entero.
Tanto los desplazamientos a la derecha como a la izquierda llenan los bits vacantes con ceros. Los desplazamientos
negativos cambian a la otra dirección;
Los desplazamientos con valores absolutos iguales o superiores al número de bits en un entero dan como resultado
cero (como todos
los bits se desplazan hacia afuera).
3.4.3 - Coacciones y conversiones
Lua proporciona algunas conversiones automáticas entre algunos tipos y representaciones en tiempo de ejecución. Bit
a bit
los operadores siempre convierten operandos flotantes en enteros. La exponenciación y la división flotante siempre
convierten un entero
operandos a flotantes. Todas las demás operaciones aritméticas aplicadas a números mixtos (enteros y flotantes)
convierten el
operando entero a un flotante. La API de C también convierte tanto enteros en flotantes como flotantes en enteros,
según sea necesario.
Además, la concatenación de cadenas acepta números como argumentos, además de cadenas.
En una conversión de entero a flotante, si el valor entero tiene una representación exacta como flotante, ese es el
resultado.
De lo contrario, la conversión obtiene el valor representable más alto o más bajo más cercano. Este tipo de
la conversión nunca falla.
La conversión de flotante a entero comprueba si el flotante tiene una representación exacta como un número entero
(es decir,
el flotante tiene un valor integral y está en el rango de representación de números enteros). Si es así, esa
representación es la
resultado. De lo contrario, la conversión falla.

Página 16
Varios lugares en Lua obligan a las cadenas a números cuando es necesario. En particular, la biblioteca de cadenas
establece
metamétodos que intentan convertir cadenas en números en todas las operaciones aritméticas. Si la conversión falla,
la biblioteca
llama al metamétodo del otro operando (si está presente) o genera un error. Tenga en cuenta que los operadores bit a
bit no
esta coerción.
No obstante, siempre es una buena práctica no depender de estas coacciones implícitas, ya que no siempre se aplican;
en
particular, "1" == 1 es falso y "1" <1 genera un error (ver §3.4.4 ). Estas coacciones existen principalmente por
compatibilidad
y puede eliminarse en futuras versiones del idioma.
Una cadena se convierte en un entero o un flotante siguiendo su sintaxis y las reglas del lexer Lua. La cuerda puede
también tienen espacios en blanco iniciales y finales y un signo. Todas las conversiones de cadenas a números
aceptan tanto un punto
y la marca de la configuración regional actual como el carácter de base. (El lexer Lua, sin embargo, acepta solo un
punto.) Si la cadena es
no es un número válido, la conversión falla. Si es necesario, el resultado de este primer paso se convierte en un
subtipo de número siguiendo las reglas anteriores para conversiones entre números flotantes y enteros.
La conversión de números a cadenas utiliza un formato legible por humanos no especificado. Para convertir números
a
cadenas de una forma específica, utilice la función string.format .
3.4.4 - Operadores relacionales
Lua admite los siguientes operadores relacionales:
==: igualdad
~ =: desigualdad
<: menor que
>: mayor que
<=: menor o igual
> =: mayor o igual
Estos operadores siempre dan como resultado falso o verdadero .
Equality (==) primero compara el tipo de sus operandos. Si los tipos son diferentes, el resultado es falso . De lo
contrario,
se comparan los valores de los operandos. Las cadenas son iguales si tienen el mismo contenido de bytes. Los
números son
iguales si denotan el mismo valor matemático.
Las tablas, los datos de usuario y los subprocesos se comparan por referencia: dos objetos se consideran iguales solo
si son los
mismo objeto. Cada vez que crea un nuevo objeto (una tabla, un usuario o un hilo), este nuevo objeto es diferente
de cualquier objeto previamente existente. Una función siempre es igual a sí misma. Funciones con cualquier
diferencia detectable
(comportamiento diferente, definición diferente) siempre son diferentes. Funciones creadas en diferentes momentos
pero sin
Las diferencias detectables pueden clasificarse como iguales o no (según los detalles del almacenamiento en caché
interno).
Puede cambiar la forma en que Lua compara tablas y datos de usuario utilizando el metamétodo __eq (consulte
§2.4 ).
Las comparaciones de igualdad no convierten cadenas en números o viceversa. Por lo tanto, "0" == 0 se evalúa como
falso , y
t [0] y t ["0"] denotan diferentes entradas en una tabla.
El operador ~ = es exactamente la negación de la igualdad (==).
Los operadores de órdenes funcionan de la siguiente manera. Si ambos argumentos son números, entonces se
comparan según su
valores matemáticos, independientemente de sus subtipos. De lo contrario, si ambos argumentos son cadenas, sus
valores son
en comparación con la ubicación actual. De lo contrario, Lua intenta llamar al metamétodo __lt o __le (ver
§2.4 ). Una comparación a> b se traduce en b <a y a> = b se traduce en b <= a.
Siguiendo el estándar IEEE 754, el valor especial NaN no se considera ni menor, ni igual, ni mayor
que cualquier valor, incluido él mismo.
3.4.5 - Operadores lógicos
Los operadores lógicos en Lua son y , o y no . Como las estructuras de control (ver §3.3.4 ), todos los operadores
lógicos
considere falso y nulo como falso y cualquier otra cosa como verdadera.
El operador de negación no siempre devuelve falso o verdadero . El operador de conjunción y devuelve su primer
argumento si
este valor es falso o nulo ; de lo contrario, y devuelve su segundo argumento. El operador de disyunción o devuelve
su primer
argumento si este valor es diferente de nil y falso ; de lo contrario, o devuelve su segundo argumento. Tanto y y o
utilizar la evaluación de cortocircuitos; es decir, el segundo operando se evalúa solo si es necesario. Aquí hay unos
ejemplos:
10 o 20
-> 10

Página 17
10 o error () -> 10
nulo o "a"
-> "a"
cero y 10
-> nada
falso y error () -> falso
falso y nulo -> falso
falso o nulo
-> nada
10 y 20
-> 20
3.4.6 - Concatenación
El operador de concatenación de cadenas en Lua se indica con dos puntos ('..'). Si ambos operandos son cadenas o
números,
luego los números se convierten en cadenas en un formato no especificado (ver §3.4.3 ). De lo contrario, el __concat
se llama metamétodo (ver §2.4 ).
3.4.7 - El operador de longitud
El operador de longitud se indica mediante el operador de prefijo unario #.
La longitud de una cadena es su número de bytes. (Ese es el significado habitual de la longitud de la cadena cuando
cada carácter es
un byte.)
El operador de longitud aplicado en una tabla devuelve un borde en esa tabla. Un borde en una tabla t es cualquier
número natural
que cumpla la siguiente condición:
(borde == 0 o t [borde] ~ = nulo) y t [borde + 1] == nulo
En palabras, un borde es cualquier índice (natural) presente en la tabla que va seguido de un índice ausente (o cero,
cuando
el índice 1 está ausente).
Una tabla con exactamente un borde se llama secuencia . Por ejemplo, la tabla {10, 20, 30, 40, 50} es una
secuencia, ya que solo tiene un borde (5). La tabla {10, 20, 30, nil, 50} tiene dos bordes (3 y 5) y
por tanto, no es una secuencia. (El nulo en el índice 4 se llama agujero ). La tabla {nil, 20, 30, nil, nil, 60,
nil} tiene tres bordes (0, 3 y 6) y tres huecos (en los índices 1, 4 y 5), por lo que tampoco es una secuencia. los
table {} es una secuencia con borde 0. Tenga en cuenta que las claves no naturales no interfieren con si una tabla es
un
secuencia.
Cuando t es una secuencia, #t devuelve su único borde, que corresponde a la noción intuitiva de la longitud del
secuencia. Cuando t no es una secuencia, #t puede devolver cualquiera de sus bordes. (El exacto depende de los
detalles del
representación interna de la tabla, que a su vez puede depender de cómo se llenó la tabla y la memoria
direcciones de sus teclas no numéricas).
El cálculo de la longitud de una tabla tiene garantizado el peor tiempo de O (log n) , donde n es el mayor tiempo
natural
clave en la tabla.
Un programa puede modificar el comportamiento del operador de longitud para cualquier valor excepto cadenas a
través de __len
metamétodo (ver §2.4 ).
3.4.8 - Precedencia
La precedencia del operador en Lua sigue la siguiente tabla, de menor a mayor prioridad:
o
y
<> <=> = ~ = ==
|
~
Y
<< >>
..
+-
* / //%
operadores unarios (no # - ~)
^
Como de costumbre, puede utilizar paréntesis para cambiar las precedencias de una expresión. La concatenación ('..')
y
Los operadores de exponenciación ('^') son asociativos por la derecha. Todos los demás operadores binarios se dejan
asociativos.

Página 18
3.4.9 - Constructores de tablas
Los constructores de tablas son expresiones que crean tablas. Cada vez que se evalúa un constructor, se crea una
nueva tabla
creado. Se puede usar un constructor para crear una tabla vacía o para crear una tabla e inicializar algunos de sus
campos.
La sintaxis general para constructores es
tableconstructor :: = ' { ' [lista de campos] ' } '
fieldlist :: = field {fieldsep field} [fieldsep]
campo :: = ' [ ' exp ' ] ' ' = ' exp | Nombre ' = ' exp | Exp
fieldsep :: = ' , ' | ' ; '
Cada campo del formulario [exp1] = exp2 agrega a la nueva tabla una entrada con la clave exp1 y el valor exp2. Un
campo de
la forma nombre = exp es equivalente a ["nombre"] = exp. Los campos del formulario exp equivalen a [i] = exp,
donde i son enteros consecutivos que comienzan con 1; los campos en los otros formatos no afectan este recuento.
Para
ejemplo,
a = {[f (1)] = g; "x", "y"; x = 1, f (x), [30] = 23; 45}
es equivalente a
hacer
local t = {}
t [f (1)] = g
t [1] = "x"
- 1er exp
t [2] = "y"
- 2da exp
tx = 1
- t ["x"] = 1
t [3] = f (x)
- 3er exp
t [30] = 23
t [4] = 45
- 4to exp
a=t
fin
El orden de las asignaciones en un constructor no está definido. (Este orden sería relevante solo cuando hay
teclas repetidas.)
Si el último campo de la lista tiene la forma exp y la expresión es una llamada a función o una expresión vararg,
entonces todos
los valores devueltos por esta expresión entran en la lista consecutivamente (ver §3.4.10 ).
La lista de campos puede tener un separador final opcional, como comodidad para el código generado por la
máquina.
3.4.10 - Llamadas a funciones
Una llamada a función en Lua tiene la siguiente sintaxis:
functioncall :: = prefixexp args
En una llamada a función, se evalúan el primer prefijoexp y los argumentos. Si el valor de prefixexp tiene función de
tipo , entonces esto
La función se llama con los argumentos dados. De lo contrario, si está presente, se llama al metamétodo prefixexp
__call: su
El primer argumento es el valor de prefixexp, seguido de los argumentos de la llamada original (ver §2.4 ).
La forma
functioncall :: = prefixexp ' : ' Args de nombre
se puede utilizar para emular métodos. Una llamada v: name ( args ) es azúcar sintáctico para v.name (v, args ),
excepto que v es
evaluado solo una vez.
Los argumentos tienen la siguiente sintaxis:
args :: = ' ( ' [lista exp] ' ) '
args :: = tableconstructor
args :: = LiteralString
Todas las expresiones de los argumentos se evalúan antes de la llamada. Una llamada de la forma f { campos } es
azúcar sintáctico para
f ({ campos }); es decir, la lista de argumentos es una única tabla nueva. Una llamada de la forma f ' cadena ' (o f "
cadena " o
f [[ cadena ]]) es azúcar sintáctico para f (' cadena '); es decir, la lista de argumentos es una única cadena literal.
Una llamada del formulario return functioncall que no está dentro del alcance de una variable por cerrar se denomina
llamada final . Lua

Página 19
implementa las llamadas de cola adecuadas (o la recursión de cola adecuada ): en una llamada de cola, la función
llamada reutiliza la entrada de la pila de la
función de llamada. Por lo tanto, no hay límite en el número de llamadas de cola anidadas que puede ejecutar un
programa.
Sin embargo, una llamada de cola borra cualquier información de depuración sobre la función de llamada. Tenga en
cuenta que una llamada de cola solo ocurre con
una sintaxis particular, donde la devolución tiene una sola llamada a función como argumento, y está fuera del
alcance de cualquier
variable a cerrar. Esta sintaxis hace que la función que llama devuelva exactamente los retornos de la función
llamada,
sin ninguna acción intermedia. Entonces, ninguno de los siguientes ejemplos son llamadas de cola:
volver (f (x))
- resultados ajustados a 1
return 2 * f (x) - resultado multiplicado por 2
return x, f (x) - resultados adicionales
f (x); regreso
- resultados descartados
return xof (x) - resultados ajustados a 1
3.4.11 - Definiciones de funciones
La sintaxis para la definición de función es
functiondef :: = function funcbody
funcbody :: = ' ( ' [parlist] ' ) ' final del bloque
El siguiente azúcar sintáctico simplifica las definiciones de funciones:
stat :: = function funcname funcbody
stat :: = nombre de la función local funcbody
funcname :: = Nombre {' . 'Nombre} [' : 'Nombre]
La declaración
función f () final del cuerpo
se traduce en
f = función () final del cuerpo
La declaración
función tabcf () body end
se traduce en
tabcf = function () body end
La declaración
función local f () final del cuerpo
se traduce en
local f; f = función () final del cuerpo
No a
local f = función () final del cuerpo
(Esto solo hace una diferencia cuando el cuerpo de la función contiene referencias a f.)
Una definición de función es una expresión ejecutable, cuyo valor tiene el tipo función . Cuando Lua precompila un
fragmento,
todos sus cuerpos funcionales también están precompilados, pero aún no se han creado. Entonces, siempre que Lua
ejecuta el
definición de función, la función es instanciada (o cerrada ). Esta instancia de función, o cierre , es el valor final de
la expresion.
Los parámetros actúan como variables locales que se inicializan con los valores de los argumentos:
parlist :: = namelist [' , ' ' ... '] | ' ... '
Cuando se llama a una función Lua, ajusta su lista de argumentos a la longitud de su lista de parámetros, a menos que
function es una función vararg , que se indica con tres puntos ('...') al final de su lista de parámetros. Un vararg
la función no ajusta su lista de argumentos; en su lugar, recopila todos los argumentos adicionales y los proporciona a
la función
mediante una expresión vararg , que también se escribe como tres puntos. El valor de esta expresión es una lista de
todos los
argumentos adicionales, similar a una función con múltiples resultados. Si se usa una expresión vararg dentro de otra

Página 20
expresión o en medio de una lista de expresiones, entonces su lista de retorno se ajusta a un elemento. Si la expresion
se utiliza como último elemento de una lista de expresiones, entonces no se realiza ningún ajuste (a menos que la
última expresión sea
entre paréntesis).
Como ejemplo, considere las siguientes definiciones:
función f (a, b) fin
función g (a, b, ...) fin
función r () return 1,2,3 end
Luego, tenemos el siguiente mapeo de argumentos a parámetros y a la expresión vararg:
LLAMADA
PARAMETROS
f (3)
a = 3, b = nada
f (3, 4)
a = 3, b = 4
f (3, 4, 5) a = 3, b = 4
f (r (), 10) a = 1, b = 10
f (r ())
a = 1, b = 2
g (3)
a = 3, b = nulo, ... -> (nada)
g (3, 4)
a = 3, b = 4, ... -> (nada)
g (3, 4, 5, 8) a = 3, b = 4, ... -> 5 8
g (5, r ())
a = 5, b = 1, ... -> 2 3
Los resultados se devuelven mediante la declaración de devolución (consulte§3.3.4 ). Si el control llega al final de
una función sin
encuentra una declaración de retorno , entonces la función regresa sin resultados.
Existe un límite dependiente del sistema en el número de valores que una función puede devolver. Este límite está
garantizado para
ser mayor que 1000.
La sintaxis de dos puntos se usa para emular métodos , agregando un parámetro adicional implícito self a la función.
Por lo tanto, la
declaración
función tabc: f ( params ) body end
es azúcar sintáctico para
tabcf = function (self, params ) body end
3.5 - Reglas de visibilidad
Lua es un lenguaje de ámbito léxico. El alcance de una variable local comienza en la primera declaración después de
su declaración
y dura hasta la última declaración no nula del bloque más interno que incluye la declaración. Considera el
siguiente ejemplo:
x = 10
-- variable global
hacer
- nuevo bloque
local x = x
- nueva 'x', con valor 10
imprimir (x)
-> 10
x=x+1
hacer
- otro bloque
local x = x + 1 - otra 'x'
imprimir (x)
-> 12
fin
imprimir (x)
-> 11
fin
imprimir (x)
-> 10 (el global)
Observe que, en una declaración como local x = x, la nueva x que se declara aún no está dentro del alcance, por lo
que la segunda x
se refiere a la variable exterior.
Debido a las reglas de alcance léxico, se puede acceder libremente a las variables locales mediante funciones
definidas dentro de su
alcance. Una variable local utilizada por una función interna se llama un valor superior (o variable local externa , o
simplemente externa
variable ) dentro de la función interna.
Observe que cada ejecución de una declaración local define nuevas variables locales. Considere el siguiente ejemplo:

Página 21
a = {}
local x = 20
para i = 1, 10 hacer
local y = 0
a [i] = función () y = y + 1; return x + y end
fin
El bucle crea diez cierres (es decir, diez instancias de la función anónima). Cada uno de estos cierres utiliza un
variable y diferente, mientras que todas comparten la misma x.
4 - La interfaz del programa de aplicación
Esta sección describe la API de C para Lua, es decir, el conjunto de funciones de C disponibles para el programa host
para
comunicarse con Lua. Todas las funciones de la API y los tipos y constantes relacionados se declaran en el archivo de
encabezado lua.h.
Incluso cuando usamos el término "función", cualquier recurso en la API puede proporcionarse como una macro.
Excepto donde
dicho de otra manera, todas estas macros usan cada uno de sus argumentos exactamente una vez (excepto para el
primer argumento, que es
siempre un estado Lua), por lo que no genera ningún efecto secundario oculto.
Como en la mayoría de las bibliotecas de C, las funciones de la API de Lua no comprueban la validez o consistencia
de sus argumentos. Sin embargo,
puede cambiar este comportamiento compilando Lua con la macro LUA_USE_APICHECK definida.
La biblioteca Lua es completamente reentrante: no tiene variables globales. Mantiene toda la información que
necesita en una estructura dinámica,
llamado el estado de Lua .
Cada estado Lua tiene uno o más subprocesos, que corresponden a líneas de ejecución independientes y cooperativas.
los
type lua_State (a pesar de su nombre) se refiere a un hilo. (Indirectamente, a través del hilo, también se refiere al
estado Lua
asociado al hilo.)
Se debe pasar un puntero a un hilo como primer argumento a cada función en la biblioteca, excepto a
lua_newstate, que crea un estado Lua desde cero y devuelve un puntero al hilo principal en el nuevo estado.
4.1 - La pila
Lua usa una pila virtual para pasar valores ay desde C. Cada elemento en esta pila representa un valor Lua ( nulo ,
número, cadena, etc.). Las funciones de la API pueden acceder a esta pila a través del parámetro de estado Lua que
recibir.
Siempre que Lua llama a C, la función llamada obtiene una nueva pila, que es independiente de las pilas anteriores y
de las pilas
de funciones C que aún están activas. Esta pila contiene inicialmente cualquier argumento para la función C y es
donde el
La función C puede almacenar valores Lua temporales y debe enviar sus resultados para que se devuelvan a la
persona que llama (consulte
lua_CFunction).
Por conveniencia, la mayoría de las operaciones de consulta en la API no siguen una disciplina de pila estricta. En
cambio, pueden referirse a
cualquier elemento de la pila mediante el uso de un índice : un índice positivo representa una posición absoluta de la
pila, comenzando en 1 como
la parte inferior de la pila; un índice negativo representa un desplazamiento relativo a la parte superior de la pila. Más
específicamente, si
la pila tiene n elementos, luego el índice 1 representa el primer elemento (es decir, el elemento que se empujó al
pila primero) y el índice n representa el último elemento; índice -1 también representa el último elemento (es decir, el
elemento
en la parte superior) y el índice -n representa el primer elemento.
4.1.1 - Tamaño de la pila
Cuando interactúa con la API de Lua, es responsable de garantizar la coherencia. En particular, eres
responsable de controlar el desbordamiento de la pila . Cuando llama a cualquier función de API, debe asegurarse de
que la pila tenga suficiente
espacio para acomodar los resultados.
Hay una excepción a la regla anterior: cuando llama a una función Lua sin un número fijo de resultados (consulte
lua_call ), Lua se asegura de que la pila tenga suficiente espacio para todos los resultados. Sin embargo, no garantiza
ningún extra
espacio. Entonces, antes de empujar cualquier cosa en la pila después de tal llamada, debe usarlua_checkstack .
Siempre que Lua llama a C, se asegura de que la pila tenga espacio para al menos elementos adicionales
LUA_MINSTACK; ese eres tu
puede empujar con seguridad hasta los valores LUA_MINSTACK en él. LUA_MINSTACK se define como 20, por
lo que normalmente no
tiene que preocuparse por el espacio de la pila a menos que su código tenga bucles que empujen elementos hacia la
pila. Cuando sea
necesario, puede utilizar la función lua_checkstack para asegurarse de que la pila tenga suficiente espacio para
empujar

Página 22
nuevos elementos.
4.1.2 - Índices válidos y aceptables
Cualquier función en la API que reciba índices de pila funciona solo con índices válidos o índices aceptables .
Un índice válido es un índice que se refiere a una posición que almacena un valor Lua modificable. Comprende
índices de pila
entre 1 y la parte superior de la pila (1 ≤ abs (índice) ≤ parte superior) más pseudoíndices , que representan algunas
posiciones
que son accesibles al código C pero que no están en la pila. Los pseudoíndices se utilizan para acceder al registro (ver
§4.3 ) y los upvalues de una función C (ver §4.2 ).
Las funciones que no necesitan una posición mutable específica, sino solo un valor (por ejemplo, funciones de
consulta), se pueden llamar con
índices aceptables. Un índice aceptable puede ser cualquier índice válido, pero también puede ser cualquier índice
positivo después de la
stack top dentro del espacio asignado para la pila, es decir, índices hasta el tamaño de la pila. (Tenga en cuenta que 0
nunca es un
índice aceptable.) Índices de upvalues (ver §4.2 ) mayor que el número real de upvalues en el actual
La función C también es aceptable (pero no válida). Excepto cuando se indique lo contrario, las funciones de la API
funcionan con
índices aceptables.
Los índices aceptables sirven para evitar pruebas adicionales en la parte superior de la pila cuando se consulta la pila.
Por ejemplo, un
La función C puede consultar su tercer argumento sin la necesidad de verificar si hay un tercer argumento, es decir,
sin la necesidad de comprobar si 3 es un índice válido.
Para funciones que se pueden llamar con índices aceptables, cualquier índice no válido se trata como si contuviera un
valor de un
tipo virtual LUA_TNONE, que se comporta como un valor nulo.
4.1.3 - Punteros a cadenas
Varias funciones en la API devuelven punteros (const char *) a cadenas Lua en la pila. (Ver lua_pushfstring ,
lua_pushlstring, lua_pushstring ,
y lua_tolstring .
Ver
además luaL_checklstring ,
luaL_checkstringy luaL_tolstring en la biblioteca auxiliar).
En general, la recolección de basura de Lua puede liberar o mover la memoria interna y luego invalidar punteros a
internos.
instrumentos de cuerda. Para permitir un uso seguro de estos punteros, la API garantiza que cualquier puntero a una
cadena en un índice de pila es
válido mientras el valor de cadena en ese índice no se elimine de la pila. (Se puede mover a otro índice,
aunque.) Cuando el índice es un pseudo-índice (refiriéndose a un valor de subida), el puntero es válido mientras que
el correspondiente
La llamada está activa y el valor de subida correspondiente no se modifica.
Algunas funciones en la interfaz de depuración también devuelven punteros a cadenas, a saber ,
lua_getlocal ,lua_getupvalue ,
lua_setlocaly lua_setupvalue . Para estas funciones, se garantiza que el puntero es válido mientras la persona que
llama
La función está activa y el cierre dado (si se dio uno) está en la pila.
A excepción de estas garantías, el recolector de basura es libre de invalidar cualquier puntero a cadenas internas.
4.2 - Cierres
Cuando se crea una función C, es posible asociarle algunos valores, creando así un cierre C (ver
lua_pushcclosure); estos valores se denominan upvalues y la función puede acceder a ellos siempre que se llame.
Siempre que se llama a una función C, sus valores de subida se ubican en pseudoíndices específicos. Estos
pseudoíndices son
producido por la macro lua_upvalueindex . El primer upvalue asociado con una función está en el índice
lua_upvalueindex (1) y así sucesivamente. Cualquier acceso a lua_upvalueindex ( n ), donde n es mayor que el
número de upvalues de la función actual (pero no mayor de 256, que es uno más el número máximo de
upvalues en un cierre), produce un índice aceptable pero no válido.
El cierre de CA también puede cambiar los valores de sus correspondientes valores de subida.
4.3 - Registro
Lua proporciona un registro , una tabla predefinida que puede ser utilizada por cualquier código C para almacenar los
valores de Lua que necesite.
Almacenar. La tabla de registro siempre está accesible en el pseudoíndice LUA_REGISTRYINDEX. Cualquier
biblioteca C puede almacenar
datos en esta tabla, pero debe tener cuidado de elegir claves que sean diferentes de las utilizadas por otras bibliotecas,
para
evitar colisiones. Por lo general, debe usar como clave una cadena que contenga el nombre de su biblioteca, o un
usuario ligero con la
dirección de un objeto C en su código, o cualquier objeto Lua creado por su código. Como ocurre con los nombres de
variables, las claves de cadena
comenzar con un guión bajo seguido de letras mayúsculas está reservado para Lua.
El mecanismo de referencia utiliza las claves enteras del registro (consulte luaL_ref ) y por algunos predefinidos

Página 23
valores. Por lo tanto, las claves enteras del registro no deben utilizarse para otros fines.
Cuando crea un nuevo estado Lua, su registro viene con algunos valores predefinidos. Estos valores predefinidos son
indexado con claves enteras definidas como constantes en lua.h. Se definen las siguientes constantes:
LUA_RIDX_MAINTHREAD: En este índice, el registro tiene el hilo principal del estado. (El hilo principal es el
uno creado junto con el estado.)
LUA_RIDX_GLOBALS: En este índice, el registro tiene el entorno global.
4.4 - Manejo de errores en C
Internamente, Lua usa la facilidad de C longjmp para manejar errores. (Lua usará excepciones si lo compila como C
++;
busque LUAI_THROW en el código fuente para obtener detalles.) Cuando Lua enfrenta algún error, como una
asignación de memoria
error o un error de tipo, genera un error; es decir, hace un salto de longitud. Un entorno protegido usa setjmp para
establecer un
punto de recuperación; cualquier error salta al punto de recuperación activo más reciente.
Dentro de una función C puede generar un error explícitamente llamando a lua_error .
La mayoría de las funciones de la API pueden generar un error, por ejemplo, debido a un error de asignación de
memoria. La documentación para
cada función indica si puede generar errores.
Si ocurre un error fuera de cualquier entorno protegido, Lua llama a una función de pánico (verlua_atpanic ) y luego
las llamadas abortan, saliendo así de la aplicación host. Su función de pánico puede evitar esta salida al no regresar
nunca (por ejemplo,
haciendo un salto de longitud a su propio punto de recuperación fuera de Lua).
La función de pánico, como su nombre lo indica, es un mecanismo de último recurso. Los programas deberían
evitarlo. Como general
regla, cuando una función C es llamada por Lua con un estado Lua, puede hacer lo que quiera en ese estado Lua,
como debería
estar ya protegido. Sin embargo, cuando el código C opera en otros estados Lua (por ejemplo, un argumento de
estado Lua al
función, un estado Lua almacenado en el registro, o el resultado de lua_newthread ), debe usarlos solo en llamadas
API
que no puede generar errores.
La función de pánico se ejecuta como si fuera un gestor de mensajes (consulte §2.3 ); en particular, el objeto de error
está en la parte superior de
la pila. Sin embargo, no hay garantía sobre el espacio de la pila. Para empujar cualquier cosa en la pila, la función de
pánico
primero debe verificar el espacio disponible (ver §4.1.1 ).
4.4.1 - Códigos de estado
Varias funciones que informan errores en la API utilizan los siguientes códigos de estado para indicar diferentes tipos
de errores o
otras condiciones:
LUA_OK (0): sin errores.
LUA_ERRRUN: un error de tiempo de ejecución.
LUA_ERRMEM: error de asignación de memoria. Para tales errores, Lua no llama al controlador de mensajes.
LUA_ERRERR: error al ejecutar el manejador de mensajes.
LUA_ERRSYNTAX: error de sintaxis durante la precompilación.
LUA_YIELD: el hilo (coroutine) cede.
LUA_ERRFILE: un error relacionado con el archivo; por ejemplo, no puede abrir o leer el archivo.
Estas constantes se definen en el archivo de encabezado lua.h.
4.5 - Manejo de rendimientos en C
Internamente, Lua usa la facilidad de C longjmp para producir una corrutina. Por lo tanto, si una función C, foo llama
a una función API
y esta función API cede (directa o indirectamente llamando a otra función que cede), Lua no puede volver a foo
más, porque el longjmp elimina su marco de la pila de C.
Para evitar este tipo de problema, Lua genera un error cada vez que intenta ceder en una llamada a la API, excepto en
tres
funciones: lua_yieldk ,lua_callk , ylua_pcallk . Todas esas funciones reciben una función de continuación (como
parámetro llamado k) para continuar la ejecución después de un rendimiento.
Necesitamos establecer alguna terminología para explicar las continuaciones. Tenemos una función C llamada desde
Lua que vamos a
llamar a la función original . Esta función original luego llama a una de esas tres funciones en la API de C, que
llamar a la función de llamada , que luego produce el hilo actual. Esto puede suceder cuando la función de llamada
lua_yieldk , o cuando la función del destinatario es lua_callk olua_pcallk y la función llamada por ellos
rendimientos.

Página 24
[-o, + p, x ]
Suponga que el hilo en ejecución cede mientras se ejecuta la función de llamada. Después de que el hilo se reanude,
eventualmente
terminar de ejecutar la función de llamada. Sin embargo, la función callee no puede volver a la función original,
porque su
El marco en la pila C fue destruido por el rendimiento. En cambio, Lua llama a una función de continuación , que se
dio como una
argumento a la función llamada. Como su nombre lo indica, la función de continuación debe continuar la tarea del
función original.
Como ilustración, considere la siguiente función:
int función_original (lua_State * L) {
... / * código 1 * /
estado = lua_pcall (L, n, m, h); / * llama a Lua * /
... / * código 2 * /
}
Ahora queremos permitir que el código Lua sea ejecutado por lua_pcall para ceder. Primero, podemos reescribir
nuestra función como aquí:
int k (lua_State * L, int status, lua_KContext ctx) {
... / * código 2 * /
}
int función_original (lua_State * L) {
... / * código 1 * /
return k (L, lua_pcall (L, n, m, h), ctx);
}
En el código anterior, la nueva función k es una función de continuación (con tipolua_KFunction ), que debería hacer
todo
el trabajo que estaba haciendo la función original después de llamar lua_pcall . Ahora, debemos informar a Lua que
debe llamar a k
si el código Lua que está ejecutando lua_pcall se interrumpe de alguna manera (errores o ceder), entonces
reescribimos el
código como aquí, reemplazando lua_pcall porlua_pcallk :
int función_original (lua_State * L) {
... / * código 1 * /
return k (L, lua_pcallk (L, n, m, h, ctx2, k), ctx1);
}
Tenga en cuenta la llamada externa y explícita a la continuación: Lua llamará a la continuación solo si es necesario,
es decir, en caso de
errores o reanudación después de un rendimiento. Si la función llamada regresa normalmente sin ceder,lua_pcallk (y
lua_callk ) también volverá normalmente. (Por supuesto, en lugar de llamar a la continuación en ese caso, puede
hacer el
trabajo equivalente directamente dentro de la función original).
Además del estado Lua, la función de continuación tiene otros dos parámetros: el estado final de la llamada y el
valor de contexto (ctx) que se pasó originalmente a lua_pcallk . Lua no usa este valor de contexto; sólo
pasa este valor de la función original a la función de continuación. Paralua_pcallk , el estado es el mismo
valor que sería devuelto por lua_pcallk , excepto que esLUA_YIELD cuando se ejecuta después de un rendimiento
(en vez de LUA_OK ). Paralua_yieldk ylua_callk , el estado es siempreLUA_YIELD cuando Lua llama al
continuación. (Para estas dos funciones, Lua no llamará a la continuación en caso de errores, porque no
manejar errores.) De manera similar, al usar lua_callk , debe llamar a la función de continuación con LUA_OK como
estado. (Paralua_yieldk , no tiene mucho sentido llamar directamente a la función de continuación, porque
lua_yieldk generalmente no regresa).
Lua trata la función de continuación como si fuera la función original. La función de continuación recibe el mismo
Pila Lua de la función original, en el mismo estado que estaría si la función llamada hubiera regresado. (Por ejemplo,
después de lua_callk la función y sus argumentos se eliminan de la pila y se reemplazan por los resultados de
la llamada.) También tiene los mismos upvalues. Todo lo que devuelve es manejado por Lua como si fuera el regreso
del
función original.
4.6 - Funciones y tipos
Aquí enumeramos todas las funciones y tipos de la API de C en orden alfabético. Cada función tiene un indicador
como este:
El primer campo, o, es cuántos elementos saca la función de la pila. El segundo campo, p, es cuántos
elementos que la función empuja a la pila. (Cualquier función siempre empuja sus resultados después de mostrar sus
argumentos).
Un campo en la forma x | y significa que la función puede presionar (o hacer saltar) elementos xoy, dependiendo de la
situación; un
signo de interrogación '?' significa que no podemos saber cuántos elementos muestra / empuja la función mirando
solo
en sus argumentos. (Por ejemplo, pueden depender de lo que hay en la pila). El tercer campo, x, indica si el
la función puede generar errores: '-' significa que la función nunca genera ningún error; 'm' significa que la función
puede generar solo

Página 25
[-0, +0, -]
[- (2 | 1), +1, e ]
errores de memoria; 'v' significa que la función puede generar los errores explicados en el texto; 'e' significa que la
función puede ejecutarse
código Lua arbitrario, ya sea directamente o mediante metamétodos, y por lo tanto puede generar errores.
lua_absindex
int lua_absindex (lua_State * L, int idx);
Convierte el idx del índice aceptable en un índice absoluto equivalente (es decir, uno que no depende de la
tamaño de la pila).
lua_Alloc
typedef void * (* lua_Alloc) (void * ud,
void * ptr,
size_t osize,
size_t nsize);
El tipo de función de asignación de memoria utilizada por los estados de Lua. La función de asignador debe
proporcionar una funcionalidad
similar a realloc, pero no exactamente igual. Sus argumentos son ud, un puntero opaco que se pasa a
lua_newstate; ptr, un puntero al bloque que se asigna / reasigna / libera; osize, el tamaño original del
bloque o algún código sobre lo que se está asignando; y nsize, el nuevo tamaño del bloque.
Cuando ptr no es NULL, osize es el tamaño del bloque señalado por ptr, es decir, el tamaño dado cuando se asignó
o reasignado.
Cuando ptr es NULL, osize codifica el tipo de objeto que Lua está asignando. osize es cualquiera
deLUA_TSTRING ,
LUA_TTABLE , LUA_TFUNCTION ,LUA_TUSERDATA , oLUA_TTHREAD cuando (y solo cuando) Lua está
creando un
nuevo objeto de ese tipo. Cuando osize es algún otro valor, Lua está asignando memoria para otra cosa.
Lua asume el siguiente comportamiento de la función de asignación:
Cuando nsize es cero, el asignador debe comportarse como libre y luego devolver NULL.
Cuando nsize no es cero, el asignador debe comportarse como realloc. En particular, el asignador devuelve NULL si
y
solo si no puede cumplir con la solicitud.
Aquí hay una implementación simple para la función de asignación. Se utiliza en la biblioteca auxiliar
porluaL_newstate .
static void * l_alloc (void * ud, void * ptr, size_t osize,
size_t nsize) {
(vacío) ud; (vacío) osize; /* no utilizado */
if (nsize == 0) {
libre (ptr);
return NULL;
}
demás
return realloc (ptr, nsize);
}
Tenga en cuenta que el estándar C asegura que free (NULL) no tiene ningún efecto y que realloc (NULL, size) es
equivalente a
malloc (tamaño).
lua_arith
void lua_arith (lua_State * L, int op);
Realiza una operación aritmética o bit a bit sobre los dos valores (o uno, en el caso de negaciones) en la parte superior
de la
pila, con el valor en la parte superior siendo el segundo operando, saca estos valores y empuja el resultado de la
operación. La función sigue la semántica del operador Lua correspondiente (es decir, puede llamar
metamétodos).
El valor de op debe ser una de las siguientes constantes:
LUA_OPADD: realiza suma (+)
LUA_OPSUB: realiza resta (-)
LUA_OPMUL: realiza multiplicación (*)
LUA_OPDIV: realiza división flotante (/)

Página 26
[-0, +0, -]
[- (nargs + 1), + nresults, e ]
[- (nargs + 1), + nresults, e ]
LUA_OPIDIV: realiza división de piso (//)
LUA_OPMOD: realiza módulo (%)
LUA_OPPOW: realiza exponenciación (^)
LUA_OPUNM: realiza negación matemática (unario -)
LUA_OPBNOT: realiza bit a bit NOT (~)
LUA_OPBAND: realiza AND (&) bit a bit
LUA_OPBOR: realiza OR bit a bit (|)
LUA_OPBXOR: realiza OR exclusivo bit a bit (~)
LUA_OPSHL: realiza desplazamiento a la izquierda (<<)
LUA_OPSHR: realiza desplazamiento a la derecha (>>)
lua_atpanic
lua_CFunction lua_atpanic (lua_State * L, lua_CFunction panicf);
Establece una nueva función de pánico y devuelve la anterior (ver §4.4 ).
lua_call
void lua_call (lua_State * L, int nargs, int nresults);
Llama a una función. Al igual que las llamadas regulares de Lua, lua_call respeta el metamétodo __call. Entonces,
aquí la palabra
"función" significa cualquier valor invocable.
Para realizar una llamada, debe utilizar el siguiente protocolo: primero, la función a llamar se inserta en la pila;
entonces el
los argumentos de la llamada se insertan en orden directo; es decir, el primer argumento se inserta primero.
Finalmente llamas
lua_call ; nargs es el número de argumentos que introdujo en la pila. Cuando la función regresa, todos
Los argumentos y el valor de la función se abren y los resultados de la llamada se envían a la pila. El número de
Los resultados se ajustan a nresults, a menos que nresults sea LUA_MULTRET. En este caso, todos los resultados de
la función son
empujado; Lua se encarga de que los valores devueltos quepan en el espacio de la pila, pero no garantiza ningún
espacio adicional en
la pila. Los resultados de la función se insertan en la pila en orden directo (el primer resultado se inserta primero), de
modo que
después de la llamada, el último resultado está en la parte superior de la pila.
Cualquier error al llamar y ejecutar la función se propaga hacia arriba (con un longjmp).
El siguiente ejemplo muestra cómo el programa anfitrión puede hacer el equivalente a este código Lua:
a = f ("cómo", tx, 14)
Aquí está en C:
lua_getglobal (L, "f");
/ * función a llamar * /
lua_pushliteral (L, "cómo");
/ * 1er argumento * /
lua_getglobal (L, "t");
/ * tabla a indexar * /
lua_getfield (L, -1, "x");
/ * empujar el resultado de tx (2nd arg) * /
lua_remove (L, -2);
/ * eliminar 't' de la pila * /
lua_pushinteger (L, 14);
/ * 3er argumento * /
lua_call (L, 3, 1); / * llamar a 'f' con 3 argumentos y 1 resultado * /
lua_setglobal (L, "a");
/ * establecer global 'a' * /
Tenga en cuenta que el código anterior está equilibrado : al final, la pila vuelve a su configuración original. Esto se
considera
buenas prácticas de programación.
lua_callk
void lua_callk (lua_State * L,
int nargs,
int nresults,
lua_KContext ctx,
lua_KFunction k);
Esta función se comporta exactamente como lua_call , pero permite que la función llamada ceda (ver §4.5 ).
lua_CFunction
typedef int (* lua_CFunction) (lua_State * L);

Página 27
[-0, +0, -]
[-0, +0, -]
[-0, +0, e ]
[-n, +1, e ]
Escriba para funciones C.
Para comunicarse correctamente con Lua, una función C debe utilizar el siguiente protocolo, que define la forma
se pasan parámetros y resultados: una función C recibe sus argumentos de Lua en su pila en orden directo (el
el primer argumento se empuja primero). Entonces, cuando se inicia la función, lua_gettop (L) devuelve el número de
argumentos
recibido por la función. El primer argumento (si lo hay) está en el índice 1 y su último argumento está en el índice
lua_gettop (L). Para devolver valores a Lua, una función C simplemente los empuja a la pila, en orden directo (la
primera
resultado se empuja primero) y devuelve en C el número de resultados. Cualquier otro valor en la pila debajo de los
resultados será
debidamente descartado por Lua. Como una función Lua, una función C llamada por Lua también puede devolver
muchos resultados.
Como ejemplo, la siguiente función recibe un número variable de argumentos numéricos y devuelve su promedio
y su suma:
static int foo (lua_State * L) {
int n = lua_gettop (L); / * número de argumentos * /
lua_Number suma = 0.0;
int i;
para (i = 1; i <= n; i ++) {
if (! lua_isnumber (L, i)) {
lua_pushliteral (L, "argumento incorrecto");
lua_error (L);
}
suma + = lua_tonumber (L, i);
}
lua_pushnumber (L, suma / n);
/ * primer resultado * /
lua_pushnumber (L, suma);
/ * segundo resultado * /
volver 2;
/ * número de resultados * /
}
lua_checkstack
int lua_checkstack (lua_State * L, int n);
Asegura que la pila tenga espacio para al menos n elementos adicionales, es decir, que pueda empujar con seguridad
hasta n valores en
eso. Devuelve falso si no puede cumplir con la solicitud, ya sea porque causaría que la pila sea mayor que un fijo
tamaño máximo (normalmente al menos varios miles de elementos) o porque no puede asignar memoria para el extra
espacio. Esta función nunca reduce la pila; si la pila ya tiene espacio para los elementos adicionales, se deja
sin alterar.
lua_close
vacío lua_close (lua_State * L);
Cierre todas las variables activas por cerrar en el hilo principal, libere todos los objetos en el estado Lua dado
(llamando al
correspondientes metamétodos de recolección de basura, si los hay), y libera toda la memoria dinámica utilizada por
este estado.
En varias plataformas, es posible que no necesite llamar a esta función, porque todos los recursos se liberan
naturalmente cuando
finaliza el programa anfitrión. Por otro lado, los programas de larga ejecución que crean varios estados, como los
demonios
o servidores web, probablemente necesitarán cerrar estados tan pronto como no sean necesarios.
lua_compare
int lua_compare (lua_State * L, int index1, int index2, int op);
Compara dos valores de Lua. Devuelve 1 si el valor en el índice index1 satisface op cuando se compara con el valor
en
index index2, siguiendo la semántica del operador Lua correspondiente (es decir, puede llamar a metamétodos).
De lo contrario, devuelve 0. También devuelve 0 si alguno de los índices no es válido.
El valor de op debe ser una de las siguientes constantes:
LUA_OPEQ: compara la igualdad (==)
LUA_OPLT: compara por menos de (<)
LUA_OPLE: compara por menor o igual (<=)
lua_concat
void lua_concat (lua_State * L, int n);

Página 28
[-0, +0, -]
[-0, +1, m ]
[-0, +0, -]
[-1, +0, v ]
[-0, +0, -]
Concatena los n valores en la parte superior de la pila, los saca y deja el resultado en la parte superior. Si n es 1, el
resultado
es el valor único en la pila (es decir, la función no hace nada); si n es 0, el resultado es la cadena vacía.
La concatenación se realiza siguiendo la semántica habitual de Lua (ver §3.4.6 ).
lua_copy
void lua_copy (lua_State * L, int fromidx, int toidx);
Copia el elemento en el índice de idx en el índice válido de idx, reemplazando el valor en esa posición. Valores en
otras posiciones no se ven afectadas.
lua_createtable
void lua_createtable (lua_State * L, int narr, int nrec);
Crea una nueva tabla vacía y la coloca en la pila. El parámetro narr es una pista de cuántos elementos
la tabla tendrá como secuencia; El parámetro nrec es una pista de cuántos otros elementos tendrá la tabla. Lua mayo
utilice estas sugerencias para preasignar memoria para la nueva tabla. Esta preasignación puede ayudar al
rendimiento cuando
sepa de antemano cuántos elementos tendrá la mesa. De lo contrario, puede utilizar la funciónlua_newtable.
lua_dump
int lua_dump (lua_State * L,
lua_Writer escritor,
datos vacíos *,
int tira);
Vuelca una función como un fragmento binario. Recibe una función Lua en la parte superior de la pila y produce un
fragmento binario
que, si se carga de nuevo, da como resultado una función equivalente a la que se volcó. Como produce partes del
trozo,
lua_dump llama a la función de escritor (verlua_Writer ) con los datos dados para escribirlos.
Si strip es verdadero, la representación binaria puede no incluir toda la información de depuración sobre la función,
para guardar
espacio.
El valor devuelto es el código de error devuelto por la última llamada al escritor; 0 significa que no hay errores.
Esta función no saca la función Lua de la pila.
lua_error
int lua_error (lua_State * L);
Genera un error de Lua, utilizando el valor en la parte superior de la pila como objeto de error. Esta función hace un
salto de longitud,
y por lo tanto nunca regresa (ver luaL_error ).
lua_gc
int lua_gc (lua_State * L, int qué, ...);
Controla el recolector de basura.
Esta función realiza varias tareas, según el valor del parámetro qué. Para opciones que necesitan más
argumentos, se enumeran después de la opción.
LUA_GCCOLLECT: Realiza un ciclo completo de recolección de basura.
LUA_GCSTOP: detiene el recolector de basura.
LUA_GCRESTART: reinicia el recolector de basura.
LUA_GCCOUNT: Devuelve la cantidad actual de memoria (en Kbytes) en uso por Lua.
LUA_GCCOUNTB: Devuelve el resto de dividir la cantidad actual de bytes de memoria en uso por Lua por
1024.
LUA_GCSTEP (int stepsize): Realiza un paso incremental de recolección de basura, correspondiente al
asignación de tamaño de paso Kbytes.
LUA_GCISRUNNING: Devuelve un booleano que indica si el recopilador está en ejecución (es decir, no detenido).
LUA_GCINC (int pause, int stepmul, stepsize): cambia el colector al modo incremental con el dado
parámetros (ver §2.5.1 ). Devuelve el modo anterior (LUA_GCGEN o LUA_GCINC).
 Página 29
[-0, +0, -]
[-0, +1, e ]
[-0, +0, -]
[-0, +1, e ]
[-0, +1, e ]
[-0, + (0 | 1), -]
[-1, +1, e ]
LUA_GCGEN (int minormul, int majormul): Cambia el colector al modo generacional con el dado
parámetros (ver §2.5.2 ). Devuelve el modo anterior (LUA_GCGEN o LUA_GCINC).
Para obtener más detalles sobre estas opciones, consulte recoger basura .
lua_getallocf
lua_Alloc lua_getallocf (lua_State * L, vacío ** ud);
Devuelve la función de asignación de memoria de un estado dado. Si ud no es NULL, Lua almacena en * ud el
puntero opaco
dado cuando se estableció la función de asignación de memoria.
lua_getfield
int lua_getfield (lua_State * L, int index, const char * k);
Coloca en la pila el valor t [k], donde t es el valor en el índice dado. Como en Lua, esta función puede
activar un metamétodo para el evento "índice" (ver §2.4 ).
Devuelve el tipo de valor introducido.
lua_getextraspace
vacío * lua_getextraspace (lua_State * L);
Devuelve un puntero a un área de memoria sin procesar asociada con el estado Lua dado. La aplicación puede utilizar
esta área para
cualquier propósito; Lua no lo usa para nada.
Cada hilo nuevo tiene esta área inicializada con una copia del área del hilo principal.
De forma predeterminada, esta área tiene el tamaño de un puntero para anular, pero puede volver a compilar Lua con
un tamaño diferente para esta área.
(Ver LUA_EXTRASPACE en luaconf.h.)
lua_getglobal
int lua_getglobal (lua_State * L, const char * nombre);
Coloca en la pila el valor del nombre global. Devuelve el tipo de ese valor.
lua_geti
int lua_geti (lua_State * L, int índice, lua_Integer i);
Coloca en la pila el valor t [i], donde t es el valor en el índice dado. Como en Lua, esta función puede
activar un metamétodo para el evento "índice" (ver §2.4 ).
Devuelve el tipo de valor introducido.
lua_getmetatable
int lua_getmetatable (lua_State * L, int índice);
Si el valor en el índice dado tiene una metatabla, la función empuja esa metatabla a la pila y devuelve 1.
De lo contrario, la función devuelve 0 y no coloca nada en la pila.
lua_gettable
int lua_gettable (lua_State * L, int índice);
Coloca en la pila el valor t [k], donde t es el valor en el índice dado y k es el valor en la parte superior de la
apilar.
Esta función saca la clave de la pila, empujando el valor resultante en su lugar. Como en Lua, esta función puede
activar un metamétodo para el evento "índice" (ver §2.4 ).
Devuelve el tipo de valor introducido.
lua_gettop

Página 30
[-0, +0, -]
[-0, +1, -]
[-1, +1, -]
[-0, +0, -]
[-0, +0, -]
[-0, +0, -]
[-0, +0, -]
[-0, +0, -]
[-0, +0, -]
int lua_gettop (lua_State * L);
Devuelve el índice del elemento superior de la pila. Dado que los índices empiezan en 1, este resultado es igual al
número de
elementos en la pila; en particular, 0 significa una pila vacía.
lua_getiuservalue
int lua_getiuservalue (lua_State * L, int index, int n);
Inserta en la pila el enésimo valor de usuario asociado con los datos de usuario completos en el índice dado y
devuelve el
tipo de valor introducido.
Si el userdata no tiene ese valor, empuja nil y regresaLUA_TNONE .
lua_insert
vacío lua_insert (lua_State * L, índice int);
Mueve el elemento superior al índice válido dado, desplazando los elementos por encima de este índice al espacio
abierto. Esta
La función no se puede llamar con un pseudo-índice, porque un pseudo-índice no es una posición de pila real.
lua_Integer
typedef ... lua_Integer;
El tipo de números enteros en Lua.
De forma predeterminada, este tipo es long long (normalmente un entero de dos complementos de 64 bits), pero se
puede cambiar a long o
int (normalmente un entero de dos complementos de 32 bits). (Ver LUA_INT_TYPE en luaconf.h.)
Lua también define las constantes LUA_MININTEGER y LUA_MAXINTEGER, con el mínimo y el máximo
valores que encajan en este tipo.
lua_isboolean
int lua_isboolean (lua_State * L, int índice);
Devuelve 1 si el valor en el índice dado es booleano y 0 en caso contrario.
lua_iscfunction
int lua_iscfunction (lua_State * L, int índice);
Devuelve 1 si el valor en el índice dado es una función C y 0 en caso contrario.
lua_isfunction
int lua_isfunction (lua_State * L, int índice);
Devuelve 1 si el valor en el índice dado es una función (ya sea C o Lua) y 0 en caso contrario.
lua_isinteger
int lua_isinteger (lua_State * L, int índice);
Devuelve 1 si el valor en el índice dado es un número entero (es decir, el valor es un número y se representa como un
integer) y 0 en caso contrario.
lua_islightuserdata
int lua_islightuserdata (lua_State * L, int índice);
Devuelve 1 si el valor en el índice dado es un dato de usuario ligero y 0 en caso contrario.
lua_isnil
int lua_isnil (lua_State * L, int índice);

Página 31
[-0, +0, -]
[-0, +0, -]
[-0, +0, -]
[-0, +0, -]
[-0, +0, -]
[-0, +0, -]
[-0, +0, -]
[-0, +0, -]
[-0, +1, e ]
Devuelve 1 si el valor en el índice dado es nulo y 0 en caso contrario.
lua_isnone
int lua_isnone (lua_State * L, int índice);
Devuelve 1 si el índice dado no es válido y 0 en caso contrario.
lua_isnoneornil
int lua_isnoneornil (lua_State * L, int índice);
Devuelve 1 si el índice dado no es válido o si el valor de este índice es nulo y 0 en caso contrario.
lua_isnumber
int lua_isnumber (lua_State * L, int índice);
Devuelve 1 si el valor en el índice dado es un número o una cadena convertible en un número, y 0 en caso contrario.
lua_isstring
int lua_isstring (lua_State * L, int índice);
Devuelve 1 si el valor en el índice dado es una cadena o un número (que siempre se puede convertir en una cadena), y
0 de lo contrario.
lua_istable
int lua_istable (lua_State * L, int índice);
Devuelve 1 si el valor en el índice dado es una tabla y 0 en caso contrario.
lua_isthread
int lua_isthread (lua_State * L, int índice);
Devuelve 1 si el valor en el índice dado es un hilo y 0 en caso contrario.
lua_isuserdata
int lua_isuserdata (lua_State * L, int índice);
Devuelve 1 si el valor en el índice dado es un dato de usuario (completo o claro) y 0 en caso contrario.
lua_isyieldable
int lua_isyieldable (lua_State * L);
Devuelve 1 si la corrutina dada puede ceder y 0 en caso contrario.
lua_KContext
typedef ... lua_KContext;
El tipo para contextos de función de continuación. Debe ser de tipo numérico. Este tipo se define como intptr_t
cuando
intptr_t está disponible, por lo que también puede almacenar punteros. De lo contrario, se define como ptrdiff_t.
lua_KFunction
typedef int (* lua_KFunction) (lua_State * L, int status, lua_KContext ctx);
Escriba para funciones de continuación (consulte §4.5 ).
lua_len
void lua_len (lua_State * L, índice int);

Página 32
[-0, +1, -]
[-0, +0, -]
[-0, +1, m ]
[-0, +1, m ]
[-0, +1, m ]
Devuelve la longitud del valor en el índice dado. Es equivalente al operador '#' en Lua (ver§3.4.7 ) y puede
activar un metamétodo para el evento de "duración" (ver §2.4 ). El resultado se coloca en la pila.
lua_load
int lua_load (lua_State * L,
lector lua_Reader,
datos vacíos *,
const char * chunkname,
modo const char *);
Carga un fragmento de Lua sin ejecutarlo. Si no hay errores, lua_load empuja el fragmento compilado como un Lua
función en la parte superior de la pila. De lo contrario, muestra un mensaje de error.
La función lua_load utiliza una función de lector proporcionada por el usuario para leer el fragmento (consulte
lua_Reader ). Los datos
El argumento es un valor opaco que se pasa a la función del lector.
El argumento chunkname le da un nombre al fragmento, que se usa para mensajes de error y en información de
depuración.
(ver §4.7 ).
lua_load detecta automáticamente si el fragmento es texto o binario y lo carga en consecuencia (ver programa luac).
El modo de cadena funciona como en la función de carga , con la adición de que un valor NULL es equivalente a la
cadena "bt".
lua_load usa la pila internamente, por lo que la función del lector siempre debe dejar la pila sin modificar cuando
regresando.
lua_load puede volver LUA_OK ,LUA_ERRSYNTAX , oLUA_ERRMEM . La función también puede devolver
otros valores
correspondiente a los errores generados por la función de lectura (ver §4.4.1 ).
Si la función resultante tiene upvalues, su primer upvalue se establece en el valor del entorno global almacenado en
index
LUA_RIDX_GLOBALS en el registro (ver §4.3 ). Al cargar fragmentos principales, este valor ascendente será la
variable _ENV
(ver §2.2 ). Otros upvalues se inicializan con nil .
lua_newstate
lua_State * lua_newstate (lua_Alloc f, void * ud);
Crea un nuevo estado independiente y devuelve su hilo principal. Devuelve NULL si no puede crear el estado (debido
a
falta de memoria). El argumento f es la función de asignación; Lua hará toda la asignación de memoria para este
estado a través de
esta función (ver lua_Alloc ). El segundo argumento, ud, es un puntero opaco que Lua pasa al asignador en
cada llamada.
lua_newtable
void lua_newtable (lua_State * L);
Crea una nueva tabla vacía y la coloca en la pila. Es equivalente a lua_createtable (L, 0, 0).
lua_newthread
lua_State * lua_newthread (lua_State * L);
Crea un nuevo hilo, lo empuja a la pila y devuelve un puntero a un lua_State que representa este nuevo
hilo. El nuevo hilo devuelto por esta función comparte con el hilo original su entorno global, pero tiene un
pila de ejecución independiente.
Los hilos están sujetos a la recolección de basura, como cualquier objeto Lua.
lua_newuserdatauv
void * lua_newuserdatauv (lua_State * L, size_t size, int nuvalue);
Esta función crea y empuja en la pila nuevos datos de usuario completos, con valores Lua asociados a nuvalue,
llamados
valores de usuario, más un bloque asociado de memoria sin procesar con bytes de tamaño. (Los valores de usuario se
pueden configurar y leer
con las funciones lua_setiuservalue ylua_getiuservalue .)
La función devuelve la dirección del bloque de memoria. Lua se asegura de que esta dirección sea válida siempre que
el

Página 33
[-1, + (2 | 0), v ]
[- (nargs + 1), + (nresults | 1), -]
los datos de usuario correspondientes están vivos (ver §2.5 ). Además, si los datos del usuario están marcados para su
finalización (consulte§2.5.3 ), su
La dirección es válida al menos hasta la llamada a su finalizador.
lua_next
int lua_next (lua_State * L, int índice);
Saca una clave de la pila y empuja un par clave-valor de la tabla en el índice dado, el "siguiente" par después del
clave dada. Si no hay más elementos en la tabla, entonceslua_next devuelve 0 y no inserta nada.
Un recorrido de tabla típico se ve así:
/ * la tabla está en la pila en el índice 't' * /
lua_pushnil (L); / * primera clave * /
while (lua_next (L, t)! = 0) {
/ * usa 'clave' (en el índice -2) y 'valor' (en el índice -1) * /
printf ("% s -% s \ n",
lua_typename (L, lua_type (L, -2)),
lua_typename (L, lua_type (L, -1)));
/ * elimina 'valor'; mantiene 'clave' para la próxima iteración * /
lua_pop (L, 1);
}
Mientras atraviesa una mesa, evite llamar lua_tolstring directamente en una clave, a menos que sepa que la clave es
en realidad
una cuerda. Recordar quelua_tolstring puede cambiar el valor en el índice dado; esto confunde la próxima llamada a
lua_next .
Esta función puede generar un error si la clave dada no es nula ni está presente en la tabla. Consulte la función
siguiente para
advertencias de modificar la tabla durante su recorrido.
lua_Number
typedef ... lua_Number;
El tipo de carrozas en Lua.
De forma predeterminada, este tipo es doble, pero se puede cambiar a un solo flotante o un doble largo. (Ver
LUA_FLOAT_TYPE
en luaconf.h.)
lua_numbertointeger
int lua_numbertointeger (lua_Number n, lua_Integer * p);
Intenta convertir un flotante Lua en un entero Lua; el flotador n debe tener un valor integral. Si ese valor está dentro
del
rango de enteros Lua, se convierte a un entero y se asigna a * p. La macro da como resultado un booleano que indica
si la conversión fue exitosa. (Tenga en cuenta que esta prueba de rango puede ser difícil de realizar correctamente sin
esta macro,
debido al redondeo.)
Esta macro puede evaluar sus argumentos más de una vez.
lua_pcall
int lua_pcall (lua_State * L, int nargs, int nresults, int msgh);
Llama a una función (o un objeto invocable) en modo protegido.
Tanto nargs como nresults tienen el mismo significado que en lua_call . Si no hay errores durante la llamada,
lua_pcall se comporta exactamente comolua_call . Sin embargo, si hay algún error,lua_pcall lo atrapa, empuja un
valor único en la pila (el objeto de error) y devuelve un código de error. Como lua_call , lua_pcall siempre
elimina la función y sus argumentos de la pila.
Si msgh es 0, entonces el objeto de error devuelto en la pila es exactamente el objeto de error original. De lo
contrario, msgh es el
índice de pila de un controlador de mensajes . (Este índice no puede ser un pseudoíndice). En caso de errores de
tiempo de ejecución, este controlador
será llamado con el objeto de error y su valor de retorno será el objeto devuelto en la pila por lua_pcall .
Normalmente, el controlador de mensajes se utiliza para agregar más información de depuración al objeto de error,
como una pila.
rastrear. Dicha información no se puede recopilar después de la devolución delua_pcall , ya que para entonces la pila
tiene

Página 34
[- (nargs + 1), + (nresults | 1), -]
[-n, +0, e ]
[-0, +1, -]
[-n, +1, m ]
[-0, +1, -]
[-0, +1, v ]
desenrollado.
La función lua_pcall devuelve uno de los siguientes códigos de estado: LUA_OK , LUA_ERRRUN ,
LUA_ERRMEM o
LUA_ERRERR .
lua_pcallk
int lua_pcallk (lua_State * L,
int nargs,
int nresults,
int msgh,
lua_KContext ctx,
lua_KFunction k);
Esta función se comporta exactamente como lua_pcall , excepto que permite que la función llamada ceda (ver §4.5 ).
lua_pop
void lua_pop (lua_State * L, int n);
Saca n elementos de la pila.
Esta función puede ejecutar código arbitrario al eliminar un índice marcado como por cerrar de la pila.
lua_pushboolean
void lua_pushboolean (lua_State * L, int b);
Inserta un valor booleano con valor b en la pila.
lua_pushcclosure
void lua_pushcclosure (lua_State * L, lua_CFunction fn, int n);
Empuja un nuevo cierre C en la pila. Esta función recibe un puntero a una función C y empuja a la pila
un valor Lua de función de tipo que, cuando se llama, invoca la función C correspondiente. El parámetro n dice
cuántos upvalues tendrá esta función (ver §4.2 ).
Cualquier función que Lua pueda llamar debe seguir el protocolo correcto para recibir sus parámetros y devolver sus
resultados.
(ver lua_CFunction ).
Cuando se crea una función C, es posible asociarle algunos valores, los llamados upvalues; estos
Los upvalues son entonces accesibles a la función cada vez que se llama. Esta asociación se llama cierre C (ver
§4.2 ). Para crear un cierre de C, primero los valores iniciales para sus valores de subida deben insertarse en la pila.
(Cuando ahí
son múltiples upvalues, el primer valor se inserta primero.) Luego Se llama a lua_pushcclosure para crear e impulsar
el
C en la pila, con el argumento n indicando cuántos valores se asociarán con la función.
lua_pushcclosure también extrae estos valores de la pila.
El valor máximo de n es 255.
Cuando n es cero, esta función crea una función C ligera , que es solo un puntero a la función C. En ese caso,
nunca genera un error de memoria.
lua_pushcfunction
void lua_pushcfunction (lua_State * L, lua_CFunction f);
Inserta una función C en la pila. Esta función es equivalente alua_pushcclosure sin upvalues.
lua_pushfstring
const char * lua_pushfstring (lua_State * L, const char * fmt, ...);
Inserta en la pila una cadena formateada y devuelve un puntero a esta cadena (consulte §4.1.3 ). Es similar a la ISO C
función sprintf, pero tiene dos diferencias importantes. Primero, no tiene que asignar espacio para el resultado; la
el resultado es una cadena Lua y Lua se encarga de la asignación de memoria (y desasignación, mediante la
recolección de basura).
En segundo lugar, los especificadores de conversión están bastante restringidos. No hay banderas, anchos ni
precisiones. La conversión

Página 35
[-0, +1, -]
[-0, +1, -]
[-0, +1, -]
[-0, +1, m ]
[-0, +1, m ]
[-0, +1, -]
[-0, +1, -]
[-0, +1, m ]
los especificadores solo pueden ser '%%' (inserta el carácter '%'), '% s' (inserta una cadena terminada en cero, sin
tamaño
restricciones), '% f' (inserta un lua_Number ), '% I' (inserta unlua_Integer ), '% p' (inserta un puntero), '% d' (inserta
un
int), '% c' (inserta un int como un carácter de un byte) y '% U' (inserta un int largo como una secuencia de bytes UTF-
8).
Esta función puede generar errores debido a un desbordamiento de la memoria o un especificador de conversión no
válido.
lua_pushglobaltable
void lua_pushglobaltable (lua_State * L);
Empuja el entorno global a la pila.
lua_pushinteger
vacío lua_pushinteger (lua_State * L, lua_Integer n);
Inserta un número entero con valor n en la pila.
lua_pushlightuserdata
void lua_pushlightuserdata (lua_State * L, void * p);
Inserta datos de usuario ligeros en la pila.
Los datos de usuario representan valores C en Lua. Un usuario claro representa un puntero, un vacío *. Es un valor
(como un número):
no lo crea, no tiene metatabla individual y no se recopila (ya que nunca se creó). Una luz
userdata es igual a "cualquier" userdata ligero con la misma dirección C.
lua_pushliteral
const char * lua_pushliteral (lua_State * L, const char * s);
Esta macro es equivalente a lua_pushstring, pero debe usarse solo cuando s es una cadena literal. (Lua puede
optimizar este caso.)
lua_pushlstring
const char * lua_pushlstring (lua_State * L, const char * s, size_t len);
Empuja la cuerda señalada por s con el tamaño largo en la pila. Lua hará o reutilizará una copia interna del
una cadena dada, por lo que la memoria en s se puede liberar o reutilizar inmediatamente después de que la función
regrese. La cuerda puede
contener cualquier dato binario, incluidos los ceros incrustados.
Devuelve un puntero a la copia interna de la cadena (ver §4.1.3).
lua_pushnil
void lua_pushnil (lua_State * L);
Coloca un valor nulo en la pila.
lua_pushnumber
void lua_pushnumber (lua_State * L, lua_Number n);
Coloca un flotador con valor n en la pila.
lua_pushstring
const char * lua_pushstring (lua_State * L, const char * s);
Empuja la cadena terminada en cero señalada por s en la pila. Lua hará o reutilizará una copia interna del
una cadena dada, por lo que la memoria en s se puede liberar o reutilizar inmediatamente después de que la función
regrese.
Devuelve un puntero a la copia interna de la cadena (ver §4.1.3).
Si s es NULL, empuja nil y devuelve NULL.

Página 36
[-0, +1, -]
[-0, +1, -]
[-0, +1, v ]
[-0, +0, -]
[-1, +1, -]
[-0, +1, -]
[-0, +1, -]
[-0, +0, -]
[-2, +0, m ]
lua_pushthread
int lua_pushthread (lua_State * L);
Empuja el hilo representado por L en la pila. Devuelve 1 si este hilo es el hilo principal de su estado.
lua_pushvalue
void lua_pushvalue (lua_State * L, índice int);
Inserta una copia del elemento en el índice dado en la pila.
lua_pushvfstring
const char * lua_pushvfstring (lua_State * L,
const char * fmt,
va_list argp);
Equivalente a lua_pushfstring , excepto que recibe un va_list en lugar de un número variable de argumentos.
lua_rawequal
int lua_rawequal (lua_State * L, int index1, int index2);
Devuelve 1 si los dos valores de los índices index1 e index2 son primitivamente iguales (es decir, iguales sin llamar
al
__eq metamétodo). De lo contrario, devuelve 0. También devuelve 0 si alguno de los índices no es válido.
lua_rawget
int lua_rawget (lua_State * L, int índice);
Similar a lua_gettable , pero realiza un acceso sin formato (es decir, sin metamétodos).
lua_rawgeti
int lua_rawgeti (lua_State * L, int índice, lua_Integer n);
Coloca en la pila el valor t [n], donde t es la tabla en el índice dado. El acceso es crudo, es decir, no
no utilice el metavalor __index.
Devuelve el tipo de valor introducido.
lua_rawgetp
int lua_rawgetp (lua_State * L, int index, const void * p);
Coloca en la pila el valor t [k], donde t es la tabla en el índice dado y k es el puntero p representado
como datos de usuario ligeros. El acceso es crudo; es decir, no utiliza el metavalor __index.
Devuelve el tipo de valor introducido.
lua_rawlen
lua_Unsigned lua_rawlen (lua_State * L, índice int);
Devuelve la "longitud" sin procesar del valor en el índice dado: para cadenas, esta es la longitud de la cadena; para las
mesas, este es el
resultado del operador de longitud ('#') sin metamétodos; para datos de usuario, este es el tamaño del bloque de
memoria
asignado para los datos de usuario. Para otros valores, esta llamada devuelve 0.
lua_rawset
void lua_rawset (lua_State * L, índice int);
Similar a lua_settable , pero realiza una asignación en bruto (es decir, sin metamétodos).
lua_rawseti

Página 37
[-1, +0, m ]
[-1, +0, m ]
[-0, +0, e ]
[-1, +0, -]
[-1, +0, -]
[-0, + ?, -]
[- ?, + ?, -]
void lua_rawseti (lua_State * L, int index, lua_Integer i);
¿El equivalente de t [i] = v, donde t es la tabla en el índice dado y v es el valor en la parte superior de la
apilar.
Esta función saca el valor de la pila. La asignación es cruda, es decir, no usa el __newindex
metavalor.
lua_rawsetp
void lua_rawsetp (lua_State * L, int index, const void * p);
¿El equivalente de t [p] = v, donde t es la tabla en el índice dado, p se codifica como datos de usuario ligeros y v
es el valor en la parte superior de la pila.
Esta función saca el valor de la pila. La asignación es cruda, es decir, no usa el __newindex
metavalor.
lua_Reader
typedef const char * (* lua_Reader) (lua_State * L,
datos vacíos *,
size_t * tamaño);
La función de lectura utilizada por lua_load . Cada vezlua_load necesita otra parte del trozo, llama al
lector, transmitiendo su parámetro de datos. El lector debe devolver un puntero a un bloque de memoria con un nuevo
pedazo del trozo y establecer el tamaño al tamaño del bloque. El bloque debe existir hasta que se vuelva a llamar a la
función de lector.
Para señalar el final del fragmento, el lector debe devolver NULL o establecer el tamaño en cero. La función del
lector puede volver
piezas de cualquier tamaño superior a cero.
lua_register
void lua_register (lua_State * L, const char * nombre, lua_CFunction f);
Establece la función C f como el nuevo valor del nombre global. Se define como una macro:
#define lua_register (L, n, f) \
(lua_pushcfunción (L, f), lua_setglobal (L, n))
lua_remove
void lua_remove (lua_State * L, índice int);
Elimina el elemento en el índice válido dado, desplazando hacia abajo los elementos por encima de este índice para
llenar el vacío. Esta
La función no se puede llamar con un pseudo-índice, porque un pseudo-índice no es una posición de pila real.
lua_replace
void lua_replace (lua_State * L, índice int);
Mueve el elemento superior al índice válido dado sin cambiar ningún elemento (por lo tanto, reemplaza el valor en
ese
índice dado), y luego aparece el elemento superior.
lua_resetthread
int lua_resetthread (lua_State * L);
Reinicia un hilo, limpia su pila de llamadas y cierra todas las variables pendientes por cerrar. Devuelve un código de
estado:
LUA_OK para que no haya errores en los métodos de cierre o un estado de error de lo contrario. En caso de error,
deja el objeto de error en
la parte superior de la pila,
lua_resume
int lua_resume (lua_State * L, lua_State * desde, int nargs,
int * nresults);
Inicia y reanuda una corrutina en el hilo dado L.

Página 38
[-0, +0, -]
[-0, +0, -]
[-1, +0, e ]
[-1, +0, e ]
[-1, +0, e ]
[-1, +0, -]
[-1, +0, -]
Para iniciar una corrutina, inserta la función principal más cualquier argumento en la pila vacía del hilo. entonces tú
llamada lua_resume , siendo nargs el número de argumentos. Esta llamada regresa cuando la corrutina suspende o
termina su ejecución. Cuando regresa, * nresults se actualiza y la parte superior de la pila contiene * nresults
valores pasados a lua_yield o devuelto por la función body.devuelve lua_resumeLUA_YIELD si la corrutina
rendimientos LUA_OK si la corrutina finaliza su ejecución sin errores, o un código de error en caso de errores (ver
§4.4.1 ).
En caso de errores, el objeto de error está en la parte superior de la pila.
Para reanudar una corrutina, elimine los valores * nresults producidos de su pila, presione los valores que se pasarán
como resultado del rendimiento, y luego llame lua_resume .
El parámetro de representa la corrutina que está reanudando L. Si no existe tal corrutina, este parámetro puede
ser NULO.
lua_rotate
void lua_rotate (lua_State * L, int idx, int n);
Rota los elementos de la pila entre el idx de índice válido y la parte superior de la pila. Los elementos se giran n
posiciones en la dirección de la parte superior, para una n positiva, o -n posiciones en la dirección de la parte inferior,
para una n negativa.
El valor absoluto de n no debe ser mayor que el tamaño del corte que se está rotando. Esta función no se puede llamar
con un pseudo-índice, porque un pseudo-índice no es una posición de pila real.
lua_setallocf
void lua_setallocf (lua_State * L, lua_Alloc f, void * ud);
Cambia la función de asignación de un estado dado af con los datos de usuario ud.
lua_setfield
void lua_setfield (lua_State * L, int index, const char * k);
¿El equivalente a t [k] = v, donde t es el valor en el índice dado y v es el valor en la parte superior de la
apilar.
Esta función saca el valor de la pila. Como en Lua, esta función puede activar un metamétodo para el "índice nuevo"
evento (ver §2.4 ).
lua_setglobal
void lua_setglobal (lua_State * L, const char * nombre);
Saca un valor de la pila y lo establece como el nuevo valor del nombre global.
lua_seti
void lua_seti (lua_State * L, int index, lua_Integer n);
¿El equivalente a t [n] = v, donde t es el valor en el índice dado y v es el valor en la parte superior de la
apilar.
Esta función saca el valor de la pila. Como en Lua, esta función puede activar un metamétodo para el "índice nuevo"
evento (ver §2.4 ).
lua_setiuservalue
int lua_setiuservalue (lua_State * L, int índice, int n);
Extrae un valor de la pila y lo establece como el nuevo n-ésimo valor de usuario asociado a los datos de usuario
completos en el
índice. Devuelve 0 si los datos de usuario no tienen ese valor.
lua_setmetatable
int lua_setmetatable (lua_State * L, int índice);
Saca una tabla o nil de la pila y establece ese valor como la nueva metatabla para el valor en el índice dado. ( nulo
significa que no hay metatabla.)

Página 39
[-2, +0, e ]
[- ?, + ?, e ]
[-0, +0, -]
[-0, +0, -]
[-0, +1, -]
[-0, +0, -]
(Por razones históricas, esta función devuelve un int, que ahora es siempre 1.)
lua_settable
void lua_settable (lua_State * L, índice int);
¿Es equivalente a t [k] = v, donde t es el valor en el índice dado, v es el valor en la parte superior de la pila,
y k es el valor justo debajo de la parte superior.
Esta función saca tanto la clave como el valor de la pila. Como en Lua, esta función puede activar un metamétodo
para el evento "newindex" (ver §2.4 ).
lua_settop
void lua_settop (lua_State * L, índice int);
Acepta cualquier índice, o 0, y establece la parte superior de la pila en este índice. Si el techo nuevo es mayor que el
anterior, entonces el
los nuevos elementos se llenan de cero . Si el índice es 0, se eliminan todos los elementos de la pila.
Esta función puede ejecutar código arbitrario al eliminar un índice marcado como por cerrar de la pila.
lua_setwarnf
void lua_setwarnf (lua_State * L, lua_WarnFunction f, void * ud);
Establece la función de advertencia que utilizará Lua para emitir advertencias (consulte lua_WarnFunction ). Los
conjuntos de parámetros ud
el valor ud pasado a la función de advertencia.
lua_State
typedef struct lua_State lua_State;
Una estructura opaca que apunta a un hilo e indirectamente (a través del hilo) a todo el estado de un Lua
Interprete. La biblioteca Lua es completamente reentrante: no tiene variables globales. Toda la información sobre un
estado es accesible
a través de esta estructura.
Se debe pasar un puntero a esta estructura como primer argumento a cada función de la biblioteca, excepto a
lua_newstate, que crea un estado Lua desde cero.
lua_status
int lua_status (lua_State * L);
Devuelve el estado del hilo L.
El estado puede ser LUA_OK para un hilo normal, un código de error si el hilo terminó la ejecución de un
lua_resume con un error, oLUA_YIELD si el hilo está suspendido.
Puede llamar a funciones solo en subprocesos con estado LUA_OK . Puede reanudar hilos con estadoLUA_OK (para
iniciar una
nueva corrutina) o LUA_YIELD (para reanudar una corrutina).
lua_stringtonumber
size_t lua_stringtonumber (lua_State * L, const char * s);
Convierte la cadena s terminada en cero en un número, inserta ese número en la pila y devuelve el tamaño total
de la cuerda, es decir, su longitud más uno. La conversión puede resultar en un número entero o flotante, según el
léxico
convenciones de Lua (ver §3.1 ). La cadena puede tener espacios en blanco iniciales y finales y un signo. Si la cuerda
no es
un número válido, devuelve 0 y no inserta nada. (Tenga en cuenta que el resultado se puede usar como booleano,
verdadero si el
la conversión se realiza correctamente.)
lua_toboolean
int lua_toboolean (lua_State * L, int índice);
Convierte el valor Lua en el índice dado en un valor booleano C (0 o 1). Como todas las pruebas en
Lua,lua_toboolean
devuelve verdadero para cualquier valor de Lua diferente de falso y nulo ; de lo contrario, devuelve falso. (Si quieres
aceptar solo

Página 40
[-0, +0, -]
[-0, +0, m ]
[-0, +0, -]
[-0, +0, -]
[-0, +0, m ]
[-0, +0, -]
[-0, +0, -]
valores booleanos reales, use lua_isboolean para probar el tipo del valor).
lua_tocfunction
lua_CFunction lua_tocfunction (lua_State * L, int índice);
Convierte un valor en el índice dado en una función C. Ese valor debe ser una función C; de lo contrario, devuelve
NULL.
lua_toclose
void lua_toclose (lua_State * L, índice int);
Marca el índice dado en la pila como una "variable" por cerrar (ver §3.3.8 ). Como una variable por cerrar en Lua,
el valor en ese índice en la pila se cerrará cuando salga del alcance. Aquí, en el contexto de una función C,
salir del alcance significa que la función en ejecución vuelve a Lua, hay un error o el índice se elimina de
la pila a través lua_settop olua_pop . Un índice marcado como por cerrar no debe eliminarse del
apilar por cualquier otra función en la API excepto lua_settop olua_pop .
Esta función no debe invocarse para un índice que sea igual o inferior a un índice activo por cerrar.
En el caso de un error de memoria insuficiente, el valor en el índice dado se cierra inmediatamente, como si ya
estuviera
marcado.
Tenga en cuenta que, tanto en caso de errores como de una devolución regular, cuando se ejecuta el metamétodo
__close, la pila C
ya se desenrolló, por lo que cualquier variable C automática declarada en la función de llamada estará fuera de
alcance.
lua_tointeger
lua_Integer lua_tointeger (lua_State * L, índice int);
Equivalente a lua_tointegerx con isnum igual a NULL.
lua_tointegerx
lua_Integer lua_tointegerx (lua_State * L, int index, int * isnum);
Convierte el valor Lua en el índice dado al tipo integral con signo lua_Integer . El valor de Lua debe ser un
entero, o un número o cadena convertible en un entero (ver §3.4.3 ); de lo contrario, lua_tointegerx devuelve 0.
Si isnum no es NULL, a su referente se le asigna un valor booleano que indica si la operación tuvo éxito.
lua_tolstring
const char * lua_tolstring (lua_State * L, int index, size_t * len);
Convierte el valor Lua en el índice dado en una cadena C. Si len no es NULL, establece * len con la longitud de la
cadena. los
El valor de Lua debe ser una cadena o un número; de lo contrario, la función devuelve NULL. Si el valor es un
número, entonces
lua_tolstring también cambia el valor real en la pila a una cadena . (Este cambio confundelua_next cuando
lua_tolstring se aplica a las claves durante un recorrido de tabla).
lua_tolstring devuelve un puntero a una cadena dentro del estado Lua (consulte §4.1.3 ). Esta cadena siempre tiene un
cero
('\ 0') después de su último carácter (como en C), pero puede contener otros ceros en su cuerpo.
lua_tonumber
lua_Number lua_tonumber (lua_State * L, índice int);
Equivalente a lua_tonumberx con isnum igual a NULL.
lua_tonumberx
lua_Number lua_tonumberx (lua_State * L, int index, int * isnum);
Convierte el valor Lua en el índice dado al tipo C lua_Number (verlua_Number ). El valor de Lua debe ser
un número o una cadena convertible en un número (ver §3.4.3 ); de lo contrario,lua_tonumberx devuelve 0.
Si isnum no es NULL, a su referente se le asigna un valor booleano que indica si la operación tuvo éxito.

Página 41
[-0, +0, -]
[-0, +0, m ]
[-0, +0, -]
[-0, +0, -]
[-0, +0, -]
[-0, +0, -]
[-0, +0, -]
[-0, +0, -]
lua_topointer
const void * lua_topointer (lua_State * L, int índice);
Convierte el valor en el índice dado en un puntero C genérico (void *). El valor puede ser un dato de usuario, una
tabla, un
hilo, una cadena o una función; de lo contrario, lua_topointer devuelve NULL. Diferentes objetos darán diferentes
punteros. No hay forma de volver a convertir el puntero a su valor original.
Por lo general, esta función se usa solo para hash y depuración de información.
lua_tostring
const char * lua_tostring (lua_State * L, índice int);
Equivalente a lua_tolstring con len igual a NULL.
lua_tothread
lua_State * lua_tothread (lua_State * L, índice int);
Convierte el valor en el índice dado en un hilo Lua (representado como lua_State *). Este valor debe ser un
hilo; de lo contrario, la función devuelve NULL.
lua_touserdata
void * lua_touserdata (lua_State * L, int índice);
Si el valor en el índice dado es un dato de usuario completo, devuelve su dirección de bloque de memoria. Si el valor
es un dato de usuario ligero,
devuelve su valor (un puntero). De lo contrario, devuelve NULL.
lua_type
int lua_type (lua_State * L, int índice);
Devuelve el tipo de valor en el índice válido dado, o LUA_TNONE para un índice no válido pero aceptable. los
tipos devueltos por lua_type están codificados por las siguientes constantes definidas en lua.h: LUA_TNIL,
LUA_TNUMBER,
LUA_TBOOLEAN, LUA_TSTRING, LUA_TTABLE, LUA_TFUNCTION, LUA_TUSERDATA,
LUA_TTHREAD y
LUA_TLIGHTUSERDATA.
lua_typename
const char * lua_typename (lua_State * L, int tp);
Devuelve el nombre del tipo codificado por el valor tp, que debe ser uno de los valores devueltos por lua_type .
lua_Unsigned
typedef ... lua_Unsigned;
La versión sin firmar de lua_Integer .
lua_upvalueindex
int lua_upvalueindex (int i);
Devuelve el pseudoíndice que representa el i-ésimo valor ascendente de la función en ejecución (consulte §4.2 ). debo
estar en el
rango [1.256] .
lua_version
lua_Number lua_version (lua_State * L);
Devuelve el número de versión de este núcleo.
lua_WarnFunction
typedef void (* lua_WarnFunction) (void * ud, const char * msg, int tocont);

Página 42
[-0, +0, -]
[- ?, + ?, -]
[- ?, + ?, v ]
[- ?, + ?, v ]
El tipo de funciones de advertencia, llamadas por Lua para emitir advertencias. El primer parámetro es un puntero
opaco establecido por
lua_setwarnf. El segundo parámetro es el mensaje de advertencia. El tercer parámetro es un booleano que indica
si el mensaje debe continuar con el mensaje en la próxima llamada.
Consulte advertir para obtener más detalles sobre las advertencias.
lua_warning
void lua_warning (lua_State * L, const char * msg, int tocont);
Emite una advertencia con el mensaje dado. Un mensaje en una llamada con tocont true debe continuar en otra
llamar a esta función.
Consulte advertir para obtener más detalles sobre las advertencias.
lua_Writer
typedef int (* lua_Writer) (lua_State * L,
const void * p,
size_t sz,
void * ud);
El tipo de función de escritura utilizada por lua_dump . Cada vezlua_dump produce otro trozo de trozo,
llama al escritor, pasando el búfer a escribir (p), su tamaño (sz) y el parámetro ud proporcionado a
lua_dump .
El escritor devuelve un código de error: 0 significa que no hay errores; cualquier otro valor significa un error y se
detienelua_dump de
llamando al escritor de nuevo.
lua_xmove
void lua_xmove (lua_State * desde, lua_State * hasta, int n);
Intercambiar valores entre diferentes hilos del mismo estado.
Esta función extrae n valores de la pila de y los empuja a la pila de.
lua_yield
int lua_yield (lua_State * L, int nresults);
Esta función es equivalente a lua_yieldk , pero no tiene continuación (ver §4.5 ). Por tanto, cuando el hilo
se reanuda, continúa la función que llamó a la función que llama a lua_yield. Para evitar sorpresas, esta función
solo debe llamarse en una llamada de cola.
lua_yieldk
int lua_yieldk (lua_State * L,
int nresults,
lua_KContext ctx,
lua_KFunction k);
Produce una corrutina (hilo).
Cuando una función C llama lua_yieldk , la corrutina en ejecución suspende su ejecución y la llamada a lua_resume
que inició esta corrutina regresa. El parámetro nresults es el número de valores de la pila que se
pasado como resultados a lua_resume .
Cuando la corrutina se reanuda de nuevo, Lua llama a la función de continuación dada k para continuar la ejecución
de la
Función C que produjo (ver §4.5 ). Esta función de continuación recibe la misma pila de la función anterior,
con los n resultados eliminados y reemplazados por los argumentos pasados a lua_resume . Además, la continuación
la función recibe el valor ctx que se pasó a lua_yieldk .
Generalmente, esta función no regresa; cuando la corrutina finalmente se reanuda, continúa ejecutando el
función de continuación. Sin embargo, hay un caso especial, que es cuando esta función se llama desde dentro de una
línea o
un gancho de conteo (ver §4.7 ). En ese caso, se debería llamar a lua_yieldk sin continuación (probablemente en
forma de
lua_yield ) y no hay resultados, y el gancho debería regresar inmediatamente después de la llamada. Lua cederá y,
cuando el

Página 43
La corrutina se reanuda de nuevo, continuará la ejecución normal de la función (Lua) que activó el gancho.
Esta función puede generar un error si se llama desde un hilo con una llamada C pendiente sin función de
continuación (lo que
se llama un límite de llamada C ), o se llama desde un hilo que no se ejecuta dentro de un currículum (normalmente
el
hilo).
4.7 - La interfaz de depuración
Lua no tiene funciones de depuración integradas. En cambio, ofrece una interfaz especial mediante funciones y
ganchos . Esta
La interfaz permite la construcción de diferentes tipos de depuradores, perfiladores y otras herramientas que necesitan
"dentro
información "del intérprete.
lua_Debug
typedef struct lua_Debug {
int evento;
const char * nombre;
/ * (n) * /
const char * namewhat; / * (n) * /
const char * qué;
/* (S) */
const char * fuente;
/* (S) */
size_t srclen;
/* (S) */
int currentline;
/ * (l) * /
int linedefined;
/* (S) */
int lastlinedefined;
/* (S) */
char nups sin firmar;
/ * (u) número de upvalues * /
char nparams sin firmar; / * (u) número de parámetros * /
char isvararg;
/ * (u) * /
char istailcall;
/ * (t) * /
transferencia corta sin firmar; / * (r) índice del primer valor transferido * /
ntransfer corto sin firmar; / * (r) número de valores transferidos * /
char short_src [LUA_IDSIZE]; /* (S) */
/* parte privada */
otros campos
} lua_Debug;
Una estructura que se utiliza para transportar diferentes piezas de información sobre una función o un registro de
activación. lua_getstack
llena solo la parte privada de esta estructura, para uso posterior. Para llenar los otros campos de lua_Debug con útiles
información, debes llamar lua_getinfo .
Los campos de lua_Debug tiene el siguiente significado:
fuente: la fuente del fragmento que creó la función. Si la fuente comienza con una '@', significa que la
La función se definió en un archivo donde el nombre del archivo sigue a la '@'. Si la fuente comienza con un '=', el
resto de
su contenido describe la fuente de una manera dependiente del usuario. De lo contrario, la función se definió en un
cadena donde la fuente es esa cadena.
srclen: la longitud de la fuente de la cadena.
short_src: una versión "imprimible" de la fuente, que se utilizará en mensajes de error.
linedefined: el número de línea donde comienza la definición de la función.
lastlinedefined: el número de línea donde termina la definición de la función.
qué: la cadena "Lua" si la función es una función Lua, "C" si es una función C, "principal" si es la parte principal
de un trozo.
currentline: la línea actual donde se está ejecutando la función dada. Cuando no hay información de línea disponible,
currentline se establece en -1.
nombre: un nombre razonable para la función dada. Debido a que las funciones en Lua son valores de primera clase,
no
tener un nombre fijo: algunas funciones pueden ser el valor de múltiples variables globales, mientras que otras se
pueden almacenar
solo en un campo de tabla. La función lua_getinfo comprueba cómo se llamó a la función para encontrar un nombre
adecuado.
Si no puede encontrar un nombre, el nombre se establece en NULL.
namewhat: explica el campo de nombre. El valor de namewhat puede ser "global", "local", "method",
"campo", "upvalue" o "" (la cadena vacía), según cómo se haya llamado a la función. (Lua usa el
cadena vacía cuando no parece aplicarse ninguna otra opción).
istailcall: verdadero si esta invocación de función fue llamada por una llamada de cola. En este caso, la persona que
llama de este nivel es
no en la pila.
nup: el número de upvalues de la función.
nparams: el número de parámetros de la función (siempre 0 para funciones C).

Página 44
[-0, +0, -]
[-0, +0, -]
[-0, +0, -]
[- (0 | 1), + (0 | 1 | 2), m ]
[-0, + (0 | 1), -]
isvararg: verdadero si la función es una función vararg (siempre verdadero para funciones C).
ftransfer: el índice en la pila del primer valor que se "transfiere", es decir, los parámetros en una llamada o retorno
valores en una devolución. (Los otros valores están en índices consecutivos). Con este índice, puede acceder y
modificar estos valores mediante lua_getlocal ylua_setlocal . Este campo solo es significativo durante una llamada
gancho, que indica el primer parámetro, o un gancho de retorno, que indica el primer valor que se devuelve. (Para
ganchos de llamada,
este valor es siempre 1.)
ntransfer: El número de valores que se transfieren (ver elemento anterior). (Para llamadas de funciones Lua, este
el valor es siempre igual a nparams.)
lua_gethook
lua_Hook lua_gethook (lua_State * L);
Devuelve la función de gancho actual.
lua_gethookcount
int lua_gethookcount (lua_State * L);
Devuelve el recuento de ganchos actual.
lua_gethookmask
int lua_gethookmask (lua_State * L);
Devuelve la máscara de gancho actual.
lua_getinfo
int lua_getinfo (lua_State * L, const char * qué, lua_Debug * ar);
Obtiene información sobre una función específica o la invocación de una función.
Para obtener información sobre la invocación de una función, el parámetro ar debe ser un registro de activación
válido que se completó
por una llamada previa a lua_getstack o dado como argumento a un gancho (ver lua_Hook ).
Para obtener información sobre una función, la empuja a la pila y comienza la cadena what con el carácter '>'. (En
ese caso, lua_getinfo saca la función de la parte superior de la pila). Por ejemplo, para saber en qué línea
se definió la función f, puede escribir el siguiente código:
lua_Debug ar;
lua_getglobal (L, "f"); / * obtener global 'f' * /
lua_getinfo (L, "> S", & ar);
printf ("% d \ n", ar.linedefined);
Cada carácter de la cadena, lo que selecciona algunos campos de la estructura, es para ser llenado o un valor para ser
empujado.
la pila:
'n': completa el nombre del campo y nombra qué;
'S': completa los campos fuente, short_src, linedefined, lastlinedefined y qué;
'l': completa el campo currentline;
't': completa el campo istailcall;
'u': completa los campos nups, nparams e isvararg;
'f': coloca en la pila la función que se está ejecutando en el nivel dado;
'L': coloca en la pila una tabla cuyos índices son los números de las líneas válidas en la función.
(Una línea válida es una línea con algún código asociado, es decir, una línea en la que puede poner un punto de
interrupción. No válido
las líneas incluyen líneas vacías y comentarios).
Si esta opción se da junto con la opción 'f', su tabla se inserta después de la función.
Esta es la única opción que puede generar un error de memoria.
Esta función devuelve 0 para señalar una opción no válida en qué; incluso entonces las opciones válidas se manejan
correctamente.
lua_getlocal
const char * lua_getlocal (lua_State * L, const lua_Debug * ar, int n);

Página 45
[-0, +0, -]
[-0, + (0 | 1), -]
[-0, +0, -]
Obtiene información sobre una variable local o un valor temporal de un registro de activación determinado o una
función determinada.
En el primer caso, el parámetro ar debe ser un registro de activación válido que fue llenado por una llamada anterior a
lua_getstack o dado como argumento a un gancho (ver lua_Hook ). El índice n selecciona qué variable local
inspeccionar; verdebug.getlocal para obtener detalles sobre índices y nombres de variables.
lua_getlocal inserta el valor de la variable en la pila y devuelve su nombre.
En el segundo caso, ar debe ser NULL y la función a inspeccionar debe estar en la parte superior de la pila. En esto
caso, solo los parámetros de las funciones Lua son visibles (ya que no hay información sobre qué variables están
activas) y
no se introducen valores en la pila.
Devuelve NULL (y no inserta nada) cuando el índice es mayor que el número de variables locales activas.
lua_getstack
int lua_getstack (lua_State * L, nivel int, lua_Debug * ar);
Obtiene información sobre la pila de tiempo de ejecución del intérprete.
Esta función llena partes de un lua_Debug estructura con una identificación del registro de activación de la función
ejecutando a un nivel dado. El nivel 0 es la función en ejecución actual, mientras que el nivel n + 1 es la función que
ha llamado
nivel n (excepto para las llamadas de cola, que no cuentan en la pila). Cuando se llama con un nivel mayor que la pila
profundidad, lua_getstack devuelve 0; de lo contrario, devuelve 1.
lua_getupvalue
const char * lua_getupvalue (lua_State * L, int funcindex, int n);
Obtiene información sobre el enésimo valor de subida del cierre en el índice funcindex. Empuja el valor del upvalue a
la pila y devuelve su nombre. Devuelve NULL (y no inserta nada) cuando el índice n es mayor que el número
de upvalues.
Consulte debug.getupvalue para obtener más información sobre upvalues.
lua_Hook
typedef void (* lua_Hook) (lua_State * L, lua_Debug * ar);
Escriba para depurar funciones de enlace.
Siempre que se llama a un gancho, su argumento ar tiene su evento de campo establecido en el evento específico que
desencadenó el gancho.
Lua identifica estos eventos con las siguientes constantes: LUA_HOOKCALL, LUA_HOOKRET,
LUA_HOOKTAILCALL,
LUA_HOOKLINE y LUA_HOOKCOUNT. Además, para eventos de línea, también se establece el campo
currentline. Para obtener el
valor de cualquier otro campo en ar, el gancho debe llamar a lua_getinfo .
Para eventos de llamada, el evento puede ser LUA_HOOKCALL, el valor normal, o LUA_HOOKTAILCALL, para
una llamada de cola; en esto
caso, no habrá evento de devolución correspondiente.
Mientras Lua ejecuta un gancho, deshabilita otras llamadas a los ganchos. Por lo tanto, si un gancho vuelve a llamar a
Lua para ejecutar un
función o un fragmento, esta ejecución se produce sin ninguna llamada a los ganchos.
Las funciones de gancho no pueden tener continuaciones, es decir, no pueden llamar lua_yieldk , lua_pcallk
olua_callk
con una k no nula.
Las funciones de gancho pueden ceder en las siguientes condiciones: Solo pueden ceder los eventos de recuento y
línea; ceder, un gancho
la función debe terminar su ejecución llamando lua_yield con nresults iguales a cero (es decir, sin valores).
lua_sethook
void lua_sethook (lua_State * L, lua_Hook f, int mask, int count);
Establece la función de enlace de depuración.
El argumento f es la función de gancho. máscara especifica en qué eventos se llamará el gancho: está formado por un
bit a bit
O de las constantes LUA_MASKCALL, LUA_MASKRET, LUA_MASKLINE y LUA_MASKCOUNT. La cuenta
El argumento solo es significativo cuando la máscara incluye LUA_MASKCOUNT. Para cada evento, el gancho se
llama como

Página 46
[- (0 | 1), +0, -]
[- (0 | 1), +0, -]
[-0, +0, -]
[-0, +0, -]
explicado a continuación:
El gancho de llamada: se llama cuando el intérprete llama a una función. El gancho se llama justo después de que
Lua entra en el
nueva función.
El gancho de retorno: se llama cuando el intérprete regresa de una función. El gancho se llama justo antes de Lua.
deja la función.
El gancho de línea: se llama cuando el intérprete está a punto de iniciar la ejecución de una nueva línea de código, o
cuando
salta hacia atrás en el código (incluso a la misma línea). Este evento solo ocurre mientras Lua está ejecutando un Lua
función.
El gancho de recuento: se llama después de que el intérprete ejecuta todas las instrucciones de recuento. Este evento
solo ocurre
mientras Lua está ejecutando una función Lua.
Los ganchos se desactivan poniendo la máscara a cero.
lua_setlocal
const char * lua_setlocal (lua_State * L, const lua_Debug * ar, int n);
Establece el valor de una variable local de un registro de activación dado. Asigna el valor en la parte superior de la
pila al
variable y devuelve su nombre. También saca el valor de la pila.
Devuelve NULL (y no muestra nada) cuando el índice es mayor que el número de variables locales activas.
Los parámetros ar y n son como en la función lua_getlocal .
lua_setupvalue
const char * lua_setupvalue (lua_State * L, int funcindex, int n);
Establece el valor del upvalue de un cierre. Asigna el valor en la parte superior de la pila al upvalue y devuelve su
nombre. También saca el valor de la pila.
Devuelve NULL (y no muestra nada) cuando el índice n es mayor que el número de upvalues.
Los parámetros funcindex yn son como en la función lua_getupvalue .
lua_upvalueid
void * lua_upvalueid (lua_State * L, int funcindex, int n);
Devuelve un identificador único para el upvalue numerado n del cierre en index funcindex.
Estos identificadores únicos permiten que un programa verifique si diferentes cierres comparten valores positivos.
Lua cierra que
compartir un upvalue (es decir, que acceda a una misma variable local externa) devolverá identificadores idénticos
para esos upvalue
índices.
Los parámetros funcindex yn son como en la función lua_getupvalue , pero n no puede ser mayor que el número
de upvalues.
lua_upvaluejoin
void lua_upvaluejoin (lua_State * L, int funcindex1, int n1,
int funcindex2, int n2);
Haga que el n1-ésimo valor al alza del cierre Lua en el índice funcindex1 se refiera al n2-ésimo valor al alza del
cierre Lua en
funcindex2 del índice.

5 - La biblioteca auxiliar
La biblioteca auxiliar proporciona varias funciones convenientes para conectar C con Lua. Mientras que la API
básica proporciona
las funciones primitivas para todas las interacciones entre C y Lua, la biblioteca auxiliar proporciona funciones de
nivel superior
para algunas tareas comunes.
Todas las funciones y tipos de la biblioteca auxiliar se definen en el archivo de encabezado lauxlib.hy tienen el
prefijo luaL_.
Todas las funciones de la biblioteca auxiliar se construyen sobre la API básica, por lo que no proporcionan nada que
no se pueda

Página 47
[- ?, + ?, m ]
[-0, +0, m ]
[- ?, + ?, m ]
[- ?, + ?, -]
[- ?, + ?, m ]
[-1, + ?, m ]
[-0, +0, v ]
hecho con esa API. Sin embargo, el uso de la biblioteca auxiliar asegura una mayor coherencia a su código.
Varias funciones de la biblioteca auxiliar utilizan internamente algunas ranuras de pila adicionales. Cuando una
función en el auxiliar
la biblioteca usa menos de cinco ranuras, no verifica el tamaño de la pila; simplemente asume que hay suficientes
ranuras.
Varias funciones de la biblioteca auxiliar se utilizan para comprobar los argumentos de la función C. Porque el
mensaje de error es
formateado para argumentos (por ejemplo, "argumento incorrecto # 1"), no debe utilizar estas funciones para otros
valores de pila.
Las funciones llamadas luaL_check * siempre generan un error si la verificación no se cumple.
5.1 - Funciones y tipos
Aquí enumeramos todas las funciones y tipos de la biblioteca auxiliar en orden alfabético.
luaL_addchar
void luaL_addchar (luaL_Buffer * B, char c);
Agrega el byte c al búfer B (ver luaL_Buffer ).
luaL_addgsub
const void luaL_addgsub (luaL_Buffer * B, const char * s,
const char * p, const char * r);
Agrega una copia de la cadena s al búfer B (ver luaL_Buffer ), reemplazando cualquier ocurrencia de la cadena p con
la
cadena r.
luaL_addlstring
void luaL_addlstring (luaL_Buffer * B, const char * s, size_t l);
Agrega la cadena apuntada por s con longitud l al búfer B (ver luaL_Buffer ). La cadena puede contener
ceros incrustados.
luaL_addsize
void luaL_addsize (luaL_Buffer * B, tamaño_t n);
Agrega al búfer B una cadena de longitud n previamente copiada al área del búfer (ver luaL_prepbuffer ).
luaL_addstring
void luaL_addstring (luaL_Buffer * B, const char * s);
Agrega la cadena terminada en cero apuntada por s al búfer B (ver luaL_Buffer ).
luaL_addvalue
void luaL_addvalue (luaL_Buffer * B);
Agrega el valor en la parte superior de la pila al búfer B (ver luaL_Buffer ). Destaca el valor.
Esta es la única función en los búferes de cadena que se puede (y debe) llamarse con un elemento adicional en la pila,
que
es el valor que se agregará al búfer.
luaL_argcheck
void luaL_argcheck (lua_State * L,
int cond,
int arg,
const char * extramsg);
Comprueba si cond es verdadera. Si no es así, genera un error con un mensaje estándar (ver luaL_argerror ).
luaL_argerror

Página 48
[-0, +0, v ]
[-0, +0, v ]
[-0, +0, -]
[-0, +0, -]
[-0, +0, -]
int luaL_argerror (lua_State * L, int arg, const char * extramsg);
Genera un error al informar un problema con el argumento arg de la función C que lo llamó, usando un mensaje
estándar
que incluye extramsg como comentario:
mal argumento # arg para ' funcname ' ( extramsg )
Esta función nunca regresa.
luaL_argexpected
void luaL_argexpected (lua_State * L,
int cond,
int arg,
const char * tname);
Comprueba si cond es verdadera. Si no es así, genera un error sobre el tipo de argumento arg con un estándar
mensaje (ver luaL_typeerror ).
luaL_Buffer
typedef struct luaL_Buffer luaL_Buffer;
Escriba para un búfer de cadena .
Un búfer de cadenas permite que el código C construya cadenas de Lua por partes. Su patrón de uso es el siguiente:
Primero declare una variable b de tipo luaL_Buffer .
Luego inicialícelo con una llamada luaL_buffinit (L, & b).
Luego agregue piezas de cadena al búfer llamando a cualquiera de las funciones luaL_add *.
Termine llamando a luaL_pushresult (& b). Esta llamada deja la cadena final en la parte superior de la pila.
Si conoce de antemano el tamaño máximo de la cadena resultante, puede usar el búfer de esta manera:
Primero declare una variable b de tipo luaL_Buffer .
Luego, inicialícelo y preasigne un espacio de tamaño sz con una llamada luaL_buffinitsize (L, & b, sz).
Luego produzca la cuerda en ese espacio.
Termine llamando a luaL_pushresultsize (& b, sz), donde sz es el tamaño total de la cadena resultante
copiado en ese espacio (que puede ser menor o igual que el tamaño preasignado).
Durante su funcionamiento normal, un búfer de cadena utiliza un número variable de ranuras de pila. Entonces,
mientras usa un búfer,
No puede asumir que sabe dónde está la parte superior de la pila. Puede utilizar la pila entre llamadas sucesivas a
operaciones de búfer siempre que ese uso sea equilibrado; es decir, cuando llama a una operación de búfer, la pila
está en el
mismo nivel que estaba inmediatamente después de la operación de búfer anterior. (La única excepción a esta regla es
luaL_addvalue.) Después de llamar a luaL_pushresult , la pila vuelve a su nivel cuando se inicializó el búfer,
más la cuerda final en su parte superior.
luaL_buffaddr
char * luaL_buffaddr (luaL_Buffer * B);
Devuelve la dirección del contenido actual del búfer B (ver luaL_Buffer ). Tenga en cuenta que cualquier adición al
búfer
puede invalidar esta dirección.
luaL_buffinit
void luaL_buffinit (lua_State * L, luaL_Buffer * B);
Inicializa un búfer B (ver luaL_Buffer ). Esta función no asigna ningún espacio; el búfer debe ser declarado
como variable.
luaL_bufflen
size_t luaL_bufflen (luaL_Buffer * B);
Devuelve la longitud del contenido actual del búfer B (ver luaL_Buffer ).

Página 49
[- ?, + ?, m ]
[-0, +0, -]
[-0, + (0 | 1), e ]
[-0, +0, v ]
[-0, +0, v ]
[-0, +0, v ]
[-0, +0, v ]
[-0, +0, v ]
luaL_buffinitsize
char * luaL_buffinitsize (lua_State * L, luaL_Buffer * B, tamaño_t sz);
Equivalente a la secuencia luaL_buffinit ,luaL_prepbuffsize .
luaL_buffsub
void luaL_buffsub (luaL_Buffer * B, int n);
Elimina n bytes del búfer B (ver luaL_Buffer ). El búfer debe tener al menos esa cantidad de bytes.
luaL_callmeta
int luaL_callmeta (lua_State * L, int obj, const char * e);
Llama a un metamétodo.
Si el objeto en el índice obj tiene una metatabla y esta metatabla tiene un campo e, esta función llama a este campo
pasando el
objeto como su único argumento. En este caso, esta función devuelve verdadero y coloca en la pila el valor devuelto
por
la llamada. Si no hay metatabla o metamétodo, esta función devuelve falso sin presionar ningún valor en el
apilar.
luaL_checkany
void luaL_checkany (lua_State * L, int arg);
Comprueba si la función tiene un argumento de cualquier tipo (incluido nil ) en la posición arg.
luaL_checkinteger
lua_Integer luaL_checkinteger (lua_State * L, int arg);
Comprueba si el argumento de la función arg es un número entero (o puede convertirse en un número entero) y
devuelve este
entero.
luaL_checklstring
const char * luaL_checklstring (lua_State * L, int arg, size_t * l);
Comprueba si el argumento de la función arg es una cadena y devuelve esta cadena; si l no es NULL llena su
referente con
la longitud de la cuerda.
Esta función utiliza lua_tolstring para obtener su resultado, por lo que todas las conversiones y advertencias de esa
función se aplican aquí.
luaL_checknumber
lua_Number luaL_checknumber (lua_State * L, int arg);
Comprueba si el argumento de la función arg es un número y devuelve este número convertido a lua_Number.
luaL_checkoption
int luaL_checkoption (lua_State * L,
int arg,
const char * def,
const char * const lst []);
Comprueba si el argumento de la función arg es una cadena y busca esta cadena en la matriz lst (que debe ser
Terminado en NULL). Devuelve el índice de la matriz donde se encontró la cadena. Genera un error si el argumento
es
no es una cadena o si la cadena no se puede encontrar.
Si def no es NULL, la función usa def como valor predeterminado cuando no hay argumento arg o cuando este
el argumento es nulo .
Esta es una función útil para mapear cadenas a C enums. (La convención habitual en las bibliotecas de Lua es usar
cadenas
en lugar de números para seleccionar opciones).

Página 50
[-0, +0, v ]
[-0, +0, v ]
[-0, +0, v ]
[-0, +0, v ]
[-0, +0, v ]
[-0, + ?, m ]
[-0, + ?, -]
[-0, +0, v ]
[-0, +3, m ]
luaL_checkstack
void luaL_checkstack (lua_State * L, int sz, const char * msg);
Aumenta el tamaño de la pila hasta los elementos top + sz, lo que genera un error si la pila no puede crecer hasta ese
tamaño. msg es un
texto adicional para entrar en el mensaje de error (o NULL si no hay texto adicional).
luaL_checkstring
const char * luaL_checkstring (lua_State * L, int arg);
Comprueba si el argumento de la función arg es una cadena y devuelve esta cadena.
Esta función utiliza lua_tolstring para obtener su resultado, por lo que todas las conversiones y advertencias de esa
función se aplican aquí.
luaL_checktype
void luaL_checktype (lua_State * L, int arg, int t);
Comprueba si el argumento de la función arg tiene el tipo t. Verlua_type para la codificación de tipos para t.
luaL_checkudata
void * luaL_checkudata (lua_State * L, int arg, const char * tname);
Comprueba si el argumento de la función arg es un dato de usuario del tipo tname (ver luaL_newmetatable ) y
devuelve la dirección del bloque de memoria de los datos de usuario (ver lua_touserdata).
luaL_checkversion
void luaL_checkversion (lua_State * L);
Comprueba si el código que realiza la llamada y la biblioteca Lua a la que se llama utilizan la misma versión de Lua y
los mismos tipos numéricos.
luaL_dofile
int luaL_dofile (lua_State * L, const char * nombre de archivo);
Carga y ejecuta el archivo dado. Se define como la siguiente macro:
(luaL_loadfile (L, nombre de archivo) || lua_pcall (L, 0, LUA_MULTRET, 0))
Vuelve LUA_OK si no hay errores, o un código de error en caso de errores (ver §4.4.1 ).
luaL_dostring
int luaL_dostring (lua_State * L, const char * str);
Carga y ejecuta la cadena dada. Se define como la siguiente macro:
(luaL_loadstring (L, str) || lua_pcall (L, 0, LUA_MULTRET, 0))
Vuelve LUA_OK si no hay errores, o un código de error en caso de errores (ver §4.4.1 ).
luaL_error
int luaL_error (lua_State * L, const char * fmt, ...);
Genera un error. El formato del mensaje de error viene dado por fmt más cualquier argumento adicional, siguiendo
las mismas reglas de
lua_pushfstring. También agrega al comienzo del mensaje el nombre del archivo y el número de línea donde
Ocurrió un error, si esta información está disponible.
Esta función nunca regresa, pero es un modismo usarla en funciones C como return luaL_error ( args ).
luaL_execresult
int luaL_execresult (lua_State * L, int stat);

Página 51
[-0, + (1 | 3), m ]
[-0, + (0 | 1), m ]
[-0, +1, m ]
[-0, +1, e ]
[-0, +1, m ]
[-0, +0, e ]
[-0, +1, -]
[-0, +1, -]
Esta función produce los valores de retorno para funciones relacionadas con el proceso en la biblioteca estándar
(os.execute y
io.close ).
luaL_fileresult
int luaL_fileresult (lua_State * L, int stat, const char * fname);
Esta función produce los valores de retorno para funciones relacionadas con archivos en la biblioteca estándar
(io.open , os.rename ,
archivo: buscar , etc.).
luaL_getmetafield
int luaL_getmetafield (lua_State * L, int obj, const char * e);
Inserta en la pila el campo e de la metatabla del objeto en el índice obj y devuelve el tipo de empujado
valor. Si el objeto no tiene una metatabla, o si la metatabla no tiene este campo, no empuja nada y
devuelve LUA_TNIL.
luaL_getmetatable
int luaL_getmetatable (lua_State * L, const char * tname);
Inserta en la pila la metatabla asociada con el nombre tname en el registro (ver
luaL_newmetatable ), o nil si no hay una metatabla asociada con ese nombre. Devuelve el tipo de empujado
valor.
luaL_getsubtable
int luaL_getsubtable (lua_State * L, int idx, const char * fname);
Asegura que el valor t [fname], donde t es el valor en el índice idx, es una tabla, y empuja esa tabla a la
apilar. Devuelve verdadero si encuentra una tabla anterior allí y falso si crea una nueva tabla.
luaL_gsub
const char * luaL_gsub (lua_State * L,
const char * s,
const char * p,
const char * r);
Crea una copia de la cadena s, reemplazando cualquier ocurrencia de la cadena p con la cadena r. Empuja la cadena
resultante
en la pila y lo devuelve.
luaL_len
lua_Integer luaL_len (lua_State * L, índice int);
Devuelve la "longitud" del valor en el índice dado como un número; es equivalente al operador '#' en Lua (ver
§3.4.7). Genera un error si el resultado de la operación no es un número entero. (Este caso solo puede pasar por
metamétodos.)
luaL_loadbuffer
int luaL_loadbuffer (lua_State * L,
const char * buff,
size_t sz,
const char * nombre);
Equivalente a luaL_loadbufferx con modo igual a NULL.
luaL_loadbufferx
int luaL_loadbufferx (lua_State * L,
const char * buff,
size_t sz,

Página 52
[-0, +1, m ]
[-0, +1, m ]
[-0, +1, -]
[-0, +1, m ]
[-0, +1, m ]
[-0, +1, m ]
const char * nombre,
modo const char *);
Carga un búfer como un fragmento de Lua. Esta función utilizalua_load para cargar el fragmento en el búfer al que
apunta el buff
con talla sz.
Esta función devuelve los mismos resultados que lua_load . name es el nombre del fragmento, utilizado para
información de depuración y
error de mensajes. El modo de cadena funciona como en la función lua_load .
luaL_loadfile
int luaL_loadfile (lua_State * L, const char * nombre de archivo);
Equivalente a luaL_loadfilex con modo igual a NULL.
luaL_loadfilex
int luaL_loadfilex (lua_State * L, const char * nombre de archivo,
modo const char *);
Carga un archivo como un fragmento de Lua. Esta función utilizalua_load para cargar el fragmento en el archivo
llamado nombre de archivo. Si
filename es NULL, luego se carga desde la entrada estándar. La primera línea del archivo se ignora si comienza con
#.
El modo de cadena funciona como en la función lua_load .
Esta función devuelve los mismos resultados que lua_load oLUA_ERRFILE en busca de errores relacionados con
archivos.
Como lua_load , esta función solo carga el fragmento; no lo ejecuta.
luaL_loadstring
int luaL_loadstring (lua_State * L, const char * s);
Carga una cadena como un trozo de Lua. Esta función utilizalua_load para cargar el fragmento en la cadena s
terminada en cero.
Esta función devuelve los mismos resultados que lua_load .
Tambien como lua_load , esta función solo carga el fragmento; no lo ejecuta.
luaL_newlib
void luaL_newlib (lua_State * L, const luaL_Reg l []);
Crea una nueva tabla y registra allí las funciones en la lista l.
Se implementa como la siguiente macro:
(luaL_newlibtable (L, l), luaL_setfuncs (L, l, 0))
La matriz l debe ser la matriz real, no un puntero a ella.
luaL_newlibtable
void luaL_newlibtable (lua_State * L, const luaL_Reg l []);
Crea una nueva tabla con un tamaño optimizado para almacenar todas las entradas en la matriz l (pero en realidad no
las almacena). Es
destinado a ser utilizado junto con luaL_setfuncs (verluaL_newlib ).
Se implementa como una macro. La matriz l debe ser la matriz real, no un puntero a ella.
luaL_newmetatable
int luaL_newmetatable (lua_State * L, const char * tname);
Si el registro ya tiene la clave tname, devuelve 0. De lo contrario, crea una nueva tabla que se utilizará como
metatabla para
userdata, agrega a esta nueva tabla el par __name = tname, agrega al registro el par [tname] = new
tabla y devuelve 1.

Página 53
[-0, +0, -]
[-0, +0, e ]
[-0, +0, -]
[-0, +0, v ]
[-0, +0, v ]
[-0, +0, v ]
[-0, +0, v ]
En ambos casos, la función coloca en la pila el valor final asociado con tname en el registro.
luaL_newstate
lua_State * luaL_newstate (vacío);
Crea un nuevo estado Lua. Llamalua_newstate con un asignador basado en las funciones de asignación C estándar
y luego establece una función de advertencia y una función de pánico (ver §4.4 ) que imprimen mensajes en la salida
de error estándar.
Devuelve el nuevo estado o NULL si hay un error de asignación de memoria.
luaL_openlibs
void luaL_openlibs (lua_State * L);
Abre todas las bibliotecas estándar de Lua en el estado dado.
luaL_opt
T luaL_opt (L, func, arg, dflt);
Esta macro se define de la siguiente manera:
(lua_isnoneornil (L, (arg))? (dflt): func (L, (arg)))
En palabras, si el argumento arg es nulo o está ausente, la macro da como resultado el dflt predeterminado. De lo
contrario, da como resultado
resultado de llamar a func con el estado L y el argumento indexarg como argumentos. Tenga en cuenta que evalúa el
expresión dflt solo si es necesario.
luaL_optinteger
lua_Integer luaL_optinteger (lua_State * L,
int arg,
lua_Integer d);
Si el argumento de la función arg es un número entero (o se puede convertir en un número entero), devuelve este
número entero. Si este argumento es
ausente o es nulo , devuelve d. De lo contrario, genera un error.
luaL_optlstring
const char * luaL_optlstring (lua_State * L,
int arg,
const char * d,
size_t * l);
Si el argumento de la función arg es una cadena, devuelve esta cadena. Si este argumento está ausente o es nulo ,
devuelve d. De lo contrario,
genera un error.
Si l no es NULL, llena su referente con la longitud del resultado. Si el resultado es NULL (solo es posible al devolver
dyd
== NULL), su longitud se considera cero.
Esta función utiliza lua_tolstring para obtener su resultado, por lo que todas las conversiones y advertencias de esa
función se aplican aquí.
luaL_optnumber
lua_Number luaL_optnumber (lua_State * L, int arg, lua_Number d);
Si el argumento de la función arg es un número, devuelve este número como lua_Number. Si este argumento está
ausente o es
cero , devuelve d. De lo contrario, genera un error.
luaL_optstring
const char * luaL_optstring (lua_State * L,
int arg,
const char * d);
Si el argumento de la función arg es una cadena, devuelve esta cadena. Si este argumento está ausente o es nulo ,
devuelve d. De lo contrario,

Página 54
[- ?, + ?, m ]
[- ?, + ?, m ]
[-0, +1, -]
[- ?, +1, m ]
[- ?, +1, m ]
[-1, +0, m ]
[-0, +1, e ]
genera un error.
luaL_prepbuffer
char * luaL_prepbuffer (luaL_Buffer * B);
Equivalente a luaL_prepbuffsize con el tamaño predefinido LUAL_BUFFERSIZE.
luaL_prepbuffsize
char * luaL_prepbuffsize (luaL_Buffer * B, tamaño_t sz);
Devuelve una dirección a un espacio de tamaño sz donde puede copiar una cadena para agregarla al búfer B (ver
luaL_Buffer ). Después de copiar la cadena en este espacio, debe llamarluaL_addsize con el tamaño de la cadena
para agregarlo al búfer.
luaL_pushfail
void luaL_pushfail (lua_State * L);
Inserta el valor de falla en la pila (ver §6 ).
luaL_pushresult
void luaL_pushresult (luaL_Buffer * B);
Termina el uso del búfer B dejando la cadena final en la parte superior de la pila.
luaL_pushresultsize
void luaL_pushresultsize (luaL_Buffer * B, size_t sz);
Equivalente a la secuencia luaL_addsize ,luaL_pushresult.
luaL_ref
int luaL_ref (lua_State * L, int t);
Crea y devuelve una referencia , en la tabla en el índice t, para el objeto en la parte superior de la pila (y abre el
objeto).
Una referencia es una clave entera única. Siempre que no agregue manualmente claves enteras en la tabla t,luaL_ref
asegura la unicidad de la clave que devuelve. Puede recuperar un objeto referido por la referencia r llamando
lua_rawgeti (L, t, r). La funciónluaL_unref libera una referencia.
Si el objeto en la parte superior de la pila es nulo , luaL_ref devuelve la constante LUA_REFNIL. El constante
Se garantiza que LUA_NOREF será diferente de cualquier referencia devuelta por luaL_ref .
luaL_Reg
typedef struct luaL_Reg {
const char * nombre;
lua_CFunction func;
} luaL_Reg;
Escriba para matrices de funciones que serán registradas por luaL_setfuncs . name es el nombre de la función y func
es un
puntero a la función. Cualquier matriz deluaL_Reg debe terminar con una entrada centinela en la que tanto el nombre
como la función son
NULO.
luaL_requiref
void luaL_requiref (lua_State * L, const char * modname,
lua_CFunction openf, int glb);
Si package.loaded [modname] no es verdadero, llama a la función openf con la cadena modname como argumento
y establece el resultado de la llamada en package.loaded [modname], como si esa función hubiera sido llamada a
través de require .

Página 55
[-nup, +0, m ]
[-0, +0, -]
[-0, +0, m ]
[-0, +1, e ]
[-0, +1, m ]
Si glb es verdadero, también almacena el módulo en el nombre de mod global.
Deja una copia del módulo en la pila.
luaL_setfuncs
void luaL_setfuncs (lua_State * L, const luaL_Reg * l, int nup);
Registra todas las funciones en la matriz l (ver luaL_Reg ) en la tabla en la parte superior de la pila (debajo opcional
upvalues, ver a continuación).
Cuando nup no es cero, todas las funciones se crean con nup upvalues, inicializadas con copias de los valores nup
previamente empujado en la pila encima de la mesa de la biblioteca. Estos valores se extraen de la pila después de
registro.
luaL_setmetatable
void luaL_setmetatable (lua_State * L, const char * tname);
Establece la metatabla del objeto en la parte superior de la pila como la metatabla asociada con el nombre tname en el
registro (ver luaL_newmetatable ).
luaL_Stream
typedef struct luaL_Stream {
ARCHIVO * f;
lua_CFunction closef;
} luaL_Stream;
La representación estándar de los identificadores de archivos que utiliza la biblioteca de E / S estándar.
Un identificador de archivo se implementa como datos de usuario completos, con una metatabla llamada
LUA_FILEHANDLE (donde
LUA_FILEHANDLE es una macro con el nombre real de la metatabla). La metatabla es creada por la biblioteca de E
/ S (ver
luaL_newmetatable ).
Estos datos de usuario deben comenzar con la estructura luaL_Stream; puede contener otros datos después de esta
estructura inicial. los
el campo f apunta al flujo C correspondiente (o puede ser NULL para indicar un identificador creado de manera
incompleta). los
field closef apunta a una función Lua que se llamará para cerrar la secuencia cuando el identificador se cierre o se
recopile;
esta función recibe el identificador de archivo como su único argumento y debe devolver un valor verdadero, en caso
de éxito,
o un valor falso más un mensaje de error, en caso de error. Una vez que Lua llama a este campo, cambia el valor del
campo a
NULL para indicar que la manija está cerrada.
luaL_testudata
void * luaL_testudata (lua_State * L, int arg, const char * tname);
Esta función funciona como luaL_checkudata , excepto que, cuando la prueba falla, devuelve NULL en lugar de
generar un
error.
luaL_tolstring
const char * luaL_tolstring (lua_State * L, int idx, size_t * len);
Convierte cualquier valor Lua en el índice dado en una cadena C en un formato razonable. La cadena resultante se
empuja
en la pila y también devuelto por la función (ver §4.1.3 ). Si len no es NULL, la función también establece * len con
la longitud de la cuerda.
Si el valor tiene una metatabla con un campo __tostring, entonces luaL_tolstring llama al correspondiente
metamétodo con el valor como argumento y utiliza el resultado de la llamada como resultado.
luaL_traceback
void luaL_traceback (lua_State * L, lua_State * L1, const char * msg,
nivel int);
Crea y empuja un rastreo de la pila L1. Si msg no es NULL, se agrega al comienzo de la
rastrear. El parámetro de nivel indica en qué nivel iniciar el rastreo.

Página 56
[-0, +0, v ]
[-0, +0, -]
[-0, +0, -]
[-0, +1, m ]
luaL_typeerror
const char * luaL_typeerror (lua_State * L,
int arg,
const char * tname);
Genera un error de tipo para el argumento arg de la función C que lo llamó, usando un mensaje estándar; tname es un
"nombre" para el tipo esperado. Esta función nunca regresa.
luaL_typename
const char * luaL_typename (lua_State * L, int índice);
Devuelve el nombre del tipo de valor en el índice dado.
luaL_unref
void luaL_unref (lua_State * L, int t, int ref);
Libera la referencia de referencia de la tabla en el índice t (ver luaL_ref ). La entrada se elimina de la tabla, por lo que
que se pueda recoger el objeto referido. La referencia de referencia también se libera para ser utilizada nuevamente.
Si ref es LUA_NOREF oLUA_REFNIL ,luaL_unref no hace nada.
luaL_where
void luaL_where (lua_State * L, int lvl);
Inserta en la pila una cadena que identifica la posición actual del control en el nivel lvl de la pila de llamadas.
Típicamente
esta cadena tiene el siguiente formato:
chunkname : currentline :
El nivel 0 es la función de ejecución, el nivel 1 es la función que llamó a la función de ejecución, etc.
Esta función se utiliza para crear un prefijo para mensajes de error.

6 - Las bibliotecas estándar

Las bibliotecas estándar de Lua proporcionan funciones útiles que se implementan en C a través de la API de C.
Algunos de estos
funciones proporcionan servicios esenciales al lenguaje (por ejemplo, tipo ygetmetatable ); otros brindan acceso a
servicios externos (por ejemplo, E / S); y otros podrían implementarse en la propia Lua, pero que por diferentes
motivos merecen
una implementación en C (p. ej., table.sort ).
Todas las bibliotecas se implementan a través de la API oficial de C y se proporcionan como módulos C separados. A
no ser que
De lo contrario, estas funciones de biblioteca no ajustan su número de argumentos a sus parámetros esperados. Para
Por ejemplo, una función documentada como foo (arg) no debe llamarse sin un argumento.
La notación falla significa un valor falso que representa algún tipo de falla. (Actualmente, fail es igual a nil , pero eso
puede cambiar en versiones futuras. La recomendación es probar siempre el éxito de estas funciones con (no
status), en lugar de (status == nil).)
Actualmente, Lua tiene las siguientes bibliotecas estándar:
biblioteca básica§6.1 );
biblioteca de corrutinas§6.2 );
biblioteca de paquetes§6.3 );
manipulación de cuerdas§6.4 );
soporte básico de UTF-8 ( §6.5 );
manipulación de la mesa§6.6 );
funciones matemáticas§6.7 ) (pecado, registro, etc.);
entrada y salida (§6.8 );
instalaciones del sistema operativo§6.9 );
instalaciones de depuración§6.10).

Página 57
A excepción de las bibliotecas básicas y de paquetes, cada biblioteca proporciona todas sus funciones como campos
de una tabla global o
como métodos de sus objetos.
Para tener acceso a estas bibliotecas, el programa anfitrión de C debe llamar a la función luaL_openlibs , que abre
todas
bibliotecas estándar. Alternativamente, el programa anfitrión puede abrirlos individualmente usando luaL_requiref
para llamar
luaopen_base (para la biblioteca básica), luaopen_package (para la biblioteca de paquetes), luaopen_coroutine (para
la biblioteca de corrutinas), luaopen_string (para la biblioteca de cadenas), luaopen_utf8 (para la biblioteca UTF-8),
luaopen_table (para la biblioteca de tablas), luaopen_math (para la biblioteca matemática), luaopen_io (para la E / S
library), luaopen_os (para la biblioteca del sistema operativo) y luaopen_debug (para la biblioteca de depuración).
Estos
las funciones se declaran en lualib.h.
6.1 - Funciones básicas
La biblioteca básica proporciona funciones básicas a Lua. Si no incluye esta biblioteca en su aplicación, debe
compruebe cuidadosamente si necesita proporcionar implementaciones para algunas de sus instalaciones.
afirmar (v [, mensaje])
Genera un error si el valor de su argumento v es falso (es decir, nulo o falso ); de lo contrario, devuelve todos sus
argumentos. En
caso de error, el mensaje es el objeto de error; cuando está ausente, el valor predeterminado es "¡aserción fallida!"
recolectar basura ([opt [, arg]])
Esta función es una interfaz genérica para el recolector de basura. Realiza diferentes funciones según su primera
argumento, optar:
"recolectar": realiza un ciclo completo de recolección de basura. Esta es la opción por defecto.
"detener": detiene la ejecución automática del recolector de basura. El recopilador se ejecutará solo cuando
explícitamente
invocado, hasta una llamada para reiniciarlo.
"reiniciar": reinicia la ejecución automática del recolector de basura.
"count": Devuelve la memoria total en uso por Lua en Kbytes. El valor tiene una parte fraccionaria, de modo que
multiplicado por 1024 da el número exacto de bytes que utiliza Lua.
"paso": realiza un paso de recolección de basura. El "tamaño" del paso está controlado por arg. Con un valor cero, el
El recolector realizará un paso básico (indivisible). Para valores distintos de cero, el recolector funcionará como si
cantidad de memoria (en Kbytes) había sido asignada por Lua. Devuelve verdadero si el paso terminó una colección
ciclo.
"isrunning": Devuelve un valor booleano que indica si el recopilador está en ejecución (es decir, no está detenido).
"incremental": cambia el modo de recopilador a incremental. Esta opción puede ir seguida de tres números:
la pausa del recolector de basura, el multiplicador de pasos y el tamaño del paso (ver §2.5.1 ). Un cero significa no
cambiar
ese valor.
"generacional": cambia el modo recolector a generacional. Esta opción puede ir seguida de dos números:
el multiplicador menor del recolector de basura y el multiplicador mayor (ver §2.5.2 ). Un cero significa no cambiar
eso
valor.
Consulte §2.5 para obtener más detalles sobre la recolección de basura y algunas de estas opciones.
dofile ([nombre de archivo])
Abre el archivo nombrado y ejecuta su contenido como un fragmento de Lua. Cuando se llama sin argumentos, dofile
se ejecuta
el contenido de la entrada estándar (stdin). Devuelve todos los valores devueltos por el fragmento. En caso de errores,
dofile
propaga el error a su llamador. (Es decir, dofile no se ejecuta en modo protegido).
error (mensaje [, nivel])
Genera un error (ver §2.3 ) con @ {mensaje} como objeto de error. Esta función nunca regresa.
Por lo general, el error agrega información sobre la posición del error al principio del mensaje, si el mensaje
es una cuerda. El argumento de nivel especifica cómo obtener la posición del error. Con el nivel 1 (el
predeterminado), el error
posición es donde se llamó a la función de error. El nivel 2 apunta el error a donde la función que llamó error
fue llamado etcétera. Pasar un nivel 0 evita la adición de información de posición de error al mensaje.
_GRAMO
Una variable global (no una función) que contiene el entorno global (ver §2.2 ). Lua en sí no usa esto

Página 58
variable; cambiar su valor no afecta a ningún entorno, ni viceversa.
getmetatable (objeto)
Si el objeto no tiene una metatabla, devuelve nil . De lo contrario, si la metatabla del objeto tiene un campo
__metatable,
devuelve el valor asociado. De lo contrario, devuelve la metatabla del objeto dado.
pares (t)
Devuelve tres valores (una función de iterador, la tabla t y 0) para que la construcción
porque yo, v en pares (t) ¿ acaban el cuerpo
iterará sobre los pares clave-valor (1, t [1]), (2, t [2]), ..., hasta el primer índice ausente.
load (chunk [, chunkname [, mode [, env]]])
Carga un trozo.
Si el fragmento es una cadena, el fragmento es esta cadena. Si chunk es una función, load la llama repetidamente para
obtener el chunk
piezas. Cada llamada a chunk debe devolver una cadena que se concatene con los resultados anteriores. Un regreso de
un vacío
cadena, nulo o ningún valor indica el final del fragmento.
Si no hay errores sintácticos, load devuelve el fragmento compilado como función; de lo contrario, devuelve fail más
el
mensaje de error.
Cuando carga un fragmento principal, la función resultante siempre tendrá exactamente un valor superior, la variable
_ENV (consulte
§2.2 ). Sin embargo, cuando carga un fragmento binario creado a partir de una función (consulte string.dump ), la
función resultante
puede tener un número arbitrario de upvalues, y no hay garantía de que su primer upvalue sea el _ENV
variable. (Es posible que una función no principal ni siquiera tenga un valor de subida _ENV).
Independientemente, si la función resultante tiene algún valor de subida, su primer valor de subida se establece en el
valor de env, si ese parámetro
se da, o al valor del medio ambiente global. Otros upvalues se inicializan con nil . Todos los valores son frescos
es decir, no se comparten con ninguna otra función.
chunkname se utiliza como el nombre del fragmento para mensajes de error e información de depuración (consulte
§4.7 ). Cuando
ausente, por defecto es chunk, si chunk es una cadena, o "= (cargar)" en caso contrario.
El modo de cadena controla si el fragmento puede ser texto o binario (es decir, un fragmento precompilado). Puede
ser el
cadena "b" (solo fragmentos binarios), "t" (solo fragmentos de texto) o "bt" (tanto binarios como de texto). El valor
predeterminado es "bt".
Es seguro cargar fragmentos binarios con formato incorrecto; La carga señala un error apropiado. Sin embargo, Lua
no comprueba el
consistencia del código dentro de fragmentos binarios; la ejecución de un código de bytes creado con fines
malintencionados puede bloquear el intérprete.
loadfile ([nombre de archivo [, modo [, env]]])
Similar a cargar , pero obtiene el fragmento del nombre del archivo o de la entrada estándar, si no se proporciona un
nombre de archivo.
siguiente (tabla [, índice])
Permite que un programa recorra todos los campos de una tabla. Su primer argumento es una tabla y su segundo
argumento es un índice
en esta tabla. Una llamada a next devuelve el siguiente índice de la tabla y su valor asociado. Cuando se llama con nil
como su
segundo argumento, siguiente devuelve un índice inicial y su valor asociado. Cuando se llama con el último índice o
con
nil en una tabla vacía, luego devuelve nil . Si el segundo argumento está ausente, se interpreta como nulo . En
particular,
puede utilizar next (t) para comprobar si una tabla está vacía.
No se especifica el orden en el que se enumeran los índices, incluso para índices numéricos . (Para atravesar una
mesa en
orden numérico, use un numérico para .)
El comportamiento de next no está definido si, durante el recorrido, asigna algún valor a un campo no existente en la
tabla.
Sin embargo, puede modificar los campos existentes. En particular, puede establecer los campos existentes en cero.
pares (t)
Si t tiene un metamétodo __pairs, lo llama con t como argumento y devuelve los primeros tres resultados de la
llamada.

Página 59
De lo contrario, devuelve tres valores: el siguiente función, la tabla t, y nil , de modo que la construcción
para k, v en pares (t) el cuerpo termina
iterará sobre todos los pares clave-valor de la tabla t.
Ver función siguiente para las advertencias de modificar la tabla durante su recorrido.
pcall (f [, arg1, ···])
Llama a la función f con los argumentos dados en modo protegido . Esto significa que cualquier error dentro de f no
es
propagado en su lugar, pcall detecta el error y devuelve un código de estado. Su primer resultado es el código de
estado (un
booleano), que es verdadero si la llamada se realiza correctamente sin errores. En tal caso, pcall también devuelve
todos los resultados del
llamar, después de este primer resultado. En caso de cualquier error, pcall devuelve falso más el objeto de error.
Tenga en cuenta que los errores detectados por
pcall no llama a un controlador de mensajes.
imprimir (···)
Recibe cualquier número de argumentos e imprime sus valores en stdout, convirtiendo cada argumento en una cadena
siguiendo las mismas reglas de tirar cuerdas .
La función imprimir no está pensada para salida formateada, sino solo como una forma rápida de mostrar un valor,
por ejemplo para
depuración. Para un control completo sobre la salida, usestring.format yio.write .
rawequal (v1, v2)
Comprueba si v1 es igual a v2, sin invocar el metamétodo __eq. Devuelve un booleano.
rawget (tabla, índice)
Obtiene el valor real de la tabla [índice], sin usar el metavalor __index. la mesa debe ser una mesa; índice
puede tener cualquier valor.
rawlen (v)
Devuelve la longitud del objeto v, que debe ser una tabla o una cadena, sin invocar el metamétodo __len.
Devuelve un número entero.
rawset (tabla, índice, valor)
Establece el valor real de la tabla [índice] en valor, sin usar el metavalor __newindex. la mesa debe ser una
tabla, indexe cualquier valor diferente de nil y NaN, y valore cualquier valor Lua.
Esta función devuelve la tabla.
seleccionar (índice, ···)
Si el índice es un número, devuelve todos los argumentos después del índice del número del argumento; índices
numéricos negativos del
end (-1 es el último argumento). De lo contrario, el índice debe ser la cadena "#" y seleccionar devuelve el número
total de
argumentos adicionales que recibió.
setmetatable (tabla, metatabla)
Establece la metatabla para la tabla dada. Si metatable es nulo , elimina la metatabla de la tabla dada. Si el
La metatabla original tiene un campo __metatable, genera un error.
Esta función devuelve la tabla.
Para cambiar la metatabla de otros tipos del código Lua, debe usar la biblioteca de depuración (§6.10 ).
tonumber (e [, base])
Cuando se llama sin base, tonumber intenta convertir su argumento en un número. Si el argumento ya es un
número o una cadena convertible en un número, luego tonumber devuelve este número; de lo contrario, vuelve a
fallar .
La conversión de cadenas puede resultar en números enteros o flotantes, de acuerdo con las convenciones léxicas de
Lua (ver §3.1 ).

Página 60
La cadena puede tener espacios iniciales y finales y un letrero.
Cuando se llama con base, e debe ser una cadena para ser interpretada como un número entero en esa base. La base
puede ser cualquier número entero entre 2 y 36, inclusive. En bases por encima de 10, la letra 'A' (en mayúscula o
minúscula)
representa 10, 'B' representa 11, y así sucesivamente, con 'Z' representando 35. Si la cadena e no es un número válido
en el
dada la base, la función devuelve falla .
tostar (v)
Recibe un valor de cualquier tipo y lo convierte en una cadena en un formato legible por humanos.
Si la metatabla de v tiene un campo __tostring, entonces tostring llama al valor correspondiente con v como
argumento,
y utiliza el resultado de la llamada como resultado. De lo contrario, si la metatabla de v tiene un campo __name con
un valor de cadena,
tostring puede usar esa cadena en su resultado final.
Para un control completo de cómo se convierten los números, use string.format .
tipo (v)
Devuelve el tipo de su único argumento, codificado como una cadena. Los posibles resultados de esta función son
"nil" (una cadena,
no el valor nulo ), "número", "cadena", "booleano", "tabla", "función", "hilo" y "datos de usuario".
_VERSIÓN
Una variable global (no una función) que contiene una cadena que contiene la versión de Lua en ejecución. El valor
actual de este
La variable es "Lua 5.4".
advertir (msg1, ···)
Emite una advertencia con un mensaje compuesto por la concatenación de todos sus argumentos (que deberían ser
cadenas).
Por convención, un mensaje de una pieza que comienza con '@' está destinado a ser un mensaje de control , que es un
mensaje para
el propio sistema de alerta. En particular, la función de advertencia estándar en Lua reconoce los mensajes de control
"@off", para detener la emisión de avisos, y "@on", para (re) iniciar la emisión; ignora el control desconocido
mensajes.
xpcall (f, msgh [, arg1, ···])
Esta función es similar a pcall , excepto que establece un nuevo controlador de mensajes msgh.
6.2 - Manipulación de corrutinas
Esta biblioteca comprende las operaciones para manipular corrutinas, que vienen dentro de la corrutina de la tabla.
Ver
§2.6 para una descripción general de las corrutinas.
coroutine.close (co)
Cierra coroutine co, es decir, cierra todas sus variables pendientes de cerrar y pone la coroutine en un estado muerto.
La corrutina dada debe estar muerta o suspendida. En caso de error al cerrar alguna variable, devuelve falso más el
objeto de error; de lo contrario, devuelve verdadero .
coroutine.create (f)
Crea una nueva corrutina, con cuerpo f. f debe ser una función. Devuelve esta nueva corrutina, un objeto con tipo
"hilo".
coroutine.isyieldable ([co])
Devuelve verdadero cuando la co-rutina puede ceder. El valor predeterminado para co es la corrutina en ejecución.
Una corrutina es susceptible de rendimiento si no es el hilo principal y no está dentro de una función C no susceptible
de rendimiento.
coroutine.resume (co [, val1, ···])
Inicia o continúa la ejecución de coroutine co. La primera vez que reanuda una corrutina, comienza a ejecutar su
cuerpo.

Página 61
Los valores val1, ... se pasan como argumentos a la función body. Si la corrutina ha cedido, reanude
lo reinicia; los valores val1, ... se pasan como resultados del rendimiento.
Si la corrutina se ejecuta sin errores, resume devuelve verdadero más los valores pasados para producir (cuando el
rendimientos de corrutina) o cualquier valor devuelto por la función del cuerpo (cuando termina la corrutina). Si hay
algún error,
resume devuelve falso más el mensaje de error.
coroutine.running ()
Devuelve la corrutina en ejecución más un booleano, verdadero cuando la corrutina en ejecución es la principal.
coroutine.status (co)
Devuelve el estado de la co-rutina, como una cadena: "en ejecución", si la rutina está en ejecución (es decir, es la que
llamado estado); "suspendido", si la corrutina se suspende en una llamada a ceder, o si no ha comenzado a ejecutarse
todavía; "normal" si la corrutina está activa pero no se está ejecutando (es decir, ha reanudado otra corrutina); y
"muerto" si
la corrutina ha terminado su función corporal, o si se ha detenido con un error.
coroutine.wrap (f)
Crea una nueva corrutina, con cuerpo f; f debe ser una función. Devuelve una función que reanuda la corrutina cada
tiempo que se llama. Cualquier argumento que se pase a esta función se comporta como argumentos adicionales para
reanudar. La función
devuelve los mismos valores devueltos por resume, excepto el primer booleano. En caso de error, la función cierra el
corrutina y propaga el error.
coroutine.yield (···)
Suspende la ejecución de la corrutina de llamada. Cualquier argumento que se produzca se pasa como resultados
adicionales para reanudar.
6.3 - Módulos
La biblioteca de paquetes proporciona instalaciones básicas para cargar módulos en Lua. Exporta una función
directamente en el
entorno global: requiere . Todo lo demás se exporta en el paquete de la tabla.
require (modname)
Carga el módulo dado. La función comienza mirando en elpackage.loaded tabla para determinar si
modname ya está cargado. Si es así, require devuelve el valor almacenado en package.loaded [modname]. (Los
La ausencia de un segundo resultado en este caso indica que esta llamada no tuvo que cargar el módulo.) De lo
contrario, intenta
busque un cargador para el módulo.
Para encontrar un cargador, require se guía por la tabla Package.searchers . Cada elemento de esta tabla es una
búsqueda
función, que busca el módulo de una forma determinada. Al cambiar esta tabla, podemos cambiar la forma requerida
busca un módulo. La siguiente explicación se basa en la configuración predeterminada paraPackage.searchers .
Primero se requieren consultas package.preload [modname]. Si tiene un valor, este valor (que debe ser una función)
es
el cargador. De lo contrario, requiera búsquedas de un cargador Lua utilizando la ruta almacenada en package.path .
Si eso tambien
falla, busca un cargador C utilizando la ruta almacenada en package.cpath . Si eso también falla, prueba un todo en
uno
cargador (ver package.searchers ).
Una vez que se encuentra un cargador, require llama al cargador con dos argumentos: modname y un valor extra,
datos del cargador ,
también devuelto por el buscador. Los datos del cargador pueden tener cualquier valor útil para el módulo; para los
buscadores predeterminados,
indica dónde se encontró el cargador. (Por ejemplo, si el cargador proviene de un archivo, este valor adicional es la
ruta del archivo).
Si el cargador devuelve un valor que no sea nulo, require asigna el valor devuelto a package.loaded [modname]. Si
el cargador no devuelve un valor que no sea nulo y no ha asignado ningún valor a package.loaded [modname],
entonces
exigir
asigna verdadero
a esta entrada. En cualquier caso, exigir devuelve el valor final de
package.loaded [modname]. Además de ese valor, require también devuelve como segundo resultado los datos del
cargador
devuelto por el buscador, que indica cómo se ha encontrado el módulo.
Si hay algún error al cargar o ejecutar el módulo, o si no puede encontrar ningún cargador para el módulo, solicite
genera un error.
package.config

Página 62
Cadena que describe algunas configuraciones en tiempo de compilación de paquetes. Esta cadena es una secuencia de
líneas:
La primera línea es la cadena de separación de directorios. El valor predeterminado es '\' para Windows y '/' para
todos los demás sistemas.
La segunda línea es el carácter que separa las plantillas en una ruta. El valor predeterminado es ';'.
La tercera línea es la cadena que marca los puntos de sustitución en una plantilla. El valor predeterminado es '?'.
La cuarta línea es una cadena que, en una ruta en Windows, se reemplaza por el directorio del ejecutable. El valor
predeterminado es '!'.
La quinta línea es una marca para ignorar todo el texto que sigue al crear el nombre de la función luaopen_. El valor
predeterminado es '-'.
package.cpath
Una cadena con la ruta utilizada por requieren buscar un cargador C.
Lua inicializa la ruta de C package.cpath de la misma manera que inicializa la ruta de Lua package.path , usando el
variable de entorno LUA_CPATH_5_4, o la variable de entorno LUA_CPATH, o una ruta predeterminada definida
en
luaconf.h.
paquete.cargado
Una tabla utilizada por require para controlar qué módulos ya están cargados. Cuando necesite un modname de
módulo y
package.loaded [modname] no es falso, require simplemente devuelve el valor almacenado allí.
Esta variable es solo una referencia a la tabla real; asignaciones a esta variable no cambian la tabla utilizada por
requieren .
package.loadlib (libname, funcname)
Vincula dinámicamente el programa host con la biblioteca de C. libname.
Si funcname es "*", entonces solo enlaza con la biblioteca, haciendo que los símbolos exportados por la biblioteca
estén disponibles para otros
Bibliotecas vinculadas dinámicamente. De lo contrario, busca una función funcname dentro de la biblioteca y
devuelve esta función
como una función C. Entonces, funcname debe seguir ellua_CFunction prototype (verlua_CFunction).
Esta es una función de bajo nivel. Omite por completo el sistema de paquetes y módulos. A diferencia de require , no
realiza cualquier búsqueda de ruta y no agrega extensiones automáticamente. libname debe ser el archivo completo
nombre de la biblioteca C, incluyendo si es necesario una ruta y una extensión. funcname debe ser el nombre exacto
exportado por la biblioteca de C (que puede depender del compilador de C y del enlazador utilizado).
Esta función no es compatible con Standard C. Como tal, solo está disponible en algunas plataformas (Windows,
Linux,
Mac OS X, Solaris, BSD y otros sistemas Unix que admiten el estándar dlfcn).
Esta función es inherentemente insegura, ya que le permite a Lua llamar a cualquier función en cualquier biblioteca
dinámica legible en el
sistema. (Lua llama a cualquier función asumiendo que la función tiene un prototipo adecuado y respeta un protocolo
adecuado (ver
lua_CFunction). Por lo tanto, llamar a una función arbitraria en una biblioteca dinámica arbitraria la mayoría de las
veces
da como resultado una infracción de acceso).
package.path
Una cadena con la ruta utilizada por requieren buscar un cargador Lua.
Al inicio, Lua inicializa esta variable con el valor de la variable de entorno LUA_PATH_5_4 o el
variable de entorno LUA_PATH o con una ruta predeterminada definida en luaconf.h, si esas variables de entorno
son
no definida. A ";;" en el valor de la variable de entorno se reemplaza por la ruta predeterminada.
package.preload
Una tabla para almacenar cargadores para módulos específicos (ver requieren ).
Esta variable es solo una referencia a la tabla real; asignaciones a esta variable no cambian la tabla utilizada por
requieren .
package.searchers
Una tabla utilizada por require para controlar cómo encontrar módulos.
Cada entrada de esta tabla es una función de búsqueda . Al buscar un módulo,requieren llamadas a cada uno de estos
buscadores
en orden ascendente, con el nombre del módulo (el argumento dado a require ) como su único argumento. Si el
buscador

Página 63
encuentra el módulo, devuelve otra función, el cargador del módulo , más un valor adicional, un cargador de datos ,
que será
pasado a ese cargador y devuelto como segundo resultado por requieren . Si no puede encontrar el módulo, devuelve
una cadena
explicando por qué (o nulo si no tiene nada que decir).
Lua inicializa esta tabla con cuatro funciones de búsqueda.
El primer buscador simplemente busca un cargador en el package.preload table.
El segundo buscador busca un cargador como una biblioteca Lua, usando la ruta almacenada en package.path . La
busqueda es
hecho como se describe en la función package.searchpath .
El tercer buscador busca un cargador como una biblioteca C, usando la ruta dada por la variable package.cpath . Otra
vez,
la búsqueda se realiza como se describe en la función package.searchpath . Por ejemplo, si la ruta C es la cadena
"./?.so;./?.dll;/usr/local/?/init.so"
el buscador del módulo foo intentará abrir los archivos ./foo.so, ./foo.dll y /usr/local/foo/init.so,
en ese orden. Una vez que encuentra una biblioteca C, este buscador primero usa una función de enlace dinámico
para vincular la aplicación con la
Biblioteca. Luego, intenta encontrar una función C dentro de la biblioteca para usarla como cargador. El nombre de
esta función C es
la cadena "luaopen_" concatenada con una copia del nombre del módulo donde cada punto se reemplaza por un
guion bajo. Además, si el nombre del módulo tiene un guión, su sufijo después (incluido) del primer guión es
remoto. Por ejemplo, si el nombre del módulo es abc-v2.1, el nombre de la función será luaopen_a_b_c.
El cuarto buscador prueba un cargador todo en uno . Busca en la ruta C una biblioteca para el nombre raíz de la
módulo. Por ejemplo, cuando requiera abc, buscará una biblioteca C para un. Si lo encuentra, lo busca en busca de un
función para el submódulo; en nuestro ejemplo, sería luaopen_a_b_c. Con esta facilidad, un paquete puede empacar
varios submódulos C en una sola biblioteca, con cada submódulo manteniendo su función abierta original.
Todos los buscadores excepto el primero (precarga) devuelven como valor extra la ruta del archivo donde se encontró
el módulo, como
devuelto por package.searchpath . El primer buscador siempre devuelve la cadena ": preload:".
Los buscadores no deben generar errores y no tener efectos secundarios en Lua. (Pueden tener efectos secundarios en
C, por ejemplo
vinculando la aplicación con una biblioteca).
package.searchpath (nombre, ruta [, sep [, rep]])
Busca el nombre de pila en la ruta indicada.
Una ruta es una cadena que contiene una secuencia de plantillas separadas por punto y coma. Para cada plantilla, la
función
reemplaza cada signo de interrogación (si lo hubiera) en la plantilla con una copia del nombre en el que todas las
apariciones de sep (un
dot, por defecto) fueron reemplazados por rep (el separador de directorios del sistema, por defecto), y luego intenta
abrir el
nombre de archivo resultante.
Por ejemplo, si la ruta es la cadena
"./?.lua;./?.lc;/usr/local/?/init.lua"
la búsqueda del nombre foo.a intentará abrir los archivos ./foo/a.lua, ./foo/a.lc, y
/usr/local/foo/a/init.lua, en ese orden.
Devuelve el nombre resultante del primer archivo que puede abrir en modo lectura (después de cerrar el archivo), o
fallar más un error
mensaje si ninguno tiene éxito. (Este mensaje de error enumera todos los nombres de archivo que intentó abrir).
6.4 - Manipulación de cadenas
Esta biblioteca proporciona funciones genéricas para la manipulación de cadenas, como buscar y extraer subcadenas,
y
la coincidencia de patrones. Al indexar una cadena en Lua, el primer carácter está en la posición 1 (no en 0, como en
C). Los índices son
se permite que sea negativo y se interpreta como una indexación hacia atrás, desde el final de la cadena. Así, el
último
el carácter está en la posición -1, y así sucesivamente.
La biblioteca de cadenas proporciona todas sus funciones dentro de la cadena de la tabla. También establece una
metatabla para cadenas donde el
El campo __index apunta a la tabla de cadenas. Por lo tanto, puede utilizar las funciones de cadena en estilo orientado
a objetos. Para
ejemplo, string.byte (s, i) se puede escribir como s: byte (i).
La biblioteca de cadenas asume codificaciones de caracteres de un byte.
cadena.byte (s [, i [, j]])

Página 64
Devuelve los códigos numéricos internos de los caracteres s [i], s [i + 1], ..., s [j]. El valor predeterminado para i es 1;
la
el valor predeterminado para j es i. Estos índices se corrigen siguiendo las mismas reglas de función string.sub .
Los códigos numéricos no son necesariamente portables entre plataformas.
string.char (···)
Recibe cero o más enteros. Devuelve una cadena con una longitud igual al número de argumentos, en el que cada
carácter tiene el código numérico interno igual a su argumento correspondiente.
Los códigos numéricos no son necesariamente portables entre plataformas.
string.dump (función [, strip])
Devuelve una cadena que contiene una representación binaria (un fragmento binario ) de la función dada, de modo
que una carga posterior en
esta cadena devuelve una copia de la función (pero con nuevos valores superiores). Si strip es un valor verdadero, el
binario
La representación puede no incluir toda la información de depuración sobre la función, para ahorrar espacio.
Las funciones con upvalues solo tienen guardado su número de upvalues. Cuando (re) cargado, esos upvalues reciben
instancias frescas. (Ver elload para obtener detalles sobre cómo se inicializan estos upvalues. Puedes usar el
biblioteca de depuración para serializar y recargar los upvalues de una función de una manera adecuada a sus
necesidades).
string.find (s, patrón [, init [, plano]])
Busca la primera coincidencia de patrón (ver §6.4.1 ) en la cadena s. Si encuentra una coincidencia, buscar devuelve
los índices
de s donde comienza y termina esta ocurrencia; de lo contrario, vuelve a fallar . Un tercer argumento numérico
opcional init
especifica dónde comenzar la búsqueda; su valor predeterminado es 1 y puede ser negativo. Un valor de verdadero
como cuarto, opcional
argumento llano desactiva las funciones de coincidencia de patrones, por lo que la función realiza una operación
simple de "buscar subcadena",
sin que ningún personaje en el patrón se considere mágico.
Si el patrón tiene capturas, en una coincidencia exitosa, los valores capturados también se devuelven, después de los
dos
índices.
string.format (formattring, ···)
Devuelve una versión formateada de su número variable de argumentos siguiendo la descripción dada en su primera
argumento, que debe ser una cadena. La cadena de formato sigue las mismas reglas que la función ISO C sprintf. los
Las únicas diferencias son que los especificadores y modificadores de conversión *, h, L, lyn no son compatibles y
que no
es un especificador adicional, q.
El especificador q formatea booleanos, nulos, números y cadenas de manera que el resultado sea una constante válida
en Lua
código fuente. Los valores booleanos y nil se escriben de forma obvia (verdadero, falso, nulo). Los flotadores están
escritos en
hexadecimal, para preservar la precisión total. Una cadena se escribe entre comillas dobles, utilizando secuencias de
escape cuando
necesario para garantizar que el intérprete de Lua pueda leerlo de forma segura. Por ejemplo, la llamada
string.format ('% q', 'una cadena con "comillas" y \ n nueva línea')
puede producir la cadena:
"una cadena con \" comillas \ "y \
nueva línea"
Este especificador no admite modificadores (banderas, ancho, largo).
Los especificadores de conversión A, a, E, e, f, G yg esperan un número como argumento. Los especificadores c, d, i,
o, u, X,
y x espera un número entero. Cuando Lua se compila con un compilador C89, los especificadores A y a (flotantes
hexadecimales)
no admiten modificadores.
El especificador s espera una cadena; si su argumento no es una cadena, se convierte en uno que sigue las mismas
reglas de
tostring . Si el especificador tiene algún modificador, el argumento de cadena correspondiente no debe contener
incrustado
ceros.
El especificador p formatea el puntero devuelto por lua_topointer. Eso da un identificador de cadena único para
tablas,
datos de usuario, hilos, cadenas y funciones. Para otros valores (números, nil, booleanos), este especificador da como
resultado un
cadena que representa el puntero NULL.

Página 65
string.gmatch (s, patrón [, init])
Devuelve una función de iterador que, cada vez que se llama, devuelve las siguientes capturas del patrón (ver §6.4.1 )
más
las cuerdas. Si el patrón no especifica capturas, entonces se produce toda la coincidencia en cada llamada. Un tercero,
opcional
el argumento numérico init especifica dónde comenzar la búsqueda; su valor predeterminado es 1 y puede ser
negativo.
Como ejemplo, el siguiente ciclo iterará sobre todas las palabras de la cadena s, imprimiendo una por línea:
s = "hola mundo de Lua"
para w en string.gmatch (s, "% a +") hacer
imprimir (w)
fin
El siguiente ejemplo recopila todos los pares clave = valor de la cadena dada en una tabla:
t = {}
s = "desde = mundo, a = Lua"
para k, v en string.gmatch (s, "(% w +) = (% w +)") do
t [k] = v
fin
Para esta función, un signo de intercalación '^' al comienzo de un patrón no funciona como un ancla, ya que esto
evitaría la
iteración.
string.gsub (s, patrón, repl [, n])
Devuelve una copia de s en la que todas (o las primeras n, si se dan) ocurrencias del patrón (ver §6.4.1 ) han sido
reemplazado por una cadena de reemplazo especificada por repl, que puede ser una cadena, una tabla o una función.
gsub también
devuelve, como segundo valor, el número total de coincidencias que se produjeron. El nombre gsub proviene de
Global
SUSTITUCIÓN .
Si repl es una cadena, entonces su valor se usa para reemplazo. El carácter% funciona como carácter de escape:
cualquiera
la secuencia en réplica de la forma% d , con d entre 1 y 9, representa el valor de la subcadena d -ésima capturada; la
la secuencia% 0 representa la coincidencia completa; la secuencia %% representa un solo%.
Si repl es una tabla, entonces se consulta la tabla para cada coincidencia, utilizando la primera captura como clave.
Si repl es una función, esta función se llama cada vez que se produce una coincidencia, con todas las subcadenas
capturadas pasadas como
argumentos, en orden.
En cualquier caso, si el patrón no especifica capturas, entonces se comporta como si todo el patrón estuviera dentro
de una captura.
Si el valor devuelto por la consulta de la tabla o por la llamada a la función es una cadena o un número, entonces se
usa como
cadena de reemplazo; de lo contrario, si es falso o nulo , entonces no hay reemplazo (es decir, la coincidencia
original se mantiene en
la cuerda).
Aquí hay unos ejemplos:
x = string.gsub ("hola mundo", "(% w +)", "% 1% 1")
-> x = "hola hola mundo mundo"
x = string.gsub ("hola mundo", "% w +", "% 0% 0", 1)
-> x = "hola hola mundo"
x = string.gsub ("hola mundo desde Lua", "(% w +)% s * (% w +)", "% 2% 1")
-> x = "mundo hola Lua de"
x = string.gsub ("inicio = $ INICIO, usuario = $ USUARIO", "% $ (% w +)", os.getenv)
-> x = "casa = / casa / roberto, usuario = roberto"
x = string.gsub ("4 + 5 = $ return 4 + 5 $", "% $ (.-)% $", función (es)
devolver carga (s) ()
fin)
-> x = "4 + 5 = 9"
local t = {nombre = "lua", versión = "5.4"}
x = string.gsub ("$ nombre- $ versión.tar.gz", "% $ (% w +)", t)

Página 66
-> x = "lua-5.4.tar.gz"
string.len (s)
Recibe una cadena y devuelve su longitud. La cadena vacía "" tiene una longitud de 0. Los ceros incrustados se
cuentan, por lo que
"a \ 000bc \ 000" tiene una longitud de 5.
string.lower (s)
Recibe una cadena y devuelve una copia de esta cadena con todas las letras mayúsculas cambiadas a minúsculas.
Todos los demás
los caracteres no se modifican. La definición de qué es una letra mayúscula depende de la configuración regional
actual.
string.match (s, patrón [, init])
Busca la primera coincidencia del patrón (consulte§6.4.1 ) en la cadena s. Si encuentra uno, la coincidencia devuelve
el
capturas del patrón; de lo contrario, vuelve a fallar . Si el patrón no especifica capturas, entonces toda la coincidencia
es
regresó. Un tercer argumento numérico opcional init especifica dónde comenzar la búsqueda; su valor
predeterminado es 1 y
puede ser negativo.
string.pack (fmt, v1, v2, ···)
Devuelve una cadena binaria que contiene los valores v1, v2, etc. serializados en forma binaria (empaquetados) de
acuerdo con el
formato de cadena fmt (ver §6.4.2 ).
string.packsize (fmt)
Devuelve el tamaño de una cadena resultante de string.pack con el formato dado. La cadena de formato no puede
tener la
opciones de longitud variable 's' o 'z' (ver §6.4.2 ).
string.rep (s, n [, sep])
Devuelve una cadena que es la concatenación de n copias de la cadena s separadas por la cadena sep. El valor por
defecto
el valor de sep es la cadena vacía (es decir, sin separador). Devuelve la cadena vacía si n no es positivo.
(Tenga en cuenta que es muy fácil agotar la memoria de su máquina con una sola llamada a esta función).
string.reverse (s)
Devuelve una cadena que es la cadena s invertida.
string.sub (s, i [, j])
Devuelve la subcadena de s que comienza en i y continúa hasta j; i y j pueden ser negativos. Si j está ausente,
entonces es
se supone que es igual a -1 (que es lo mismo que la longitud de la cadena). En particular, la llamada string.sub (s, 1, j)
devuelve un prefijo de s con longitud j, y string.sub (s, -i) (para una i positiva) devuelve un sufijo de s con longitud i.
Si, después de la traducción de índices negativos, i es menor que 1, se corrige a 1. Si j es mayor que la longitud de la
cadena,
se corrige a esa longitud. Si, después de estas correcciones, i es mayor que j, la función devuelve la cadena vacía.
string.unpack (fmt, s [, pos])
Devuelve los valores empaquetados en la cadena s (ver string.pack ) de acuerdo con el formato string fmt
(ver§6.4.2 ). Un
pos opcionales marca dónde empezar a leer en s (el valor predeterminado es 1). Después de los valores leídos, esta
función también devuelve el
índice del primer byte no leído en s.
string.upper (s)
Recibe una cadena y devuelve una copia de esta cadena con todas las letras minúsculas cambiadas a mayúsculas.
Todos los demás
los caracteres no se modifican. La definición de qué es una letra minúscula depende de la ubicación actual.
6.4.1 - Patrones
Los patrones en Lua se describen mediante cadenas regulares, que se interpretan como patrones por la coincidencia
de patrones
funciones string.find , string.gmatch, string.gsub ystring.match. Esta sección describe el
sintaxis y el significado (es decir, con lo que coinciden) de estas cadenas.

Página 67
Clase de personaje:
Una clase de caracteres se utiliza para representar un conjunto de caracteres. Se permiten las siguientes
combinaciones para describir un
clase de personaje:
x : (donde x no es uno de los caracteres mágicos ^ $ ()%. [] * + -?) representa el propio carácter x .
.: (un punto) representa todos los caracteres.
% a: representa todas las letras.
% c: representa todos los caracteres de control.
% d: representa todos los dígitos.
% g: representa todos los caracteres imprimibles excepto el espacio.
% l: representa todas las letras minúsculas.
% p: representa todos los caracteres de puntuación.
% s: representa todos los caracteres de espacio.
% u: representa todas las letras mayúsculas.
% w: representa todos los caracteres alfanuméricos.
% x: representa todos los dígitos hexadecimales.
% x : (donde x es cualquier carácter no alfanumérico) representa el carácter x . Esta es la forma estándar de
escapar de los personajes mágicos. Cualquier carácter no alfanumérico (incluidos todos los caracteres de puntuación,
incluso
lo no mágico) puede ir precedido de un '%' para representarse a sí mismo en un patrón.
[ conjunto ]: representa la clase que es la unión de todos los personajes del conjunto . Una variedad de caracteres
puede ser
especificado separando los caracteres finales del rango, en orden ascendente, con un '-'. Todas las clases% x
descrito anteriormente también se puede utilizar como componentes en el conjunto . Todos los demás personajes del
set se representan a sí mismos.
Por ejemplo, [% w_] (o [_% w]) representa todos los caracteres alfanuméricos más el guión bajo, [0-7]
representa los dígitos octales, y [0-7% l% -] representa los dígitos octales más las letras minúsculas más el '-'
personaje.
Puede poner un corchete de cierre en un conjunto colocándolo como el primer carácter del conjunto. Puedes poner un
guión en un conjunto colocándolo como el primer o el último carácter del conjunto. (También puede usar un escape
para
ambos casos.)
La interacción entre rangos y clases no está definida. Por lo tanto, patrones como [% az] o [a - %%] tienen
sin significado.
[^ set ]: representa el complemento de set , donde set se interpreta como arriba.
Para todas las clases representadas por letras simples (% a,% c, etc.), la letra mayúscula correspondiente representa la
complemento de la clase. Por ejemplo,% S representa todos los caracteres que no son espacios.
Las definiciones de letras, espacios y otros grupos de caracteres dependen de la configuración regional actual. En
particular, la clase
[az] puede no ser equivalente a% l.
Elemento de patrón:
Un elemento de patrón puede ser
una clase de carácter único, que coincide con cualquier carácter de la clase;
una clase de un solo carácter seguida de '*', que coincide con secuencias de cero o más caracteres en la clase.
Estos elementos de repetición siempre coincidirán con la secuencia más larga posible;
una clase de un solo carácter seguida de '+', que coincide con las secuencias de uno o más caracteres de la clase.
Estos elementos de repetición siempre coincidirán con la secuencia más larga posible;
una clase de un solo carácter seguida de '-', que también coincide con secuencias de cero o más caracteres en el
clase. A diferencia de '*', estos elementos de repetición siempre coincidirán con la secuencia más corta posible;
una clase de un solo carácter seguida de '?', que coincide con cero o una aparición de un carácter en la clase. Eso
siempre coincide con una ocurrencia si es posible;
% n , para n entre 1 y 9; tal elemento coincide con una subcadena igual a la n -ésima cadena capturada (ver más
abajo);
% b xy , donde x y y son dos caracteres distintos; tal elemento coincide con cadenas que comienzan con x , terminan
con y , y
donde las x y y están equilibrados . Esto significa que, si uno lee la cadena de izquierda a derecha, contando +1 para
un
x y -1 para una y , la y final es la primera y donde el recuento llega a 0. Por ejemplo, el elemento% b () coincide
expresiones con paréntesis equilibrados.
% f [ conjunto ], un patrón de frontera ; tal elemento coincide con una cadena vacía en cualquier posición de modo
que el siguiente carácter
pertenece al conjunto y el carácter anterior no pertenece al conjunto . El conjunto conjunto se interpreta como
anteriormente.
descrito. El principio y el final del tema se manejan como si fueran el carácter '\ 0'.

Página 68
Patrón:
Un patrón es una secuencia de elementos de patrón. Un signo de intercalación '^' al comienzo de un patrón ancla la
coincidencia en el
comienzo de la cadena de asunto. Un '$' al final de un patrón ancla la coincidencia al final de la cadena del asunto. A
otras posiciones, '^' y '$' no tienen un significado especial y se representan a sí mismos.
Capturas:
Un patrón puede contener subpatrones entre paréntesis; describen capturas . Cuando un partido tiene éxito, el
Las subcadenas de la cadena del sujeto que coinciden con las capturas se almacenan ( capturan ) para uso futuro. Las
capturas están numeradas
de acuerdo con el paréntesis izquierdo. Por ejemplo, en el patrón "(a * (.)% W (% s *))", la parte de la cadena
la coincidencia "a * (.)% w (% s *)" se almacena como la primera captura y, por lo tanto, tiene el número 1; la
coincidencia de caracteres
"." se captura con el número 2, y la parte que coincide con "% s *" tiene el número 3.
Como caso especial, capture () captura la posición actual de la cadena (un número). Por ejemplo, si aplicamos el
patrón "() aa ()" en la cadena "flaaap", habrá dos capturas: 3 y 5.
Múltiples partidos:
La función string.gsub y el iteradorstring.gmatch coincide con múltiples ocurrencias del patrón dado en
el tema. Para estas funciones, una nueva coincidencia se considera válida solo si termina al menos un byte después
del final de
el partido anterior. En otras palabras, la máquina de patrones nunca acepta la cadena vacía como una coincidencia
inmediatamente.
después de otro partido. Como ejemplo, considere los resultados del siguiente código:
> string.gsub ("abc", "() a * ()", imprimir);
-> 1 2
-> 3 3
-> 4 4
El segundo y tercer resultado provienen de que Lua empareja una cadena vacía después de 'b' y otra después de 'c'.
Lua hace
no coincidir con una cadena vacía después de 'a', porque terminaría en la misma posición de la coincidencia anterior.
6.4.2 - Cadenas de formato para empaquetar y desempaquetar
El primer argumento para string.pack , string.packsize ystring.unpack es una cadena de formato, que
describe el diseño de la estructura que se está creando o leyendo.
Una cadena de formato es una secuencia de opciones de conversión. Las opciones de conversión son las siguientes:
<: establece little endian
>: establece big endian
=: establece endian nativo
! [ n ]: establece la alineación máxima en n (el valor predeterminado es la alineación nativa)
b: un byte firmado (char)
B: un byte sin firmar (char)
h: un corto firmado (tamaño nativo)
H: un short sin firmar (tamaño nativo)
l: largo firmado (tamaño nativo)
L: largo sin firmar (tamaño nativo)
j: un lua_Integer
J: a lua_Unsigned
T: a size_t (tamaño nativo)
i [ n ]: un int firmado con n bytes (el tamaño predeterminado es el nativo)
I [ n ]: un int sin firmar con n bytes (el tamaño predeterminado es el nativo)
f: un flotador (tamaño nativo)
d: un doble (tamaño nativo)
n: a lua_Number
c n : una cadena de tamaño fijo con n bytes
z: una cadena terminada en cero
s [ n ]: una cadena precedida por su longitud codificada como un entero sin signo con n bytes (el valor
predeterminado es size_t)
x: un byte de relleno
X op : un elemento vacío que se alinea de acuerdo con la opción op (que de lo contrario se ignora)
'': (espacio) ignorado

Página 69
(Un "[ n ]" significa un número integral opcional). Excepto por el relleno, los espacios y las configuraciones
(opciones "xX
<=>! "), cada opción corresponde a un argumento en string.pack o un resultado enstring.unpack .
Para las opciones "! N ", "s n ", "i n " y "I n ", n puede ser cualquier número entero entre 1 y 16. Todas las opciones
integrales verifican
desbordes; string.pack comprueba si el valor dado se ajusta al tamaño dado; string.unpack comprueba si
el valor leído cabe en un entero Lua. Para las opciones sin firmar, los enteros Lua también se tratan como valores sin
firmar.
Cualquier cadena de formato comienza con el prefijo "! 1 =", es decir, con una alineación máxima de 1 (sin
alineación) y nativa
endianidad.
El endianismo nativo asume que todo el sistema es endian grande o pequeño. Las funciones de embalaje no
emular correctamente el comportamiento de formatos endian mixtos.
La alineación funciona de la siguiente manera: para cada opción, el formato obtiene un relleno adicional hasta que los
datos comienzan en un desplazamiento que es
un múltiplo del mínimo entre el tamaño de la opción y la alineación máxima; este mínimo debe ser un poder de
2. Las opciones "c" y "z" no están alineadas; la opción "s" sigue la alineación de su número entero inicial.
Todo el relleno se rellena con ceros por string.pack y se ignora porstring.unpack .
6.5 - Soporte UTF-8
Esta biblioteca proporciona soporte básico para la codificación UTF-8. Proporciona todas sus funciones dentro de la
tabla utf8. Esta
La biblioteca no proporciona ningún soporte para Unicode que no sea el manejo de la codificación. Cualquier
operación que
necesita el significado de un carácter, como la clasificación de caracteres, está fuera de su alcance.
A menos que se indique lo contrario, todas las funciones que esperan una posición de byte como parámetro asumen
que la posición dada es
ya sea el comienzo de una secuencia de bytes o uno más la longitud de la cadena de asunto. Como en la biblioteca de
cadenas, negativo
los índices cuentan desde el final de la cadena.
Las funciones que crean secuencias de bytes aceptan todos los valores hasta 0x7FFFFFFF, como se define en el UTF-
8 original
especificación; eso implica secuencias de bytes de hasta seis bytes.
Las funciones que interpretan secuencias de bytes solo aceptan secuencias válidas (bien formadas y no demasiado
largas). Por defecto,
solo aceptan secuencias de bytes que dan como resultado puntos de código Unicode válidos, rechazando valores
superiores a 10FFFF
y sustitutos. Un argumento booleano laxo, cuando está disponible, levanta estas comprobaciones, de modo que todos
los valores hasta 0x7FFFFFFF
son aceptados. (Las secuencias no bien formadas y demasiado largas todavía se rechazan).
utf8.char (···)
Recibe cero o más números enteros, convierte cada uno en su secuencia de bytes UTF-8 correspondiente y devuelve
un
cadena con la concatenación de todas estas secuencias.
utf8.charpattern
El patrón (una cadena, no una función) "[\ 0- \ x7F \ xC2- \ xFD] [\ x80- \ xBF] *" (ver §6.4.1 ), que coincide
exactamente una secuencia de bytes UTF-8, asumiendo que el sujeto es una cadena UTF-8 válida.
utf8.codes (s [, laxo])
Devuelve valores para que la construcción
para p, c en utf8 code (s) do body end
iterará sobre todos los caracteres UTF-8 en la cadena s, siendo p la posición (en bytes) yc el punto de código de cada
personaje. Genera un error si encuentra alguna secuencia de bytes no válida.
utf8.codepoint (s [, i [, j [, laxo]]])
Devuelve los puntos de código (como números enteros) de todos los caracteres en s que comienzan entre la posición
del byte i y j (ambos
incluido). El valor predeterminado para i es 1 y para j es i. Genera un error si encuentra alguna secuencia de bytes no
válida.
utf8.len (s [, i [, j [, flojo]]])
Devuelve el número de caracteres UTF-8 en la cadena s que comienzan entre las posiciones i y j (ambas inclusive).
los
el valor predeterminado para i es 1 y para j es -1. Si encuentra alguna secuencia de bytes inválida, los retornos fallan
más la posición de la primera inválida
byte.

Página 70
utf8.offset (s, n [, i])
Devuelve la posición (en bytes) donde comienza la codificación del enésimo carácter de s (contando desde la
posición i). A
n negativa obtiene caracteres antes de la posición i. El valor predeterminado para i es 1 cuando n no es negativo y #s
+ 1 en caso contrario,
de modo que utf8.offset (s, -n) obtiene el desplazamiento del n-ésimo carácter desde el final de la cadena. Si el
especificado
El carácter no está en el sujeto ni justo después de su final, la función devuelve falla .
Como caso especial, cuando n es 0 la función devuelve el inicio de la codificación del carácter que contiene el i-
ésimo
byte de s.
Esta función asume que s es una cadena UTF-8 válida.
6.6 - Manipulación de tablas
Esta biblioteca proporciona funciones genéricas para la manipulación de tablas. Proporciona todas sus funciones
dentro de la tabla table.
Recuerde que, siempre que una operación necesite la longitud de una tabla, se aplican todas las advertencias sobre el
operador de longitud
(ver §3.4.7 ). Todas las funciones ignoran las teclas no numéricas en las tablas dadas como argumentos.
table.concat (lista [, sep [, i [, j]]])
Dada una lista donde todos los elementos son cadenas o números, devuelve la lista de cadenas [i] .. sep..list [i + 1] ···
sep..list [j]. El valor predeterminado para sep es la cadena vacía, el predeterminado para i es 1 y el predeterminado
para j es
#lista. Si i es mayor que j, devuelve la cadena vacía.
table.insert (lista, [pos,] valor)
Inserta el valor del elemento en la posición pos en la lista, desplazando hacia arriba la lista de elementos [pos], lista
[pos + 1], ···,
lista [#lista]. El valor predeterminado para pos es # lista + 1, de modo que una tabla de llamada.insertar (t, x) inserta x
al final de
la lista t.
table.move (a1, f, e, t [, a2])
Mueve elementos de la tabla a1 a la tabla a2, realizando el equivalente a la siguiente asignación múltiple:
a2 [t], ··· = a1 [f], ···, a1 [e]. El valor predeterminado para a2 es a1. El rango de destino puede superponerse con el
origen
abarcar. El número de elementos que se moverán debe caber en un entero Lua.
Devuelve la tabla de destino a2.
table.pack (···)
Devuelve una nueva tabla con todos los argumentos almacenados en las claves 1, 2, etc. y con un campo "n" con el
número total de
argumentos. Tenga en cuenta que la tabla resultante puede no ser una secuencia, si algunos argumentos son nulos .
table.remove (lista [, pos])
Elimina de la lista el elemento en la posición pos, devolviendo el valor del elemento eliminado. Cuando pos es un
entero entre 1 y # lista, se desplaza hacia abajo en la lista de elementos [pos + 1], lista [pos + 2], ···,
lista [#lista] y borra la lista de elementos [#lista]; La posición del índice también puede ser 0 cuando #list es 0, o #list
+
1.
El valor predeterminado para pos es #list, por lo que una llamada table.remove (l) elimina el último elemento de la
lista l.
table.sort (lista [, comp])
Ordena los elementos de la lista en un orden determinado, in situ , de la lista [1] a la lista [#lista]. Si se da una
compensación, entonces debe ser
una función que recibe dos elementos de lista y devuelve verdadero cuando el primer elemento debe ir antes que el
segundo en
el orden final (de modo que, después de la clasificación, i <j implica no comp (lista [j], lista [i])). Si no se da la
compensación, entonces
en su lugar se utiliza el operador estándar de Lua <.
Tenga en cuenta que la función comp debe definir un orden parcial estricto sobre los elementos de la lista; es decir,
debe ser
asimétrico y transitivo. De lo contrario, es posible que no sea posible una clasificación válida.
El algoritmo de clasificación no es estable: los elementos considerados iguales por el orden dado pueden tener sus
posiciones relativas
cambiado por el tipo.

Página 71
table.unpack (lista [, i [, j]])
Devuelve los elementos de la lista dada. Esta función es equivalente a
lista de retorno [i], lista [i + 1], ···, lista [j]
De forma predeterminada, i es 1 y j es #list.
6.7 - Funciones matemáticas
Esta biblioteca proporciona funciones matemáticas básicas. Proporciona todas sus funciones y constantes dentro de la
tabla matemática.
Las funciones con la anotación "integer / float" dan resultados enteros para argumentos enteros y resultados flotantes
para
argumentos no enteros. Las funciones de redondeomath.ceil , math.floor ymath.modf devuelve un entero
cuando el resultado se ajusta al rango de un número entero, o un flotante de lo contrario.
math.abs (x)
Devuelve el valor máximo entre x y -x. (entero / flotante)
math.acos (x)
Devuelve el arco coseno de x (en radianes).
matemáticas.asin (x)
Devuelve el arco seno de x (en radianes).
math.atan (y [, x])
Devuelve el arco tangente de y / x (en radianes), pero usa los signos de ambos argumentos para encontrar el cuadrante
del
resultado. También maneja correctamente el caso de que x sea cero.
El valor predeterminado para x es 1, por lo que la llamada math.atan (y) devuelve el arco tangente de y.
math.ceil (x)
Devuelve el valor integral más pequeño mayor o igual que x.
math.cos (x)
Devuelve el coseno de x (se supone que está en radianes).
math.deg (x)
Convierte el ángulo x de radianes a grados.
math.exp (x)
Devuelve el valor e x (donde e es la base de los logaritmos naturales).
matemáticas.floor (x)
Devuelve el mayor valor integral menor o igual ax.
math.fmod (x, y)
Devuelve el resto de la división de x por y que redondea el cociente hacia cero. (entero / flotante)
matemáticas enorme
El valor flotante HUGE_VAL, un valor mayor que cualquier otro valor numérico.
math.log (x [, base])
Devuelve el logaritmo de x en la base dada. El valor predeterminado para base es e (de modo que la función devuelve
el valor natural

Página 72
logaritmo de x).
math.max (x, ···)
Devuelve el argumento con el valor máximo, según el operador Lua <.
math.maxinteger
Un número entero con el valor máximo de un número entero.
matemáticas.min (x, ···)
Devuelve el argumento con el valor mínimo, según el operador Lua <.
Math.mininteger
Un número entero con el valor mínimo de un número entero.
math.modf (x)
Devuelve la parte integral de x y la parte fraccionaria de x. Su segundo resultado es siempre un flotador.
math.pi
El valor de π .
math.rad (x)
Convierte el ángulo x de grados a radianes.
math.random ([m [, n]])
Cuando se llama sin argumentos, devuelve un flotante pseudoaleatorio con distribución uniforme en el rango [0,1) .
Cuando
llamado con dos enteros myn, math.random devuelve un entero pseudoaleatorio con distribución uniforme en el
rango [m, n] . La llamada math.random (n), para una n positiva, es equivalente a math.random (1, n). La llamada
math.random (0) produce un número entero con todos los bits (pseudo) aleatorios.
Esta función utiliza el algoritmo xoshiro256 ** para producir enteros pseudoaleatorios de 64 bits, que son los
resultados
de llamadas con argumento 0. Otros resultados (rangos y flotantes) se extraen sin sesgo de estos enteros.
Lua inicializa su generador pseudoaleatorio con el equivalente a una llamada a math.randomseed sin argumentos,
de modo que math.random debería generar diferentes secuencias de resultados cada vez que se ejecuta el programa.
math.randomseed ([x [, y]])
Cuando se llama con al menos un argumento, los parámetros enteros xey se unen en una semilla de 128 bits que se
usa
reinicializar el generador pseudoaleatorio; semillas iguales producen secuencias iguales de números. El valor
predeterminado para y
es cero.
Cuando se llama sin argumentos, Lua genera una semilla con un intento débil de aleatoriedad.
Esta función devuelve los dos componentes semilla que se usaron efectivamente, de modo que al configurarlos
nuevamente se repite la
secuencia.
Para asegurar un nivel requerido de aleatoriedad para el estado inicial (o por el contrario, para tener una secuencia
determinista, por
instancia al depurar un programa), debe llamar math.randomseed con argumentos explícitos.
matemáticas.pecado (x)
Devuelve el seno de x (se supone que está en radianes).
matemáticas.sqrt (x)
Devuelve la raíz cuadrada de x. (También puede usar la expresión x ^ 0.5 para calcular este valor).
matemáticas.tan (x)

Página 73
Devuelve la tangente de x (se supone que está en radianes).
matemáticas.tointeger (x)
Si el valor x se puede convertir en un número entero, devuelve ese número entero. De lo contrario, las devoluciones
fallan .
math.type (x)
Devuelve "entero" si x es un número entero, "flotante" si es un número flotante o falla si x no es un número.
matemáticas.ult (m, n)
Devuelve un valor booleano, verdadero si y solo si el entero m está por debajo del entero n cuando se comparan como
enteros sin signo.
6.8 - Instalaciones de entrada y salida
La biblioteca de E / S proporciona dos estilos diferentes para la manipulación de archivos. El primero usa
identificadores de archivos implícitos; eso es,
hay operaciones para establecer un archivo de entrada predeterminado y un archivo de salida predeterminado, y todas
las operaciones de entrada / salida se realizan
sobre estos archivos predeterminados. El segundo estilo utiliza identificadores de archivo explícitos.
Cuando se utilizan identificadores de archivo implícitos, todas las operaciones las proporciona la tabla io. Cuando se
utilizan identificadores de archivo explícitos,
operación io.open devuelve un identificador de archivo y luego todas las operaciones se proporcionan como métodos
del identificador de archivo.
La metatabla para identificadores de archivos proporciona metamétodos para __gc y __close que intentan cerrar el
archivo cuando se llama.
La tabla io también proporciona tres identificadores de archivos predefinidos con sus significados habituales de C:
io.stdin,
io.stdout y io.stderr. La biblioteca de E / S nunca cierra estos archivos.
A menos que se indique lo contrario, todas las funciones de E / S fallan en caso de falla, más un mensaje de error
como segundo resultado y un
código de error dependiente del sistema como tercer resultado y algún valor no falso en caso de éxito. En sistemas
que no son POSIX,
el cálculo del mensaje de error y el código de error en caso de errores puede no ser seguro para subprocesos, porque
se basan en
en la variable C global errno.
io.close ([archivo])
Equivalente a archivo: close (). Sin un archivo, cierra el archivo de salida predeterminado.
io.flush ()
Equivalente a io.output (): flush ().
io.input ([archivo])
Cuando se llama con un nombre de archivo, abre el archivo con nombre (en modo texto) y establece su identificador
como archivo de entrada predeterminado.
Cuando se llama con un identificador de archivo, simplemente establece este identificador de archivo como el archivo
de entrada predeterminado. Cuando se llama sin
argumentos, devuelve el archivo de entrada predeterminado actual.
En caso de errores, esta función genera el error, en lugar de devolver un código de error.
io.lines ([nombre de archivo, ···])
Abre el nombre de archivo dado en modo lectura y devuelve una función de iterador que funciona como archivo:
líneas (···) sobre
el archivo abierto. Cuando la función del iterador no puede leer ningún valor, cierra automáticamente el archivo.
junto al
función de iterador, io.lines devuelve otros tres valores: dos valores nulos como marcadores de posición, más el
archivo creado
encargarse de. Por lo tanto, cuando se utiliza en un bucle for genérico , el archivo también se cierra si el bucle es
interrumpido por un error o un
romper .
La llamada io.lines () (sin nombre de archivo) es equivalente a io.input (): lines ("l"); es decir, itera sobre el
líneas del archivo de entrada predeterminado. En este caso, el iterador no cierra el archivo cuando finaliza el ciclo.
En caso de errores al abrir el archivo, esta función genera el error, en lugar de devolver un código de error.
io.open (nombre de archivo [, modo])
Esta función abre un archivo, en el modo especificado en el modo de cadena. En caso de éxito, devuelve un nuevo
identificador de archivo.

Página 74
La cadena de modo puede ser cualquiera de las siguientes:
"r": modo de lectura (predeterminado);
"w": modo de escritura;
"a": modo de adición;
"r +": modo de actualización, se conservan todos los datos anteriores;
"w +": modo de actualización, se borran todos los datos anteriores;
"a +": añadir modo de actualización, se conservan los datos anteriores, solo se permite escribir al final del archivo.
La cadena de modo también puede tener una 'b' al final, que es necesaria en algunos sistemas para abrir el archivo en
modo binario.
io.output ([archivo])
Similar a io.input , pero opera sobre el archivo de salida predeterminado.
io.popen (prog [, modo])
Esta función depende del sistema y no está disponible en todas las plataformas.
Inicia el programa prog en un proceso separado y devuelve un identificador de archivo que puede usar para leer datos
de este
programa (si el modo es "r", el valor predeterminado) o para escribir datos en este programa (si el modo es "w").
io.read (···)
Equivalente a io.input (): read (···).
io.tmpfile ()
En caso de éxito, devuelve un identificador para un archivo temporal. Este archivo se abre en modo de actualización
y se
eliminado cuando finaliza el programa.
io.type (obj)
Comprueba si obj es un identificador de archivo válido. Devuelve la cadena "archivo" si obj es un identificador de
archivo abierto, "cerrado
file "si obj es un identificador de archivo cerrado, o falla si obj no es un identificador de archivo.
io.write (···)
Equivalente a io.output (): write (···).
archivo: cerrar ()
Cierra el archivo. Tenga en cuenta que los archivos se cierran automáticamente cuando sus identificadores se
recolectan como basura, pero eso requiere
cantidad de tiempo impredecible para suceder.
Al cerrar un identificador de archivo creado con io.popen , file: close devuelve los mismos valores devueltos por
os.execute .
archivo: flush ()
Guarda cualquier dato escrito en un archivo.
archivo: líneas (···)
Devuelve una función de iterador que, cada vez que se llama, lee el archivo de acuerdo con los formatos dados.
Cuando no
se proporciona el formato, utiliza "l" por defecto. Como ejemplo, la construcción
para c en el archivo: las líneas (1) hacen el final del cuerpo
iterará sobre todos los caracteres del archivo, comenzando en la posición actual. A diferencia de io.lines , esta función
no
cierre el archivo cuando finalice el ciclo.
archivo: leer (···)
Lee el archivo de archivo, de acuerdo con los formatos dados, que especifican qué leer. Para cada formato, la función
devuelve una cadena o un número con los caracteres leídos, o falla si no puede leer datos con el formato
especificado. (En esto

Página 75
último caso, la función no lee los formatos subsiguientes.) Cuando se llama sin argumentos, utiliza un
formato que lee la siguiente línea (ver más abajo).
Los formatos disponibles son
"n": lee un numeral y lo devuelve como un float o un entero, siguiendo las convenciones léxicas de Lua. (Los
el número puede tener espacios en blanco iniciales y un signo.) Este formato siempre lee la secuencia de entrada más
larga
ese es un prefijo válido para un numeral; si ese prefijo no forma un número válido (por ejemplo, una cadena vacía,
"0x", o
"3.4e-") o es demasiado largo (más de 200 caracteres), se descarta y los retornos de formato fallan .
"a": lee el archivo completo, comenzando en la posición actual. Al final del archivo, devuelve la cadena vacía; esta
el formato nunca falla.
"l": lee la siguiente línea saltando el final de la línea, devolviendo el error al final del archivo. Este es el formato por
defecto.
"L": lee la siguiente línea manteniendo el carácter de fin de línea (si está presente), devolviendo el error al final del
archivo.
número : lee una cadena con hasta este número de bytes y devuelve un error al final del archivo. Si el número es
cero,
no lee nada y devuelve una cadena vacía, o falla al final del archivo.
Los formatos "l" y "L" deben usarse solo para archivos de texto.
archivo: buscar ([de donde [, desplazamiento]])
Establece y obtiene la posición del archivo, medida desde el principio del archivo, hasta la posición dada por el
desplazamiento más un
base especificada por la cadena de donde, como sigue:
"set": la base es la posición 0 (comienzo del archivo);
"cur": la base es la posición actual;
"end": la base es el final del archivo;
En caso de éxito, seek devuelve la posición final del archivo, medida en bytes desde el principio del archivo. Si busca
falla, devuelve fail , más una cadena que describe el error.
El valor predeterminado para donde es "cur" y para el desplazamiento es 0. Por lo tanto, el archivo de llamada: seek
() devuelve el
posición actual del archivo, sin cambiarlo; el archivo de llamada: seek ("set") establece la posición al principio del
archivo
(y devuelve 0); y el archivo de llamada: seek ("end") establece la posición al final del archivo y devuelve su tamaño.
archivo: setvbuf (modo [, tamaño])
Establece el modo de almacenamiento en búfer de un archivo. Hay tres modos disponibles:
"no": sin almacenamiento en búfer.
"full": almacenamiento en búfer completo.
"línea": búfer de línea.
Para los dos últimos casos, el tamaño es una sugerencia del tamaño del búfer, en bytes. El tamaño predeterminado es
apropiado.
El comportamiento específico de cada modo no es portátil; compruebe la función subyacente ISO C setvbuf en su
plataforma para más detalles.
archivo: escribir (···)
Escribe el valor de cada uno de sus argumentos en el archivo. Los argumentos deben ser cadenas o números.
En caso de éxito, esta función devuelve archivo.
6.9 - Instalaciones del sistema operativo
Esta biblioteca se implementa a través de table os.
os.clock ()
Devuelve una aproximación de la cantidad en segundos de tiempo de CPU utilizado por el programa, según lo
devuelto por el
reloj de función ISO C subyacente.
os.date ([formato [, hora]])
Devuelve una cadena o una tabla que contiene la fecha y la hora, formateada según el formato de cadena dado.

Página 76
Si el argumento de tiempo está presente, este es el tiempo para ser formateado (vea la función os.time para una
descripción de este
valor). De lo contrario, la fecha formatea la hora actual.
Si el formato comienza con '!', La fecha se formatea en Hora universal coordinada. Después de este carácter opcional,
si
el formato es la cadena "* t", luego la fecha devuelve una tabla con los siguientes campos: año, mes (1–12), día (1–
31),
hora (0-23), min (0-59), seg (0-61, debido a los segundos bisiestos), wday (día de la semana, 1-7, el domingo es 1),
yday (día del
year, 1–366) e isdst (indicador de horario de verano, un valor booleano). Este último campo puede estar ausente si la
información no está
disponible.
Si el formato no es "* t", la fecha devuelve la fecha como una cadena, formateada de acuerdo con las mismas reglas
que ISO C
función strftime.
Si el formato está ausente, el valor predeterminado es "% c", lo que proporciona una representación de fecha y hora
legible por humanos mediante el
localidad actual.
En sistemas que no son POSIX, esta función puede no ser segura para subprocesos debido a su dependencia de la
función C gmtime y
C función localtime.
os.difftime (t2, t1)
Devuelve la diferencia, en segundos, del tiempo t1 al tiempo t2 (donde los tiempos son valores devueltos por
os.time ). En
POSIX, Windows y algunos otros sistemas, este valor es exactamente t2 - t1.
os.execute ([comando])
Esta función es equivalente al sistema de funciones ISO C. Pasa un comando para ser ejecutado por un operador
shell del sistema. Su primer resultado es verdadero si el comando terminó con éxito o falla en caso contrario.
Después de este primer resultado
la función devuelve una cadena más un número, como sigue:
"salir": el comando terminó normalmente; el siguiente número es el estado de salida del comando.
"señal": el comando terminó con una señal; el siguiente número es la señal que terminó el
mando.
Cuando se llama sin un comando, os.execute devuelve un booleano que es verdadero si hay un shell disponible.
os.exit ([código [, cerrar]])
Llama a la función ISO C exit para terminar el programa anfitrión. Si el código es verdadero , el estado devuelto es
EXIT_SUCCESS; si el código es falso , el estado devuelto es EXIT_FAILURE; si el código es un número, el estado
devuelto
es este número. El valor predeterminado del código es verdadero .
Si el segundo argumento opcional close es verdadero, cierra el estado Lua antes de salir.
os.getenv (varname)
Devuelve el valor de la variable de entorno del proceso varname o falla si la variable no está definida.
os.remove (nombre de archivo)
Elimina el archivo (o directorio vacío, en sistemas POSIX) con el nombre dado. Si esta función falla, devuelve fail
más una cadena que describe el error y el código de error. De lo contrario, devuelve verdadero.
os.rename (nombre antiguo, nombre nuevo)
Cambia el nombre del archivo o directorio llamado oldname a newname. Si esta función falla, devuelve falla , más
una cadena
describiendo el error y el código de error. De lo contrario, devuelve verdadero.
os.setlocale (locale [, categoría])
Establece la configuración regional actual del programa. locale es una cadena dependiente del sistema que especifica
una locale; la categoría es una
cadena opcional que describe qué categoría cambiar: "todos", "cotejar", "ctype", "monetario", "numérico",
o "tiempo"; la categoría predeterminada es "todos". La función devuelve el nombre de la nueva configuración
regional o falla si la solicitud
no se puede honrar.
Si locale es la cadena vacía, la locale actual se establece en una locale nativa definida por la implementación. Si la
localidad es la
cadena "C", la configuración regional actual se establece en la configuración regional C estándar.

Página 77
Cuando se llama con nil como primer argumento, esta función solo devuelve el nombre de la configuración regional
actual para el
categoría.
Es posible que esta función no sea segura para subprocesos debido a su dependencia de la función C setlocale.
os.time ([tabla])
Devuelve la hora actual cuando se llama sin argumentos, o una hora que representa la fecha y hora locales
especificadas
por la tabla dada. Esta tabla debe tener campos año, mes y día, y puede tener campos hora (el valor predeterminado es
12),
min (el valor predeterminado es 0), sec (el valor predeterminado es 0) e isdst (el valor predeterminado es nulo ). Los
demás campos se ignoran. Para obtener una descripción de
estos campos, vea el función os.date .
Cuando se llama a la función, los valores en estos campos no necesitan estar dentro de sus rangos válidos. Por
ejemplo, si
seg es -10, significa 10 segundos antes del tiempo especificado por los otros campos; si la hora es 1000, significa
1000 horas
después del tiempo especificado por los otros campos.
El valor devuelto es un número, cuyo significado depende de su sistema. En POSIX, Windows y algunos otros
sistemas, este número cuenta el número de segundos desde una hora de inicio determinada (la "época"). En otros
sistemas,
el significado no está especificado, y el número devuelto por el tiempo se puede usar solo como un argumento para
os.date
y os.difftime .
Cuando se llama con una tabla, os.time también normaliza todos los campos documentados en la función os.date , de
modo que
representan el mismo tiempo que antes de la llamada pero con valores dentro de sus rangos válidos.
os.tmpname ()
Devuelve una cadena con un nombre de archivo que se puede utilizar para un archivo temporal. El archivo debe
abrirse explícitamente antes de su
utilizar y eliminar explícitamente cuando ya no sea necesario.
En los sistemas POSIX, esta función también crea un archivo con ese nombre, para evitar riesgos de seguridad.
(Alguien más podría
crear el archivo con permisos incorrectos en el tiempo entre obtener el nombre y crear el archivo).
abra el archivo para usarlo y eliminarlo (incluso si no lo usa).
Cuando sea posible, tal vez prefiera utilizar io.tmpfile , que elimina automáticamente el archivo cuando el programa
termina.
6.10 - La biblioteca de depuración
Esta biblioteca proporciona la funcionalidad de la interfaz de depuración (§4.7 ) a los programas Lua. Debes tener
cuidado cuando
usando esta biblioteca. Varias de sus funciones violan los supuestos básicos sobre el código Lua (por ejemplo, que las
variables locales a un
no se puede acceder a la función desde el exterior; que el código Lua no puede cambiar las metatablas de datos de
usuario; esa Lua
programas no se bloquean) y, por lo tanto, pueden comprometer el código seguro. Además, algunas funciones en este
la biblioteca puede ser lenta.
Todas las funciones de esta biblioteca se proporcionan dentro de la tabla de depuración. Todas las funciones que
operan sobre un hilo tienen un
primer argumento opcional que es el hilo sobre el que operar. El valor predeterminado es siempre el hilo actual.
debug.debug ()
Ingresa a un modo interactivo con el usuario, ejecutando cada cadena que ingresa el usuario. Usando comandos
simples y
otras funciones de depuración, el usuario puede inspeccionar variables globales y locales, cambiar sus valores,
evaluar expresiones,
etcétera. Una línea que contiene solo la palabra cont finaliza esta función, de modo que el llamador continúa su
ejecución.
Tenga en cuenta que los comandos para debug.debug no están anidados léxicamente dentro de ninguna función y, por
lo tanto, no tienen acceso directo
a las variables locales.
debug.gethook ([hilo])
Devuelve la configuración de gancho actual del hilo, como tres valores: la función de gancho actual, la máscara de
gancho actual,
y el recuento de ganchos actual, según lo establecido por función debug.sethook .
Las devoluciones fallan si no hay ningún gancho activo.
debug.getinfo ([hilo,] f [, qué])

Página 78
Devuelve una tabla con información sobre una función. Puede dar la función directamente o puede dar un número
como
el valor de f, que significa la función que se ejecuta en el nivel f de la pila de llamadas del subproceso dado: el nivel 0
es el
función actual (getinfo en sí); El nivel 1 es la función que llamó a getinfo (excepto para las llamadas de cola, que no
contar en la pila); etcétera. Si f es un número mayor que el número de funciones activas, entonces getinfo devuelve
fallar .
La tabla devuelta puede contener todos los campos devueltos por lua_getinfo , con la cadena que describe cual
campos para completar. El valor predeterminado para lo que es obtener toda la información disponible, excepto la
tabla de líneas válidas. Si está presente, el
la opción 'f' agrega un campo llamado func con la función en sí. Si está presente, la opción 'L' agrega un campo
llamado
activelines con la tabla de líneas válidas.
Por ejemplo, la expresión debug.getinfo (1, "n"). Name devuelve un nombre para la función actual, si un
Se puede encontrar un nombre razonable y la expresión debug.getinfo (imprimir) devuelve una tabla con todos los
disponibles.
información sobre la función de impresión .
debug.getlocal ([hilo,] f, local)
Esta función devuelve el nombre y el valor de la variable local con índice local de la función en el nivel f del
apilar. Esta función accede no solo a variables locales explícitas, sino también a parámetros y valores temporales.
El primer parámetro o variable local tiene índice 1, y así sucesivamente, siguiendo el orden en que se declaran en el
código,
contando solo las variables que están activas en el alcance actual de la función. Las constantes de tiempo de
compilación no pueden
aparecen en este listado, si fueron optimizados por el compilador. Los índices negativos se refieren a argumentos
vararg; -1
es el primer argumento vararg. La función devuelve un error si no hay una variable con el índice dado y genera un
error cuando se llama con un nivel fuera de rango. (Puedes llamardebug.getinfo para comprobar si el nivel es válido).
Los nombres de variable que comienzan con '(' (paréntesis abierto) representan variables sin nombres conocidos
(variables internas
como variables de control de bucle y variables de fragmentos guardados sin información de depuración).
El parámetro f también puede ser una función. En ese caso, getlocal devuelve solo el nombre de los parámetros de la
función.
debug.getmetatable (valor)
Devuelve la metatabla del valor dado o nil si no tiene una metatabla.
debug.getregistry ()
Devuelve la tabla de registro (ver §4.3 ).
debug.getupvalue (f, arriba)
Esta función devuelve el nombre y el valor del upvalue con índice up de la función f. La función regresa
fallará si no hay un valor al alza con el índice dado.
(Para las funciones Lua, los upvalues son las variables locales externas que usa la función y que, en consecuencia,
son
incluido en su cierre.)
Para las funciones de C, esta función usa la cadena vacía "" como nombre para todos los upvalues.
Nombre de la variable '?' (signo de interrogación) representa variables sin nombres conocidos (variables de
fragmentos guardados
sin información de depuración).
debug.getuservalue (u, n)
Devuelve el enésimo valor de usuario asociado a los datos de usuario u más un valor booleano, falso si los datos de
usuario no lo tienen.
valor.
debug.sethook ([hilo,] gancho, máscara [, recuento])
Establece la función dada como el gancho de depuración. La máscara de cuerda y el recuento de números describen
cuándo el gancho
ser llamado. La máscara de cadena puede tener cualquier combinación de los siguientes caracteres, con el significado
dado:
'c': el gancho se llama cada vez que Lua llama a una función;
'r': el gancho se llama cada vez que Lua regresa de una función;
'l': el gancho se llama cada vez que Lua ingresa una nueva línea de código.

Página 79
Además, con un conteo diferente de cero, el gancho también se llama después de cada instrucción de conteo.
Cuando se llama sin argumentos, debug.sethook desactiva el gancho.
Cuando se llama al gancho, su primer parámetro es una cadena que describe el evento que ha desencadenado su
llamada: "llamada",
"tail call", "return", "line" y "count". Para eventos de línea, el gancho también obtiene el nuevo número de línea como
su
segundo parámetro. Dentro de un gancho, puede llamar a getinfo con nivel 2 para obtener más información sobre la
ejecución
función. (El nivel 0 es la función getinfo y el nivel 1 es la función de gancho).
debug.setlocal ([hilo,] nivel, local, valor)
Esta función asigna el valor valor a la variable local con índice local de la función a nivel de nivel de la
apilar. La función devuelve un error si no hay una variable local con el índice dado y genera un error cuando se
llama
con un nivel fuera de rango. (Puede llamar a getinfo para verificar si el nivel es válido). De lo contrario, devuelve el
nombre de la variable local.
Consulte debug.getlocal para obtener más información sobre índices y nombres de variables.
debug.setmetatable (valor, tabla)
Establece la metatabla para el valor dado en la tabla dada (que puede ser nula ). Devuelve valor.
debug.setupvalue (f, arriba, valor)
Esta función asigna el valor de valor al upvalue con índice up de la función f. La función devuelve falla si
no hay ningún valor al alza con el índice dado. De lo contrario, devuelve el nombre del upvalue.
Consulte debug.getupvalue para obtener más información sobre upvalues.
debug.setuservalue (udata, valor, n)
Establece el valor dado como el enésimo valor de usuario asociado al udata dado. udata debe ser un userdata
completo.
Devuelve udata, o falla si los datos de usuario no tienen ese valor.
debug.traceback ([hilo,] [mensaje [, nivel]])
Si el mensaje está presente pero no es una cadena ni es nulo , esta función devuelve el mensaje sin más
procesamiento.
De lo contrario, devuelve una cadena con un seguimiento de la pila de llamadas. La cadena de mensaje opcional se
adjunta al
comienzo del rastreo. Un número de nivel opcional indica en qué nivel iniciar el rastreo (el valor predeterminado es
1, el
función que llama a traceback).
debug.upvalueid (f, n)
Devuelve un identificador único (como datos de usuario ligeros) para el valor superior numerado n de la función
dada.
Estos identificadores únicos permiten que un programa verifique si diferentes cierres comparten valores positivos.
Lua cierra que
compartir un upvalue (es decir, que acceda a una misma variable local externa) devolverá identificadores idénticos
para esos upvalue
índices.
debug.upvaluejoin (f1, n1, f2, n2)
Haga que el n1-ésimo valor de subida del cierre Lua f1 se refiera al n2-ésimo valor de subida del cierre Lua f2.

7 - Lua independiente
Aunque Lua ha sido diseñado como un lenguaje de extensión, para integrarse en un programa anfitrión en C, también
es
se utiliza con frecuencia como idioma independiente. Un intérprete de Lua como idioma independiente, llamado
simplemente lua, es
provisto de la distribución estándar. El intérprete independiente incluye todas las bibliotecas estándar. Su uso es:
lua [opciones] [script [argumentos]]
Las opciones son:

Página 80
-e stat : ejecuta string stat ;
-i: ingrese al modo interactivo después de ejecutar el script ;
-l mod : "requiere" mod y asigna el resultado al mod global ;
-v: información de la versión impresa;
-E: ignora las variables de entorno;
-W: activa las advertencias;
-: detener la manipulación de opciones;
-: ejecuta stdin como un archivo y deja de manejar las opciones.
Después de manejar sus opciones, lua ejecuta el script dado . Cuando se llama sin argumentos, lua se comporta como
lua -v -i
cuando la entrada estándar (stdin) es una terminal, y como lua, en caso contrario.
Cuando se llama sin la opción -E, el intérprete busca una variable de entorno LUA_INIT_5_4 (o
LUA_INIT si el nombre versionado no está definido) antes de ejecutar cualquier argumento. Si el contenido variable
tiene el
format @ filename , luego lua ejecuta el archivo. De lo contrario, lua ejecuta la cadena en sí.
Cuando se llama con la opción -E, Lua no consulta ninguna variable de entorno. En particular, los valores de
package.path ypackage.cpath se establecen con las rutas predeterminadas definidas en luaconf.h.
Las opciones -e, -l y -W se manejan en el orden en que aparecen. Por ejemplo, una invocación como
$ lua -e 'a = 1' -llib1 script.lua
Primero establecerá a en 1, luego requerirá la biblioteca lib1, y finalmente ejecutará el archivo script.lua sin
argumentos. (Aquí $
es el indicador de shell. Su mensaje puede ser diferente).
Antes de ejecutar cualquier código, lua recopila todos los argumentos de la línea de comandos en una tabla global
llamada arg. El nombre del guión
va al índice 0, el primer argumento después del nombre del script va al índice 1, y así sucesivamente. Cualquier
argumento antes del
El nombre del script (es decir, el nombre del intérprete más sus opciones) van a índices negativos. Por ejemplo, en la
llamada
$ lua -la b.lua t1 t2
la mesa es así:
arg = {[-2] = "lua", [-1] = "-la",
[0] = "b.lua",
[1] = "t1", [2] = "t2"}
Si no hay ningún script en la llamada, el nombre del intérprete pasa al índice 0, seguido de los demás argumentos. Por
ejemplo,
la llamada
$ lua -e "imprimir (arg [1])"
imprimirá "-e". Si hay un script, se llama al script con argumentos arg [1], ···, arg [#arg]. Como todos los trozos en
Lua, el script se compila como una función vararg.
En el modo interactivo, Lua solicita repetidamente y espera una línea. Después de leer una línea, Lua primero intenta
interpretar el
línea como expresión. Si tiene éxito, imprime su valor. De lo contrario, interpreta la línea como una declaración. Si tú
escribes
una declaración incompleta, el intérprete espera a que se complete emitiendo un mensaje diferente.
Si la variable global _PROMPT contiene una cadena, su valor se utiliza como indicador. Del mismo modo, si el
global
La variable _PROMPT2 contiene una cadena, su valor se utiliza como indicador secundario (emitido durante
declaraciones).
En caso de errores no protegidos en la secuencia de comandos, el intérprete informa del error al flujo de errores
estándar. Si el error
El objeto no es una cadena pero tiene un metamétodo __tostring, el intérprete llama a este metamétodo para producir
el
mensaje final. De lo contrario, el intérprete convierte el objeto de error en una cadena y le agrega un seguimiento de
pila.
Cuando las advertencias están activadas, simplemente se imprimen en la salida de error estándar.
Al terminar normalmente, el intérprete cierra su estado Lua principal (ver lua_close ). El guión puede evitar este paso
llamando os.exit para terminar.
Para permitir el uso de Lua como intérprete de script en sistemas Unix, Lua omite la primera línea de un fragmento
de archivo si comienza con
#. Por lo tanto, los scripts de Lua se pueden convertir en programas ejecutables usando chmod + xy #! forma, como
en
#! / usr / local / bin / lua
Por supuesto, la ubicación del intérprete de Lua puede ser diferente en su máquina. Si lua está en tu RUTA, entonces

Página 81
#! / usr / bin / env lua
es una solución más portátil.

8 - Incompatibilidades con el anterior

Versión
Aquí enumeramos las incompatibilidades que puede encontrar al mover un programa de Lua 5.3 a Lua 5.4.
Puede evitar algunas incompatibilidades compilando Lua con las opciones adecuadas (consulte el archivo luaconf.h).
Sin embargo,
todas estas opciones de compatibilidad se eliminarán en el futuro. La mayoría de las veces, surgen problemas de
compatibilidad cuando
estas opciones de compatibilidad se eliminan. Entonces, siempre que tenga la oportunidad, debe intentar probar su
código con
una versión de Lua compilada con todas las opciones de compatibilidad desactivadas. Eso facilitará las transiciones a
versiones más nuevas de
Lua.
Las versiones de Lua siempre pueden cambiar la API de C de formas que no impliquen cambios en el código fuente
de un programa, como
los valores numéricos para constantes o la implementación de funciones como macros. Por lo tanto, nunca debes
suponga que los binarios son compatibles entre diferentes versiones de Lua. Vuelva a compilar siempre los clientes
de la API de Lua
al usar una nueva versión.
De manera similar, las versiones de Lua siempre pueden cambiar la representación interna de fragmentos
precompilados; precompilado
los trozos no son compatibles entre las diferentes versiones de Lua.
Las rutas estándar en la distribución oficial pueden cambiar entre versiones.
8.1 - Incompatibilidades en el idioma
La conversión de cadenas a números en operaciones aritméticas y bit a bit se ha eliminado del núcleo.
idioma. La biblioteca de cadenas hace un trabajo similar para operaciones aritméticas (pero no bit a bit) usando la
cadena
metamétodos. Sin embargo, a diferencia de versiones anteriores, la nueva implementación conserva el tipo implícito
de
el número en la cadena. Por ejemplo, el resultado de "1" + "2" ahora es un número entero, no un flotante.
Las constantes enteras decimales literales que se desbordan se leen como flotantes, en lugar de ajustarse. Puedes usar
notación hexadecimal para tales constantes si desea el comportamiento anterior (leerlas como enteros con ajuste
alrededor).
Se ha eliminado el uso del metamétodo __lt para emular __le. Cuando sea necesario, este metamétodo
debe definirse explícitamente.
La semántica del bucle for numérico sobre enteros cambió en algunos detalles. En particular, el control
variable nunca se envuelve.
No se puede declarar una etiqueta para un goto donde una etiqueta con el mismo nombre es visible, incluso si esta
otra etiqueta es
declarado en un bloque adjunto.
Al finalizar un objeto, Lua no ignora los metamétodos __gc que no son funciones. Cualquier valor será
llamado, si está presente. (Los valores no invocables generarán una advertencia, como cualquier otro error al llamar a
un finalizador).
8.2 - Incompatibilidades en las bibliotecas
La función la impresión no llamatostring para formatear sus argumentos; en cambio, tiene esta funcionalidad
cableado. Debe usar __tostring para modificar cómo se imprimen los valores.
El generador de números pseudoaleatorios utilizado por la función math.random ahora comienza con algo
Semilla aleatoria. Además, utiliza un algoritmo diferente.
De forma predeterminada, las funciones de decodificación de la biblioteca utf8 no aceptan sustitutos como puntos de
código válidos. Un
El parámetro adicional en estas funciones las hace más permisivas.
Las opciones "setpause" y "setstepmul" de la función recolectar basura están en desuso. Debería
utilice la nueva opción "incremental" para configurarlos.
La función io.lines ahora devuelve cuatro valores, en lugar de solo uno. Eso puede ser un problema cuando se usa
como único argumento para otra función que tiene parámetros opcionales, como en
load (io.lines (nombre de archivo, "L")). Para solucionar ese problema, puede envolver la llamada entre paréntesis,
para ajustar
su número de resultados a uno.
8.3 - Incompatibilidades en la API
Los datos de usuario completos ahora tienen un número arbitrario de valores de usuario asociados. Por tanto, las
funciones

Página 82
lua_newuserdata,
lua_setuservalue,
y lua_getuservalue
fueron
sustituido
por
lua_newuserdatauv ,lua_setiuservalue ylua_getiuservalue , que tienen un argumento adicional.
Por compatibilidad, los nombres antiguos todavía funcionan como macros asumiendo un valor de usuario único. Sin
embargo, tenga en cuenta que
Los datos de usuario con valores de usuario cero son más eficientes en cuanto a memoria.
La función lua_resume tiene un parámetro adicional. Este parámetro de salida devuelve el número de valores en el
parte superior de la pila que fueron entregados o devueltos por la corrutina. (En versiones anteriores, esos valores
eran los
pila completa.)
La función lua_version devuelve el número de versión, en lugar de una dirección del número de versión. los
El núcleo de Lua debería funcionar correctamente con bibliotecas que utilicen sus propias copias estáticas del mismo
núcleo, por lo que no hay
necesitan comprobar si están utilizando el mismo espacio de direcciones.
Se eliminó la constante LUA_ERRGCMM. Los errores en los finalizadores nunca se propagan; en cambio, generan
una advertencia.
Las opciones LUA_GCSETPAUSE y LUA_GCSETSTEPMUL de la función lua_gc están en desuso. Tú
debe usar la nueva opción LUA_GCINC para configurarlos.

9 - La sintaxis completa de Lua

Aquí está la sintaxis completa de Lua en BNF extendido. Como es habitual en BNF extendido, {A} significa 0 o más
As y [A]
significa una A opcional (para precedencias de operadores, consulte §3.4.8 ; para obtener una descripción de los
terminales Nombre, Número,
y LiteralString, consulte §3.1 .)
trozo :: = bloque
block :: = {stat} [retstat]
stat :: = ' ; '|
varlist ' = ' lista exp |
functioncall |
etiqueta |
descanso |
Ir a Nombre |
hacer el final del bloque |
while exp hacer fin de bloque |
repetir bloque hasta exp |
if exp entonces bloque { elseif exp entonces bloque} [ else bloque] fin |
para Nombre ' = ' exp ' , ' exp [' , ' exp] do block end |
para namelist en explist hacer block end |
function funcname funcbody |
función local Nombre funcbody |
attnamelist local [' = ' explist]
attnamelist :: = Name attrib {' , ' Name attrib}
attrib :: = [' < ' Nombre ' > ']
retstat :: = return [lista exp] [' ; ']
label :: = ' :: ' Nombre ' :: '
funcname :: = Nombre {' . 'Nombre} [' : 'Nombre]
varlist :: = var {' , ' var}
var :: = Nombre | prefixexp ' [ ' exp ' ] ' | prefixexp ' . ' Nombre
namelist :: = Name {' , ' Name}
explist :: = exp {' , ' exp}
exp :: = nulo | falso | verdadero | Numeral | LiteralString | ' ... ' | functiondef |

prefixexp | tableconstructor | exp binop exp | unop exp

prefixexp :: = var | functioncall | ' ( ' exp ' ) '
functioncall :: = prefixexp args | prefixexp ' : ' Args de nombre
args :: = ' ( ' [lista exp] ' ) ' | tableconstructor | LiteralString
functiondef :: = function funcbody
funcbody :: = ' ( ' [parlist] ' ) ' final del bloque
parlist :: = namelist [' , ' ' ... '] | ' ... '
tableconstructor :: = ' { ' [lista de campos] ' } '
fieldlist :: = field {fieldsep field} [fieldsep]
campo :: = ' [ ' exp ' ] ' ' = ' exp | Nombre ' = ' exp | Exp
fieldsep :: = ' , ' | ' ; '
binop :: = ' + ' | ' - ' | ' * ' | ' / ' | ' // ' | ' ^ ' | ' % ' |
' & ' | ' ~ ' | ' | '| ' >> ' | ' << ' | ' .. ' |
' < ' | ' <= ' | ' > ' | ' > = ' | ' == ' | ' ~ = ' |
y|o
unop :: = ' - ' | no | ' # ' | ' ~ '
última actualización: vie 13 nov 15:35:22 utc 2020