Manual de Referencia de Lua 5.

1
por Roberto erusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes
(Traduccin de Julio Manuel Fernndez-Daz; vanse las notas sobre la misma al final del documento.)
Copyright 20072008 Lua.org, PUC-Rio. Libremente disponible bajo los trminos de la licencia de Lua.
contenido ndice english portugus espaol
1 - Introduccin
Lua es un lenguage de programacin extensible diseado para una programacin procedimental general con utilidades
para la descripcin de datos. Tambin ofrece un buen soporte para la programacin orientada a objetos, programacin
funcional y programacin orientada a datos. Se pretende que Lua sea usado como un lenguaje de script potente y ligero
para cualquier programa que lo necesite. Lua est implementado como una biblioteca escrita en C limpio (esto es, en el
subconjunto comn de ANS C y C++).
Siendo un lenguaje de extensin, Lua no tiene nocin de programa principal (main): slo funciona embebido en un cliente
anfitrin, denominado programa contenedor o simplemente anfitrin (host). ste puede invocar funciones para ejecutar un
trozo de cdigo Lua, puede escribir y leer variables de Lua y puede registrar funciones C para que sean llamadas por el
cdigo Lua. A travs del uso de funciones C, Lua puede ser aumentado para abarcar un amplio rango de diferentes
dominios, creando entonces lenguajes de programacin personalizados que comparten el mismo marco sintctico. La
distribucin de Lua incluye un programa anfitrin de muestra denominado lua, que usa la biblioteca de Lua para ofrecer un
intrprete de Lua completo e independiente.
Lua es software libre, y se proporciona, como es usual, sin garantas, como se establece en su licencia. La implementacin
descrita en este manual est disponible en el sitio web oficial de Lua, www.lua.org.
Como cualquier otro manual de referencia, este documento es parco en algunos lugares. Para una discusin de las
decisiones detrs del diseo de Lua, vanse los artculos tcnicos disponibles en el sitio web de Lua. Para una detallada
introduccin a la programacin en Lua, vase el libro de Roberto, Programming in Lua (Second Edition).
2 - El lenguaje
Esta seccin describe el lxico, la sintaxis y la semntica de Lua. En otras palabras, esta seccin describe qu elementos
(tokens) son vlidos, cmo deben combinarse y qu significa su combinacin.
Las construcciones del lenguaje se explicarn usando la notacin BNF extendida usual, en la que {a} significa 0 o ms aes,
y [a] significa una a opcional. Los smbolos no terminales se muestran en itlica, las palabras clave (keywords) se muestran
en negrita, y los otros smbolos terminales se muestran en un tipo de letra de paso fijo (typewriter), encerrada entre
comillas simples. La sintaxis completa de Lua se encuentra al final de este manual.
2.1 - Convecciones lxicas
Los nombres (tambin llamados identificadores) en Lua pueden ser cualquier tira de caracteres (string) slo con letras,
dgitos y caracteres de subrayado (underscore), no comenzando por un dgito. Esto coincide con la definicin de los
nombres en la mayora de los lenguajes. (La definicin de letra depende de la implementacin local actual a travs del
sistema locale: cualquier carcter considerado alfabtico en el sistema local puede ser usado en un identificador.) Los
identificadores se usan para nombrar variables y campos de tablas.
Las siguientes palabras clave (keywords) estn reservadas y no pueden usarse como nombres:
and break do else elseif
end false for function if
in local nil not or
repeat return then true until while
En Lua las letras maysculas y las minsculas se consideran diferentes: and es una palabra reservada, pero And y AND
son dos nombres diferentes vlidos. Como convencin, los nombres que comienzan por un subrayado seguido por letras en
maysculas (como _VERSON) estn reservados para uso como variables globales internas de Lua.
Los siguientes strings denotan otros elementos:
+ - * / % ^ #
== ~= <= >= < > =
( ) { } [ ]
; : , . .. ...
Los strings literales pueden ser delimitados por comillas simples (apstrofes) o dobles, y pueden contener las siguientes
secuencias de escape de C: '\a' (pitido, bell) '\b' (retroceso, backspace), '\f' (salto de pgina, form feed), '\n' (nueva lnea,
newline), '\r' (retorno de carro, carriage return), '\t' (tabulador horizontal, horizontal tab), '\v' (tabulador vertical, vertical tab),
'\\' (barra inversa, backslash), '\"' (comilla doble, uotation mark o double uote) y '\'' (apstrofe, apostrophe o single uote).
Adems, una '\newline' (esto es, una barra inversa seguida por un salto de lnea real) produce un salto de lnea en el string.
Un carcter en un string puede tambin especificarse por su valor numrico usando la secuencia de escape '\ddd', donde
ddd es una secuencia de tres dgitos decimales. (Tenga presente que si la secuencia numrica de escape est seguida de
un dgito debe ser expresada usando exactamente tres dgitos.) Los strings en Lua pueden contener cualquier valor de 8
bits, incluyendo el carcter cero, el cual puede ser especificado mediante '\0'.
Para poner una comilla (simple) doble, una barra inversa, un retorno de carro o un carcter cero dentro de un string literal
encerrado por comillas (simples) dobles se debe usar una secuencia de escape. Cualquier otro carcter puede ser incluido
en el literal. (Algunos caracteres de control pueden causar problemas con el sistema de ficheros, pero Lua no tiene
problemas con ellos.)
Los strings literales pueden definirse usando un formato largo, encerrados en corchetes largos. Definimos un corchete largo
de abrir de nivel n como un corchete de abrir seguido de n signos igual (=) seguidos de otro corchete de abrir. As, un
corchete largo de abrir de nivel 0 se escribe [[, un corchete largo de abrir de nivel 1 se escribe [=[, y as sucesivamente. Los
corchetes largos de cerrar se define de manera similar; por ejemplo, un corchete largo de cerrar de nivel 4 se expresa ]
====]. Un string largo comienza en un corchete largo de abrir de cualquier nivel y termina en el primer corchete largo de
cerrar del mismo nivel. Los strings literales delimitados de esta manera pueden extenderse por varias lneas, las secuencias
de escape no son interpretadas y se ignoran los corchetes largos de cualquier otro nivel. Por tanto, pueden contener
cualquier cosa excepto un corchete de cerrar del mismo nivel o caracteres cero.
Por conveniencia, cuando un corchete largo de abrir es seguido inmediatamente de un carcter de nueva lnea, ste no es
incluido en el string. Por ejemplo, usando el cdigo de caracteres ASC (en el cual 'a' se codifica como 97, el carcter de
nueva lnea se codifica como 10, y '1' se codifica como 49), los cinco literales siguientes denotan el mismo string:
a = 'alo\n123"'
a = "alo\n123\""
a = '\97lo\10\04923"'
a = [[alo
123"]]
a = [==[
alo
123"]==]
Las constantes num!ricas pueden contener una parte decimal opcional y tambin un exponente opcional. Lua tambin
acepta constantes enteras hexadecimales, escritas anteponiendo el prefijo 0x. Algunos ejemplos de constantes numricas
vlidas son
3 3.0 3.1416 314.16e-2 0.31416E1 0xff 0x56
Los comentarios comienzan con un doble guin (--) en cualquier lugar fuera de un string. Si el texto que sigue
inmediatamente despus de -- no es un corchete largo de abrir el comentario es corto y llega hasta el final de lnea. En otro
caso tenemos un comentario largo, que alcanza hasta el correspondiente corchete largo de cerrar. Los comentarios largos
se usan frecuentemente para deshabilitar temporalmente trozos de cdigo.
2.2 - alores ! ti"os
Lua es un lengua"e dinmicamente tipado. Esto significa que las variables no tienen tipos; slo tienen tipo los valores. No
existen definiciones de tipo en el lenguaje. Todos los valores almacenan su propio tipo.
Todos los valores en Lua son valores de primera clase. Esto significa que todos ellos pueden ser almacenados en
variables, pueden ser pasados como argumentos de funciones, y tambin ser devueltos como resultados.
Existen ocho tipos bsicos en Lua: nil, boolean, number, string, function, userdata, thread y table. #il es el tipo del valor nil,
cuya principal propiedad es ser diferente de cualquier otro valor; normalmente representa la ausencia de un valor til.
$oolean es el tipo de los valores false (falso) y true (verdadero). Tanto nil como false hacen una condicin falsa; cualquier
otro valor la hace verdadera. #umber representa nmeros reales (en coma flotante y doble precision). (Es fcil construir
intrpretes de Lua que usen otra representacin interna para los nmeros, ya sea en coma flotante con precisin simple o
enteros largos. Vase el fichero luaconf.h.) String representa una tira de caracteres. Lua trabaja con 8 bits: los strings
pueden contener cualquier carcter de 8 bits, incluyendo el carcter cero ('\0') (vase 2.1).
Lua puede llamar (y manejar) funciones escritas en Lua y funciones escritas en C (vase 2.5.8).
El tipo userdata se incluye para permitir guardar en variables de Lua datos arbitrarios en C. Este tipo corresponde a bloques
de memoria y no tienen asociadas operaciones predefinidas en Lua, excepto la asignacin y el test de identidad. Sin
embargo, usando metatablas , el programador puede definir operaciones asociadas a valores de tipo userdata (vase
2.8). Los valores de este tipo no pueden ser creados o modificados en Lua, sino slo a travs de la AP de C. Esto
garantiza la integridad de los datos propiedad del programa anfitrin.
El tipo thread representa procesos de ejecucin y es usado para implementar co-rutinas (vase 2.11). No deben
confundirse los procesos de Lua con los del sistema operativo. Lua soporta co-rutinas en todos los sistemas, incluso en
aqullos que no soporten procesos.
El tipo table (tabla) implementa arrays asociativos, esto es, arrays que pueden ser indexados no slo con nmeros, sino
tambin con cualquier valor (excepto nil). Las tablas pueden ser heterog!neas, ya que pueden contener valores de todos
los tipos (excepto nil). Las tablas son el nico mecanismo de estructuracin de datos en Lua; pueden ser usadas para
representar arrays ordinarios, tablas de smbolos, conjuntos, registros, grafos, rboles, etc. Para representar registros Lua
usa el nombre del campo como ndice. El lenguaje soporta esta representacin haciendo la notacin b.nombre equivalente
a b["nombre"]. Existen varias maneras convenientes de crear tablas en Lua (vase 2.5.7).
Como ndices, tambin los valores de los campos de una tabla pueden ser de cualquier tipo (excepto nil). En particular,
debido a que las funciones son valores de primera clase, los campos de las tablas pueden contener funciones. Entonces las
tablas pueden contener tambin m!todos (vase 2.5.9).
Los valores de las tablas, las funciones, los procesos y los userdata (completos) son ob"etos: las variables no contienen
realmente esos valores, sino que slo los referencian. La asignacin, el paso de argumentos y el retorno de las funciones
siempre manejan referencias a esos valores; esas operaciones no implican ningn tipo de copia.
La funcin de biblioteca type retorna un string que describe el tipo de un valor dado.
2.2.1 - Coercin
Lua puede convertir automticamente entre valores string y valores numricos en tiempo de ejecucin. Cualquier operacin
aritmtica aplicada a un string intenta convertir el mismo en un nmero, siguiendo las reglas normales de conversin. Y
viceversa, cuando un nmero se usa donde se espera un string el nmero se convierte a string, con un formato razonable.
Para un control completo en la conversin de nmeros en strings debe usarse la funcin format de la biblioteca de manejo
de strings (vase string.format).
2.# - aria$les
Las variables son lugares donde se almacenan valores. Existen tres tipos de variables en Lua: globales, locales y campos
de tabla.
Un nico nombre puede denotar una variable local o una global (o un argumento formal de una funcin, el cual es una
forma particular de una variable local):
var ::= nombre
nombre denota identificadores, como se definen en 2.1.
Lua asume que las variables son globales, a no ser que sean declaradas explcitamente como locales (vase 2.4.7). Las
variables locales tienen un mbito (scope) definido l!%icamente: pueden ser accedidas libremente desde dentro de las
funciones definidas en su mismo mbito (vase 2.6).
Antes de la primera asignacin el valor de una variable es nil.
Los corchetes se usan para indexar una tabla:
var ::= prefixexp '%' exp '&'
La primera expresin (prefi%e%p) debe dar como resultado un valor tabla; la segunda expresin (e%p) identifica una entrada
especfica en esta tabla. La expresin que denota la tabla que es indexada tienen una sintaxis restringida; vase 2.5 para
ms detalles.
La sintaxis var.nombre es otra manera de expresar var["nombre"] y se usa para denotar campos de tablas:
var ::= prefixexp '.' nombre
La manera en qu se accede a las variables globales y a los campos de las tablas puede ser cambiada mediante
metatablas. Un acceso a la variable indexada t[i] equivale a una llamada a gettable_event(t,i) (vase 2.8 para una
completa descripcin de la funcin gettable_event. Esta funcin no est definida ni es invocable desde Lua. Se usa aqu
slo con propsitos ilustrativos).
Todas las variables globales se almacenan como campos de tablas ordinarias en Lua, denominadas tablas de entorno o
simplemente entornos (vase 2.9). Cada funcin tiene su propia referencia a un entorno, as que todas las variables
globales de esta funcin se refieren a esa tabla de entorno. Cuando se crea una funcin, sta hereda el entorno de la
funcin que la cre. Para obtener la tabla de entorno de una funcin en cdigo Lua, se invoca a getfenv. Para reemplazarla
se llama a setfenv. (Se pueden manejar los entornos de una funcin C, pero slo a travs de la biblioteca de depuracin;
vase 5.9.)
Un acceso a la variable global x equivale a _env.x, que a su vez equivale a
gettable_event(_env, "x")
donde _env es el entorno de la funcin que se est ejecutando en ese momento (vase 2.8 para una completa descripcin
de la funcin gettable_event. Esta funcin no est definida ni es invocable desde Lua. gualmente, la variable _env no est
definida en Lua. Se usan aqu slo con propsitos ilustrativos.)
2.' - (entencias
Lua soporta un conjunto casi convencional de sentencias, similar a los de Pascal o C. Este conjunto incluye la asignacin,
estructuras de control de flujo, llamadas a funciones, constructores de tablas y declaraciones de variables.
2.'.1 - Chunks
La unidad de ejecucin en Lua se denomina chunk, el cual es simplemente un conjunto de sentencias que se ejecutan
secuencialmente. Cada sentencia puede llevar opcionalmente al final un punto y coma:
chunk ::= {sentencia [')']}
No existen sentencias vacas en Lua y por tanto ';;' no es legal.
Lua maneja cada chunk como el cuerpo de una funcin annima con un nmero variable de argumentos (vase 2.5.9).
Los chunks pueden definir variables locales, recibir argumentos y retornar valores.
Un chunk puede ser almacenado en un fichero o en un string dentro de un programa anfitrin. Cuando se ejecuta un chunk
primero se precompila, crendose instrucciones para una mquina virtual, y es entonces cuando el cdigo compilado es
ejecutado por un intrprete de la mquina virtual.
Los chunks pueden tambin estar precompilados en forma binaria; vase el programa luac para ms detalles. Las formas
fuente y compilada de los programas son intercambiables; Lua detecta automticamente el tipo de fichero y acta de
manera acorde.
2.'.2 - *lo+ues
Un bloque es una lista de sentencias; sintcticamente un bloque es lo mismo que un chunk:
bloque ::= chunk
Un bloque puede ser delimitado explcitamente para producir una sentencia simple:
sentencia ::= do bloque end
Los bloques explcitos son tiles para controlar el mbito de las declaraciones de variable. Tambin se utilizan a veces para
aadir sentencias return o $rea, en medio de otro bloque (vase 2.4.4).
2.'.# - La asignacin
Lua permite asignaciones mltiples. Por tanto la sintaxis de una asignacin define una lista de variables a la izquierda y una
lista de expresiones a la derecha. Los elementos de ambas listas estn separados por comas:
sentencia ::= varlist '-' explist
varlist ::= var {'.' var}
explist ::= exp {'.' exp}
Las expresiones se analizan en 2.5.
Antes de una asignacin la lista de expresiones se a"usta a la longitud de la lista de variables. Si existen ms valores de los
necesarios el exceso se descarta. Si existen menos valores de los necesarios la lista se extiende con tantos valores nil
como se necesiten. Si la lista de expresiones finaliza con una llamada a una funcin entonces todos los valores devueltos
en la llamada pueden entrar en la lista de valores antes del ajuste (excepto cuando se encierra entre parntesis; vase
2.5).
La sentencia de asignacin primero evala todas sus expresiones y slo despus se hace la asignacin. Entonces, el
cdigo
i = 3
i, b[i] = i+1, 20
asigna 20 a b[3], sin afectar a b[4] debido a que i en b[i] se evala (a 3) antes de que se le asigne el valor 4. Similarmente,
la lnea
x, y = y, x
intercambia los valores de x e y.
El mecanismo de asignacin a las variables globales y a los campos de tablas puede ser modificado mediante metatablas.
Una asignacin a una variable indexada t[i] = val equivale a settable_event(t,i,val). (Vase 2.8 para una completa
descripcin de la funcin settable_event. Esta funcin no est definida ni es invocable desde Lua. Se usa slo con
propsitos ilustrativos.)
Una asignacin a la variable global x = val equivale a la asignacin _env.x = val, que a su vez equivalen a
settable_event(_env, "x", val)
donde _env es el entorno de la funcin que est ejecutndose en ese momento. (La variable _env no est definida en Lua.
Se utiliza aqu slo con propsitos ilustrativos.)
2.'.' - Estructuras de control
Las estructuras de control if, /0ile y re"eat tienen el significado habitual y la sintaxis familiar:
sentencia ::= /0ile exp do bloque end
sentencia ::= re"eat bloque until exp
sentencia ::= if exp t0en bloque {elseif exp t0en bloque} [else bloque] end
Lua tiene tambin una sentencia for, en dos formatos (vase 2.4.5).
La condicin de una expresin de una estructura de control puede retornar cualquier valor. Tanto false como nil se
consideran falsos. Todos los valores diferentes de nil y false se consideran verdaderos (en particular, el nmero 0 y el
string vaco son tambin verdaderos).
En el bucle re"eatuntil el bloque interno no acaba en la palabra clave until sino detrs de la condicin. De esta manera la
condicin puede referirse a variables locales declaradas dentro del bloque del bucle.
La orden return se usa para devolver valores desde una funcin o un chunk (el cual es justamente una funcin). Las
funciones y los chunks pueden retornar ms de un valor, por lo que la sintaxis para return es
sentencia ::= return [explist]
La orden $rea, se usa para terminar la ejecucin de los bucles /0ile, re"eat y for, saltando a la sentencia que sigue
despus del bucle:
sentencia ::= $rea,
Un $rea, finaliza el bucle ms interno que est activo.
Las rdenes return y $rea, pueden aparecer slo como &ltima sentencia dentro de un bloque. Si se necesita realmente un
return o un $rea, en medio de un bloque se debe usar un bloque ms interno explcitamente, como en 'do return end' y 'do
break end', debido a que as return y $rea, son las ltimas sentencias en su propio bloque.
2.'.5 - La sentencia for
La sentencia for tiene dos formas: una numrica y otra genrica.
La forma numrica del bucle for repite un bloque mientras una variable de control sigue una progresin aritmtica. Tiene la
sintaxis siguiente:
sentencia ::= for nombre '-' exp1 '.' exp2 ['.' exp3] do bloque end
El bloue se repite para los valores de nombre comenzando en e%p' hasta que sobrepasa e%p( usando como paso e%p).
Ms precisamente una sentencia for como
for v = e', e(, e) do bloue end
equivale al cdigo:
do
local var, limit, step = tonumber(e'), tonumber(e(), tonumber(e))
if not (var and limit and step) then error() end
while (step > 0 and var <= limit) or (step <= 0 and var >= limit) do
local v = var
bloue
var = var + step
end
end
Ntese lo siguiente:
Todas las expresiones de control se evalan slo una vez, antes de que comience el bucle. Deben resultar todas
en nmeros.
var, limit y step son variables invisibles. Los nombres aparecen aqu slo con propsitos ilustrativos.
Si la tercera expresin (el paso) est ausente se utiliza paso 1.
Se puede utilizar $rea, para salir del bucle for.
La variable de control v es local dentro del bucle; no se puede utilizar su valor despus de que finalice el bucle for
o despus de una salida del mismo con $rea,. Si se necesita el valor de la variable var entonces debe asignarse a
otra variable antes del $rea, o de la salida del bucle.
La sentencia for genrica trabaja con funciones, denominadas iteradores. En cada iteracin se invoca a la funcin iterador
que produce un nuevo valor, parndose la iteracin cuando el nuevo valor es nil. El bucle for genrico tiene la siguiente
sintaxis:
sentencia ::= for lista_de_nombres in explist do bloque end
lista_de_nombres ::= nombre {'.' nombre}
Una sentencia for como
for var*', ..., var*n in e%plist do bloue end
equivale al cdigo:
do
local f, s, var = e%plist
while true do
local var*', ... , var*n = f(s, var)
var = var*'
if var == nil then break end
bloue
end
end
Ntese lo siguiente:
e%plist se evala slo una vez. Sus resultados son una funcin iterador, un estado y un valor inicial para la primera
variable iteradora.
f, s y var son variables invisibles. Los nombres que aqu aparecen son slo ilustrativos.
Se puede usar una orden $rea, para salir del bucle for.
Las variables de control del bucle var*i son locales en el bucle; no se pueden usar sus valores despus de que
acabe el bucle for. Si se necesitan sus valores se deben asignar a otras variables antes de que se salga del bucle
(normalmente o con un $rea,).
2.'.1 - (entencias de lla2adas a funcin
Para evitar posibles efectos laterales, las llamadas a funcin pueden ser realizadas como sentencias:
sentencia ::= llamada_a_func
En ese caso todos los valores retornados se descartan. Las llamadas a funcin estn explicadas en 2.5.8.
2.'.3 - 4eclaraciones locales
Las variables locales pueden ser declaradas en cualquier lugar dentro de un bloque. Esas declaraciones pueden incluir una
asignacin inicial:
sentencia ::= local lista_de_nombres ['-' explist]
Si est presente, una asignacin inicial tiene la misma semntica que una asignacin mltiple (vase 2.4.3). En otro caso
todas las variables son inicializadas con nil.
Un chunk es tambin un bloque (vase 2.4.1), as que las variables locales pueden ser declaradas en un chunk fuera de
cualquier bloque explcito. El mbito de esas variables se extiende hasta el final del chunk.
Las reglas de visibilidad para las variables locales se exponen en 2.6.
2.5 - Ex"resiones
Las expresiones bsicas en Lua son las siguientes:
exp ::= prefixexp
exp ::= nil | false | true
exp ::= Nmero
exp ::= String
exp ::= func
exp ::= constructor_de_tabla
exp ::= '...'
exp ::= exp operador_binario exp
exp ::= operador_unario exp
prefixexp ::= var | llamada_a_func | '5' exp '6'
Los nmeros y los string literales se explican en 2.1; las variables se explican en 2.3; la definicin de funciones se explica
en 2.5.9; las llamadas a funcin se explican en 2.5.8; los constructores de tablas se explican en 2.5.7. Las expresiones
vararg (que indican un nmero variable de argumentos en una funcin), denotadas mediante tres puntos ('...'), pueden ser
usadas directamente slo cuando estn dentro de las funciones con vararg; se explican en 2.5.9.
Los operadores binarios comprenden los operadores aritmticos (vase 2.5.1), los operadores relacionales (vase 2.5.2)
y los operadores lgicos (vase 2.5.3). Los operadores unarios compenden el menos unario (vase 2.5.1), el not unario
(vase 2.5.3) y el operador de longitud unario (vase 2.5.5).
Tanto las llamadas a funcin como las expresiones vararg pueden resultar en valores mltiples. Si la expresin se usa
como una sentencia (vase 2.4.6) (slo posible con llamadas a funcin), entonces su lista de valores retornados se ajusta
a cero elementos, descartando todos los valores retornados. Si la expresin se usa como el ltimo (o nico) elemento de
una lista de expresiones entonces no se realiza ningn ajuste (a no ser que la llamada se encierre entre parntesis). En
todos los dems contextos Lua ajusta el resultado de la lista a un solo elemento, descartando todos los valores excepto el
primero.
He aqu varios ejemplos:
f() -- ajustado a 0 resultados
g(f(), x) -- f() es ajustado a 1 resultado
g(x, f()) -- g toma x y todos los valores devueltos por f()
a,b,c = f(), x -- f() se ajusta a 1 resultado (c toma el valor nil)
a,b = ... -- a toma el primer argumento vararg, b toma
-- el segundo (a y b pueden ser nil si no existen los
-- correspondientes argumentos vararg)
a,b,c = x, f() -- f() se ajusta a 2 resultados
a,b,c = f() -- f() se ajusta a 3 resultados
return f() -- retorna todos los valores devueltos por f()
return ... -- retorna todos los argumentos vararg recibidos
return x,y,f() -- retorna x, y, y todos los valores devueltos por f()
{f()} -- crea una lista con todos los valores retornados por f()
{...} -- crea una lista con todos los argumentos vararg
{f(), nil} -- f() se ajusta a 1 resultado
Una expresin encerrada en parntesis siempre resulta en un nico valor. Entonces, (f(x,y,z)) siempre es un valor nico,
incluso si f retorna varios valores. (El valor de (f(x,y,z)) es el primer valor retornado por f o nil si f no retorna ningn valor).
2.5.1 - 7"eradores arit2ticos
Lua tiene los operadores aritmticos comunes: los binarios + (adicin), - (substraccin), * (multiplicacin), / (divisin), %
(mdulo) y ^ (exponenciacin); y el unario - (negacin). Si los operandos son nmeros o strings que se convierten a
nmeros (vase 2.2.1), entonces todas las operaciones tienen el significado corriente. La exponenciacin trabaja con
cualquier exponente. Por ejemplo, x^(-0.5) calcula la inversa de la raiz cuadrada de x. El mdulo se define como
a % b == a - math.floor(a/b)*b
Esto es, es el resto de la divisin que redondea el cociente hacia menos infinito.
2.5.2 - 7"eradores relacionales
Los operadores relacionales en Lua son
== ~= < > <= >=
Devuelven siempre un resultado false o true.
La igualdad (==) primero compara el tipo de los operandos. Si son diferentes entonces el resultado es false. En otro caso
se comparan los valores de los operandos. Los nmeros y los strings se comparan de la manera usual. Los objetos (tablas,
userdata, procesos y funciones) se comparan por referencia: dos objetos se consideran iguales slo si son el mismo objeto.
Cada vez que se crea un nuevo objeto (una tabla, userdata, proceso o funcin) este nuevo objeto es diferente de todos los
dems objetos preexistentes.
Se puede cambiar la manera en que Lua compara tablas y userdata usando el metamtodo "eq" (vase 2.8).
Las reglas de conversin de 2.2.1 no se aplican en las comparaciones de igualdad. De este modo "0"==0 es false, y t[0] y
t["0"] denotan diferentes entradas en una tabla.
El operador ~= es exactamente la negacin de la igualdad (==).
El orden de los operadores funciona de la siguiente manera. Si ambos argumentos son nmeros entonces se comparan
como tales. En otro caso, si ambos argumentos son strings sus valores se comparan de acuerdo al sistema local. En otro
caso, Lua trata de usar los metamtodos "lt" o "le" (vase 2.8).
2.5.# - 7"eradores lgicos
Los operadores lgicos en Lua son and, or y not. Como las estructuras de control (vase 2.4.4) todos los operadores
lgicos consideran false y nil como falso y todo lo dems como verdadero.
El operador negacin not siempre retorna false o true. El operador conjuncin and retorna su primer operando si su valor
es false o nil; en caso contrario and retorna su segundo operando. El operador disyuncin or retorna su primer operando si
su valor es diferente de nil y false; en caso contrario or retorna su segundo argumento. Tanto and como or usan
evaluacin de cortocircuito; esto es, su segundo operando se evala slo si es necesario. He aqu varios ejemplos:
10 or 20 --> 10
10 or error() --> 10
nil or "a" --> "a"
nil and 10 --> nil
false and error() --> false
false and nil --> false
false or nil --> nil
10 and 20 --> 20
(En este manual '-->' indica el resultado de la expresin precedente.)
2.5.' - Concatenacin
El operador de concatenacin de strings en Lua se denota mediante dos puntos seguidos ('..'). Si ambos operandos son
strings o nmeros entonces se convierten a strings mediante las reglas mencionadas en 2.2.1. En otro caso se invoca al
metamtodo "concat" (vase 2.8).
2.5.5 - El o"erador longitud
El operador longitud se denota mediante #. La longitud de un string es su nmero de bytes (significado normal de la longitud
de un string cuando cada carcter ocupa un byte).
La longitud de una tabla t se define como un ndice entero n tal que t[n] no es nil y t[n+1] es nil; adems, si t[1] es nil
entonces n puede ser cero. Para un array regular, con valores no nil desde 1 hasta un n dado, la longitud es exactamente
n, el ndice es su ltimo valor. Si el array tiene "agujeros" (esto es, valores nil entre otros valores que no lo son), entonces
#t puede ser cualquiera de los ndices que preceden a un valor nil (esto es, Lua puede considerar ese valor nil como el final
del array).
2.5.1 - 8recedencia de los o"eradores
La precedencia de los operadores en Lua sigue lo expuesto en la tabla siguiente de menor a mayor prioridad:
or
and
< > <= >= ~= ==
..
+ -
* / %
not # - (unario)
^
Como es usual, se pueden usar parntesis para cambiar la precedencia en una expresin. Los operadores de
concatenacin ('..') y de exponenciacin ('^') son asociativos por la derecha. Todos los dems operadores son asociativos
por la izquierda.
2.5.3 - Constructores de ta$la
Los constructores de tabla son expresiones que crean tablas. Cada vez que se evala un constructor se crea una nueva
tabla. Los constructores pueden ser usados para crear tablas vacas o para crear tablas e inicializar alguno de sus campos.
La sintaxis general para esos constructores es
constructor_de_tabla ::= '9' [lista_de_campos] ':'
lista_de_campos ::= campo {separador_de_campos campo} [separador_de_campos]
campo ::= '%' exp '&' '-' exp | nombre '-' exp | exp
separador_de_campos ::= '.' | ')'
Cada campo de la forma [exp1] = exp2 aade una entrada a la nueva tabla con la clave exp1 y con el valor exp2. Un campo
de la forma nombre = exp equivale a ["nombre"] = exp. Finalmente, campos de la forma exp son equivalentes a [i] = exp,
donde i son nmeros enteros consecutivos, comenzando con 1. Los campos en el otro formato no afectan este contador.
Por ejemplo,
a = { [f(1)] = g; "x", "y"; x = 1, f(x), [30] = 23; 45 }
equivale a
do
local t = {}
t[f(1)] = g
t[1] = "x" -- 1 exp
t[2] = "y" -- 2 exp
t.x = 1 -- t["x"] = 1
t[3] = f(x) -- 3 exp
t[30] = 23
t[4] = 45 -- 4 exp
a = t
end
Si el ltimo campo en la lista tiene la forma exp y la expresin es una llamada a funcin o una expresin vararg, entonces
todos los valores retornados por esta expresin entran en la lista consecutivamente (vase 2.5.8). Para evitar esto debe
encerrarse la llamada a la funcin (o la expresin vararg) entre parntesis (vase 2.5).
La lista de campos puede tener un separador opcional al final, una conveniencia para cdigo fuente generado de manera
automtica.
2.5.; - Lla2adas a funcin
Una llamada a una funcin tiene en Lua la siguiente sintaxis:
llamada_a_func ::= prefixexp argumentos
En una llamada a funcin, se evalan primero prefi%e%p y los argumentos. Si el valor de prefi%e%p es del tipo function,
entonces se invoca a esta funcin con los argumentos dados. En caso contrario se invoca el metamtodo "call", pasando
como primer argumento el valor de prefi%e%p seguido por los argumentos originales de la llamada (vase 2.8).
La forma
llamada_a_func ::= prefixexp '<' nombre argumentos
puede ser usada para invocar "mtodos". Una llamada v:nombre(...) es otra manera de expresar v.nombre(v,...), excepto
que v se evala slo una vez.
Los argumentos tienen la siguiente sintaxis:
argumentos ::= '5' [explist] '6'
argumentos ::= constructor_de_tabla
argumentos ::= String
Todos los argumentos de la expresin se evalan antes de la llamada. Un llamada de la forma f{...} es otra manera de
expresar f({...}); esto es, la lista de argumentos es una nueva tabla simple. Una llamada de la forma f'...' (o f"..." o f[[...]]) es
otra manera de expresar f('...'); esto es, la lista de argumentos es un string literal simple.
Como excepcin a la sintaxis de formato libre de Lua, no se puede poner una rotura de lnea antes de '(' en una llamada a
funcin. Esta restriccin evita algunas ambigedades en el lenguaje. Si se escribe
a = f
(g).x(a)
Lua podra ententerlo como una sentencia simple, a = f(g).x(a). Entonces, si se desean dos sentencias se debe aadir un
punto y coma entre ellas. Si realmente se desea llamar a f, se debe eliminar la rotura de lnea antes de (g).
Una llamada de la forma return llamada*a*func se denomina una llamada de cola. Lua implementa llamadas de cola
correctas (o recursi+n de cola correcta): en una llamada de cola la funcin invocada reutiliza la entrada en la pila de la
funcin que la est llamando. Por tanto no existe lmite en el nmero de llamadas de cola anidadas que un programa puede
ejecutar. Sin embargo una llamada de cola borra cualquier informacin de depuracin relativa a la funcin invocante.
Ntese que una llamada de cola slo ocurre con una sintaxis particular donde el return tiene una llamada simple a funcin
como argumento; esta sintsis hace que la funcin invocante devuelva exactamente el retorno de la funcin invocada.
Segn esto ninguno de los siguientes ejemplos son llamadas de cola:
return (f(x)) -- resultados ajustados a 1
return 2 * f(x)
return x, f(x) -- resultados adicionales
f(x); return -- resultados descartados
return x or f(x) -- resultados ajustados a 1
2.5.= - 4efinicin de funciones
La sintaxis para la definicin de funciones es
func ::= function cuerpo_de_func
cuerpo_de_func ::= '5' [lista_de_argumentos] '6' bloque end
La siguiente forma simplifica la definicin de funciones:
sentencia ::= function nombre_de_func cuerpo_de_func
sentencia ::= local function nombre cuerpo_de_func
nombre_de_func ::= nombre {'.' nombre} ['<' nombre]
La sentencia
function f () cuerpo*de*funci+n end
se traduce en
f = function () cuerpo*de*funci+n end
La sentencia
function t.a.b.c.f () cuerpo*de*funci+n end
se traduce en
t.a.b.c.f = function () cuerpo*de*funci+n end
La sentencia
local function f () cuerpo*de*funci+n end
se traduce en
local f; f = function () cuerpo*de*funci+n end
no en:
local f = function () cuerpo*de*funci+n end
(Esto slo entraa diferencias cuando el cuerpo de la funcin contiene referencias a f.)
Una definicin de funcin es una expresin ejecutable, cuyo valor tiene el tipo function. Cuando Lua precompila un chunk
todos sus cuerpos de funcin son tambin precompilados. Entonces cuando Lua ejecuta la definicin de funcin, la misma
es instanciada (o cerrada). Esta instancia de funcin (o closure) es el valor final de la expresin. Diferentes instancias de la
misma funcin pueden referirse a diferentes variables locales externas y pueden tener diferentes tablas de entorno.
Los argumentos formales de una funcin actan como variables locales que son inicializadas con los valores actuales de
los argumentos:
lista_de_argumentos ::= lista_de_nombres ['.' '...'] | '...'
Cuando se invoca una funcin, la lista de argumentos actuales se ajusta a la longitud de la lista de argumentos formales, a
no ser que la funcin sea de tipo vararg, lo que se indica por tres puntos ('...') al final de la lista de argumentos formales.
Una funcin vararg no ajusta su lista de argumentos; en su lugar recolecta todos los argumentos actuales extra y se los
pasa a la funcin a travs de una e%presi+n vararg, lo que tambin se indica por medio de tres puntos. El valor de esta
expresin es una lista de todos los argumentos actuales extra, similar a una funcin con resultados mltiples. Si la
expresin vararg se usa en el interior de otra expresin o en el medio de una lista de expresiones, entonces su retorno se
ajusta a un slo elemento. Si la expresin es usada como el ltimo elemento de una lista de expresiones entonces no se
hace ningn ajuste (a no ser que la llamada se realice entre parntesis).
Como ejemplo, consideremos las siguientes definiciones:
function f(a, b) end
function g(a, b, ...) end
function r() return 1,2,3 end
Entonces tenemos la siguiente correspondencia de los argumentos actuales a los formales y a la expresin vararg:
LLAMADA ARGUMENTOS
f(3) a=3, b=nil
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=nil, ... --> (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 usando la sentencia return (vase 2.4.4). Si el flujo del programa alcanza el final de una
funcin sin encontrar una sentencia return entonces la funcin retorna sin resultados.
La sintaxis con dos puntos (':') se usa para definir m!todos, esto es, funciones que tienen un argumento extra denominado
self. Entonces la sentencia
function t.a.b.c:f (params) cuerpo*de*funci+n end
es otra manera de expresar
t.a.b.c.f = function (self, params) cuerpo*de*funci+n end
2.1 - Reglas de visi$ilidad
Lua es un lenguaje con mbito lxico. El mbito de las variables comienza en la primera sentencia despu!s de su
declaracin y termina al final del bloque ms interno que incluya la declaracin. Consideremos el siguiente ejemplo:
x = 10 -- variable global
do -- nuevo bloque
local x = x -- nueva 'x', con valor 10
print(x) --> 10
x = x+1
do -- otro bloque
local x = x+1 -- otra 'x'
print(x) --> 12
end
print(x) --> 11
end
print(x) --> 10 (el valor de la variable global)
Tengase presente que en una declaracin como local x = x, la nueva x que est siendo declarada no tiene mbito todava, y
la segunda x se refiere a la variable externa.
Debido a las reglas de mbito lxico, las variables locales pueden ser accedidas por funciones definidas en el interior de su
propio mbito. Una variable local usada en una funcin interna se denomina upvalue o variable local e%terna en el interior
de la funcin.
Ntese que cada ejecucin de una sentencia local define nuevas variables locales. Considrese el siguiente ejemplo:
a = {}
local x = 20
for i=1,10 do
local y = 0
a[i] = function () y=y+1; return x+y end
end
El bucle crea diez closures (esto es, diez instancias de una funcin annima). Cada uno de estas instancias usa una
variable y diferente, mientras que todas ellas comparten la misma x.
2.3 - Manejo de errores
Debido a que Lua es un lenguaje de extensin embebido, todas las acciones de Lua comienzan con cdigo C en el
programa anfitrin llamando a una funcin de la biblioteca de Lua (vase lua_pcall). Cada vez que ocurra un error durante
la compilacin o ejecucin de Lua, el control retorna a C, que puede tomar las medidas apropiadas (tales como imprimir un
mensaje de error).
Se puede generar (o activar) explcitamente en Lua un error invocando la funcin error. Si se necesita capturar errores en
Lua se puede usar la funcin pcall.
2.; - Metata$las
Cada valor en Lua puede tener una metatabla. sta es una tabla ordinaria de Lua que define el comportamiento del valor
original para ciertas operaciones especiales. Se pueden cambiar varios aspectos del comportamiento de las operaciones
realizadas sobre un valor estableciendo campos especficos en su metatabla. Por ejemplo, cuando un valor no numrico es
un operando de una adicin Lua busca una funcin en el campo "__add" de su metatabla. Si se encuentra una, entonces se
invoca esa funcin para realizar la adicin.
Llamamos eventos a los campos de una metatabla y a los valores los denominamos metam!todos. En el ejemplo anterior el
evento es "add" mientras que el metamtodo es la funcin que realiza la adicin.
Se puede solicitar la metatabla de cualquier valor a travs de la funcin getmetatable.
Se puede reemplazar la metatabla de una tabla a travs de la funcin setmetatable. No se puede cambiar la metatabla de
otros tipos de datos desde Lua (excepto usando la biblioteca de depuracin); se debe usar la AP de C para ello.
Las tablas y los userdata completos tienen metatablas individuales (aunque varias tablas y userdata pueden compartir sus
metatablas); los valores de los otros tipos comparten una nica metatabla por tipo. Por tanto, existe una nica metatabla
para todos los nmeros, otra para todos los strings, etc.
Una metatabla puede controlar cmo se comporta un objeto en las operaciones aritmticas, en las comparaciones de
orden, en la concatenacin, en la operacin longitud y en el indexado. Una metatabla puede tambin definir una funcin que
ser invocada cuando se libera memoria ocupada (garbage collection) por userdata. A cada una de esas operaciones Lua
le asocia una clave especfica denominada evento. Cuando Lua realiza una de esas operaciones con un valor, comprueba
si ste tiene una metatabla con el correspondiente evento. Si es as, el valor asociado con esa clave (el metam!todo)
controla cmo realiza Lua la operacin.
Las metatablas controlan las operaciones listadas a continuacin. Cada operacin se identifica por su correspondiente
nombre. La clave asociada a cada operacin es un string con su nombre prefijado con dos subrayados, '__'; por ejemplo, la
clave para la operacin "add" es el string "__add". La semntica de esas operaciones est mejor expuesta a travs de una
funcin Lua que describe cmo ejecuta el intrprete la operacin.
El cdigo Lua mostrado aqu es slo ilustrativo; el comportamiento real est codificado internamente en el intrprete y es
mucho ms eficiente que esta simulacin. Todas las funciones usadas en estas descripciones (rawget, tonumber, etc.)
estn descritas en 5.1. En particular, para recuperar el metamtodo de un objeto dado, usamos la expresin
metatable(objeto)[evento]
Esto puede tambin ser expresado mediante
rawget(getmetatable(objeto) or {}, evento)
Por tanto, el acceso a un metamtodo no invoca otros metamtodos, y el acceso a los objetos sin metatablas no falla
(simplemente devuelve nil).
>add>< La operacin +.
La funcin getbinhandler que aparece ms abajo define cmo escoge Lua un manejador de la operacin binaria.
Primero Lua prueba el primer operando. Si su tipo no define un manejador para la operacin entonces Lua lo
intenta con el segundo operando.
function getbinhandler (op1, op2, evento)
return metatable(op1)[evento] or metatable(op2)[evento]
end
Usando esta funcin el comportamiento del cdigo op1 + op2 es
function add_event (op1, op2)
local o1, o2 = tonumber(op1), tonumber(op2)
if o1 and o2 then -- son numricos ambos operandos?
return o1 + o2 -- '+' aqu es la primitiva 'add'
else -- al menos uno de los operandos es no numrico
local h = getbinhandler(op1, op2, "__add")
if h then
-- invoca el manejador de ambos operandos
return (h(op1, op2))
else -- no existe un manejador disponible: comportamiento por defecto
error()
end
end
end
>su$>< La operacin -. El comportamiento es similar a la operacin "add".
>2ul>< La operacin *. El comportamiento es similar a la operacin "add".
>div>< La operacin /. El comportamiento es similar a la operacin "add".
>2od>< La operacin %. El comportamiento es similar a la operacin "add", usando o1 - floor(o1/o2)*o2 como
operacin primitiva.
>"o/>< La operacin ^ (exponenciacin). El comportamiento es similar a la operacin "add", con la funcin pow
(de la biblioteca matemtica de C) como operacin primitiva.
>un2>< La operacin - unaria.
function unm_event (op)
local o = tonumber(op)
if o then -- es numrico el operando?
return -o -- '-' aqu es la funcin primitiva 'unm'
else -- el operando no es numrico.
-- intentar obtener un manejador para el operando
local h = metatable(op).__unm
if h then
-- invocar el manejador con el operando
return (h(op))
else -- no hay manejador disponible: comportamiento por defecto
error()
end
end
end
>concat>< La operacin .. (concatenacin).
function concat_event (op1, op2)
if (type(op1) == "string" or type(op1) == "number") and
(type(op2) == "string" or type(op2) == "number") then
return op1 .. op2 -- concatenacin primitiva de strings
else
local h = getbinhandler(op1, op2, "__concat")
if h then
return (h(op1, op2))
else
error()
end
end
end
>len>< La operacin #.
function len_event (op)
if type(op) == "string" then
return strlen(op) -- longitud primitiva de string
elseif type(op) == "table" then
return #op -- longitud primitiva de tabla
else
local h = metatable(op).__len
if h then
-- invocar el manejador con el operando
return (h(op))
else -- no hay manejador disponible: comportamiento por defecto
error()
end
end
end
Vase 2.5.5 para una descripcin de la longitud de una tabla.
>e+>< La operacin ==. La funcin getcomphandler define cmo elige Lua un metamtodo para el operador de
comparacin. Se selecciona un metamtodo cuando ambos objetos que son comparados tienen el mismo tipo y el
mismo metamtodo para la operacin dada.
function getcomphandler (op1, op2, evento)
if type(op1) ~= type(op2) then return nil end
local mm1 = metatable(op1)[evento]
local mm2 = metatable(op2)[evento]
if mm1 == mm2 then return mm1 else return nil end
end
El evento "eq" se define as:
function eq_event (op1, op2)
if type(op1) ~= type(op2) then -- diferentes tipos?
return false -- diferentes objetos
end
if op1 == op2 then -- iguales primitivas?
return true -- los objetos son iguales
end
-- probar un metamtodo
local h = getcomphandler(op1, op2, "__eq")
if h then
return (h(op1, op2))
else
return false
end
end
a ~= b equivale a not (a == b).
>lt>< La operacin <.
function lt_event (op1, op2)
if type(op1) == "number" and type(op2) == "number" then
return op1 < op2 -- comparacin numrica
elseif type(op1) == "string" and type(op2) == "string" then
return op1 < op2 -- comparacin lexicogrfica
else
local h = getcomphandler(op1, op2, "__lt")
if h then
return (h(op1, op2))
else
error();
end
end
end
a > b equivale a b < a.
>le>< La operacin <=.
function le_event (op1, op2)
if type(op1) == "number" and type(op2) == "number" then
return op1 <= op2 -- comparacin numrica
elseif type(op1) == "string" and type(op2) == "string" then
return op1 <= op2 -- comparacin lexicogrfica
else
local h = getcomphandler(op1, op2, "__le")
if h then
return h(op1, op2)
else
h = getcomphandler(op1, op2, "__lt")
if h then
return not h(op2, op1)
else
error();
end
end
end
end
a >= b equivale a b <= a. Tngase presente que en ausencia de un metamtodo "le" Lua intenta usar el de "lt",
asumiendo que a <= b equivale a not (b < a).
>index>< El acceso indexado tabla[clave].
function gettable_event (tabla, clave)
local h
if type(tabla) == "table" then
local v = rawget(tabla, clave)
if v ~= nil then return v end
h = metatable(tabla).__index
if h == nil then return nil end
else
h = metatable(tabla).__index
if h == nil then
error();
end
end
if type(h) == "function" then
return (h(tabla, clave)) -- invocar el manejador
else return h[clave] -- o repetir la operacin con l
end
end
>ne/index>< La asignacin indexada tabla[clave] = valor.
function settable_event (tabla, clave, valor)
local h
if type(tabla) == "table" then
local v = rawget(tabla, clave)
if v ~= nil then rawset(tabla, clave, valor); return end
h = metatable(tabla).__newindex
if h == nil then rawset(tabla, clave, valor); return end
else
h = metatable(tabla).__newindex
if h == nil then
error();
end
end
if type(h) == "function" then
h(tabla, clave, valor) -- invoca el manejador
else h[clave] = valor -- o repite la operacin con l
end
end
>call>< invocada cuando Lua llama a un valor.
function function_event (func, ...)
if type(func) == "function" then
return func(...) -- llamada primitiva
else
local h = metatable(func).__call
if h then
return h(func, ...)
else
error()
end
end
end
2.= - Entornos
Adems de metatablas, los objetos de tipo proceso, las funciones y los userdata tienen otra tabla asociada, denominada
entorno. Como las metatablas los entornos son tablas normales y varios objetos pueden compartir el mismo entorno.
Los entornos asociados con userdata no tienen significado en Lua. Es slo una caracterstica para los programadores
asociar una tabla con userdata.
Los entornos asociados con procesos se denominan entornos globales. Son usados como entornos por defecto para los
procesos y para las funciones no anidadas creadas por el proceso (a travs de loadfile, loadstring o load) y pueden ser
accedidas directamente por el cdigo en C (vase 3.3).
Los entornos asociados con funciones C pueden ser accedidos directamente por el cdigo en C (vase 3.3). Son usadas
como entornos por defecto por otras funciones C creadas por la funcin dada.
Los entornos asociados con funciones en Lua son utilizados para resolver todos los accesos a las variables globales dentro
de la funcin (vase 2.3). Son usados tambin como entornos por defecto por otras funciones en Lua creadas por la
funcin.
Se puede cambiar el entorno de una funcin Lua o de un proceso en ejecucin invocando setfenv. Se puede obtener el
entorno de una funcin Lua o del proceso en ejecucin invocando getfenv. Para manejar el entorno de otros objetos
(userdata, funciones C, otros procesos) se debe usar la AP de C.
2.1? - Li$eracin de 2e2oria no utili@ada
Lua realiza automticamente la gestin de la memoria. Esto significa que no debemos preocuparnos ni de asignar (o
reservar) memoria para nuevos objetos ni de liberarla cuando los objetos dejan de ser necesarios. Lua gestiona la memoria
automticamente ejecutando un liberador de memoria (garbage collector) de cuando en cuando para eliminar todos los
ob"etos muertos (esos objetos que ya no son accesibles desde Lua). Todos los objetos en Lua son susceptibles de gestin
automtica: tablas, userdata, funciones, procesos y strings.
Lua implementa un liberador de memoria del tipo marcado-barrido incremental. Utiliza dos nmeros para controlar sus
ciclos de liberacin de memoria: la pausa del liberador de memoria y el multiplicador del paso del liberador de memoria.
La pausa del liberador de memoria controla cunto tiempo debe esperar el liberador de memoria antes de comenzar un
nuevo ciclo. Valores grandes hacen al liberador menos agresivo. Valores menores que 1 significan que el liberador no
esperar para comenzar un nuevo ciclo. Un valor de 2 significa que el liberador espera que la memoria total en uso se
doble antes de comenzar un nuevo ciclo.
El multiplicador del paso controla la velocidad relativa del liberador en cuanto a asignacin de memoria. Los valores ms
largos hacen el liberador ms agresivo pero tambin aumentan el tamao de cada paso incremental. Valores menores que
1 hacen el liberador demasiado lento y puede resultar en que el liberador nunca acabe un ciclo. El nmero por defecto, 2,
significa que el liberador se ejecuta a una velocidad doble que la asignacin de memoria.
Se pueden cambiar esos nmeros invocando en C a lua_gc o en Lua a collectgarbage. Ambos tienen como argumentos un
porcentaje (y entonces un argumento 100 significa un valor real de 1). Con esas funciones se puede tambin controlar el
liberador directamente (por ejemplo, pararlo y reiniciarlo).
2.1?.1 - Meta2todos de li$eracin de 2e2oria
Usando la AP de C se pueden establecer metamtodos liberadores de memoria para userdata (vase 2.8). Esos
metamtodos se denominan tambin finalizadores. stos permiten coordinar el sistema de liberacin de memoria de Lua
con gestores externos de recursos (tales como cerrar ficheros, conexiones de red o de bases de datos, o liberar su propia
memoria).
Los userdata que se van a liberar con un campo __gc en sus metatablas no son liberados inmediatamente por el liberador
de memoria. En su lugar Lua los pone en una lista. Despus de eso Lua hace el equivalente a la siguiente funcin para
cada userdata en la lista:
function gc_event (udata)
local h = metatable(udata).__gc
if h then
h(udata)
end
end
Al final de cada ciclo de liberacin de memoria, los finalizadores de userdata que aparecen en la lista que va a ser liberada
son invocados en orden inverso al de su creacin. Esto es, el primer finalizador en ser invocado es el que est asociado
con el userdata creado en ltimo lugar por el programa. El propio userdata puede ser liberado slo en el prximo ciclo de
liberacin de memoria.
2.1?.2 - Aa$las d$iles
Una tabla d!bil es una tabla cuyos elementos son referencias d!biles. Una referencia dbil es ignorada por el liberador de
memoria. En otras palabras, si las nicas referencias a un objeto son referencias dbiles entonces se libera la memoria
asociada con este objeto.
Una tabla dbil puede tener claves dbiles, valores dbiles o ambas cosas. Una tabla con claves dbiles permite la
liberacin de sus claves, pero prohibe la liberacin de sus valores. Una tabla con claves dbiles y valores dbiles permite la
liberacin tanto de claves como de valores. En cualquier caso, ya sea la clave o el valor el liberado, el par completo es
eliminado de la tabla. La debilidad de una tabla est controlada por el campo __mode de su metatabla. Si el campo __mode
es un string que contiene el carcter 'k', las claves en la tabla son dbiles. Si __mode contiene 'v', los valores en la tabla
son dbiles.
Despus de usar una tabla como metatabla no se debera cambiar el valor de su campo __mode. En caso contrario el
comportamiento dbil de las tablas controladas por esa metatabla es indefinido.
2.11 - co-rutinas
Lua tiene co-rutinas, tambin denominadas multiprocesos colaborativos. En Lua una co-rutina representa un proceso de
ejecucin independiente. A diferencia de los sistemas multiproceso, en Lua una co-rutina slo suspende su ejecucin
invocando de manera explcita una funcin yield (cesin).
Se pueden crear co-rutinas con una llamada a coroutine.create. El nico argumento de esta funcin es otra funcin que es
la funcin principal de la co-rutina.
Cuando se llama por primera vez a coroutine.resume, pasndole como argumento el proceso retornado por
coroutine.create, la co-rutina comienza a ejecutarse en la primera lnea de su funcin principal. Los argumentos extra
pasados a coroutine.resume se pasan a su vez a la funcin principal de la co-rutina. Despus de que la co-rutina empieza a
ejecutarse lo hace hasta que termina o se produce una cesi+n del control de flujo del programa.
Una co-rutina puede terminar su ejecucin de dos maneras: normalmente, cuando su funcin principal retorna (explcita o
implcitamente, despus de su ltima instruccin); y anormalmente, si se produjo un error no protegido. En el primer caso,
coroutine.resume devuelve true, ms cualquier valor retornado por la funcin principal de la co-rutina. En caso de error
coroutine.resume devuelve false ms un mensaje de error.
Una co-rutina cede el control invocando a coroutine.yield. Cuando una co-rutina cede el control la correspondiente
coroutine.resume retorna inmediatamente, incluso si la cesin ocurre dentro de una llamada a una funcin anidada (esto es,
no en la funcin principal, sino en una funcin directa o indirectamente invocada desde la funcin principal). En el caso de
una cesin, coroutine.resume tambin devuelve true, ms cualesquiera valores pasados a coroutine.yield. La prxima vez
que se resuma la misma co-rutina, continuar su ejecucin desde el punto en que fue realizada la cesin, con la llamada a
coroutine.yield devolviendo cualquier argumento extra pasado a coroutine.resume.
La funcin coroutine.wrap crea una co-rutina, justo igual que lo hara coroutine.create, pero en lugar de retornar la co-rutina
misma, devuelve una funcin que, cuando es invocada resume la co-rutina. Cualesquiera argumentos pasados a esta
funcin pasan como argumentos a coroutine.resume. coroutine.wrap devuelve todos los valores retornados por
coroutine.resume, excepto el primero (el cdigo booleano de error). A diferencia de coroutine.resume, coroutine.wrap no
captura errores; cualquier error se propaga a la rutina invocante.
Como ejemplo, considrese el siguiente cdigo:
function foo (a)
print("foo", a)
return coroutine.yield(2*a)
end

co = coroutine.create(function (a,b)
print("co-body", a, b)
local r = foo(a+1)
print("co-body", r)
local r, s = coroutine.yield(a+b, a-b)
print("co-body", r, s)
return b, "end"
end)

print("main", 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 se ejecuta se produce la siguiente salida:
co-body 1 10
foo 2
main true 4
co-body r
main true 11 -9
co-body x y
main true 10 end
main false cannot resume dead coroutine
# - La interface del "rogra2a de a"licacin 5B8I6
Esta seccin describe la AP de C para Lua, esto es, el conjunto de funciones C disponibles para que el programa anfitrin
se comunique con Lua. Todas las funciones de la AP y sus tipos y constantes relacionados estn declaradas en el fichero
de cabecera lua.h.
Aunque se usa el trmino "function", algunas rutinas en la AP pueden ser macros. Todas esas macros usan cada uno de
sus argumentos exactamente una vez (excepto su primer argumento, que es siempre el estado de Lua), y por tanto no
generan efectos laterales ocultos.
Como en la mayora de las bibliotecas de C, la funciones AP de Lua no verifican la validez ni la consistencia de sus
argumentos. Sin embargo se puede cambiar este comportamiento compilando Lua con las definiciones adecuadas para la
macro luai_apicheck, en el fichero luaconf.h.
#.1 - La "ila 5stack6
Lua usa una pila virtual para pasar valores a y desde C. Cada elemento en esta pila representa un valor de Lua (nil,
nmero, string, etc.).
Siempre que Lua llame al C, la funcin llamada obtiene una nueva pila, que es independiente de las pilas anteriores y de
las pilas de las funciones C que todava estn activas. Esta pila contiene inicialmente cualquier argumento de la funcin C y
es donde sta coloca los resultados que deben ser devueltos a la rutina invocadora (vase lua_CFunction).
Por conveniencia, la mayora de las operaciones de peticin de la AP no siguen una disciplina estricta de pila. En su lugar
pueden referirse a cualquier elemento en la pila usando un ,ndice: un valor positivo representa una posicin absoluta en la
pila (comenzando en 1); un valor negativo representa un desplazamiento relativo a la parte superior de la pila. Ms
especficamente, si la pila tiene n elementos, entonces el ndice 1 representa el primer elemento (esto es, el elemento que
fue colocado primero en la pila) y un ndice n representa el ltimo elemento; un ndice -' tambin representa el ltimo
elemento (esto es, el elemento en la parte superior) y un ndice -n representa el primer elemento. Decimos que un ndice es
vlido si tiene un valor comprendido entre 1 y la parte superior de la pila (esto es, si 1 > abs(ndice) > top).
#.2 - El ta2aCo de la "ila
Cuando el programador interacciona con la AP de Lua es responsable de asegurar la consistencia. En particular es
responsable de controlar el crecimiento correcto de la pila. Se puede usar la funcin lua_checkstack para hacer crecer el
tamao de la pila.
Siempre que Lua llama al C, se asegura de que al menos existen LUA_MNSTACK posiciones disponibles en la pila.
LUA_MNSTACK est definida como 20, as que normalmente el programador no tiene que preocuparse del espacio en la
pila, a no ser que su cdigo tenga bucles que coloquen elementos en la pila.
La mayora de las funciones de peticin aceptan como ndice cualquier valor dentro del espacio disponible en la pila, o sea
ndices hasta el mximo del tamao de la pila establecido mediante lua_checkstack. Esos ndices se denominan ,ndices
aceptables. Ms formalmente, definimos un ,ndice aceptable de la siguiente manera:
(ndice < 0 && abs(ndice) <= top) ||
(ndice > 0 && ndice <= stackspace)
Ntese que 0 no es nunca un ndice aceptable.
#.# - 8seudoDndices
Excepto en los casos en que se indique, cualquier funcin que acepta ndices vlidos tambin puede ser invocada con
pseudo,ndices, los cuales representan algunos valores en Lua que son accesibles desde el cdigo en C pero que no estn
en la pila. Los pseudondices son usados para acceder al entorno del proceso, al entorno de la funcin, al registro y a los
upvalues de una funcin C (vase 3.4).
El entorno del proceso (donde "viven" las variables globales) est siempre en el pseudondice LUA_GLOBALSNDEX. El
entorno de una funcin C que est en ejecucin est siempre en el pseudondice LUA_ENVRONNDEX.
Para acceder y cambiar el valor de una variable global se pueden usar operaciones normales de tabla en la tabla de
entorno. Por ejemplo, para acceder al valor de una variable global se hace
lua_getfield(L, LUA_GLOBALSNDEX, nombre_de_variable_global);
#.' - Instancias en C
Cuando se crea una funcin C es posible asociarle algunos valores, creando una instancia en .; esos valores se
denominan upvalues y son accesibles a la funcin en cualquier momento en que sea invocada (vase lua_pushcclosure).
Siempre que se invoque a una funcin C sus upvalues se localizan en pseudondices especficos. stos se producen
mediante la macro lua_upvalueindex. El primer valor asociado con una funcin est en la posicin lua_upvalueindex(1), y
as sucesivamente. Cualquier acceso a lua_upvalueindex(n), donde n es mayor que el nmero de upvalues de la funcin
actual produce un ndice aceptable pero invlido.
#.5 - El registro
Lua proporciona un registro, una tabla predefinida que puede ser usada por cualquier cdigo en C para almacenar cualquier
valor que Lua necesite guardar. Esta tabla se localiza siempre en el pseudondice LUA_REGSTRYNDEX. Cualquier
biblioteca de C puede almacenar datos en esta tabla, pero debera tener cuidado de elegir claves diferentes de aqullas
usadas por otras bibliotecas, para evitar conflictos. Tpicamente se podra usar como clave un string conteniendo el nombre
de la biblioteca o userdata "ligeros" con la direccin de un objeto de C en el cdigo.
Las claves de tipo entero en el registro son usadas como mecanismo para referenciar, implementado en la biblioteca
auxiliar, y por tanto no deberan ser usados para otros propsitos diferentes.
#.1 - Manejo de errores en C
nternamente Lua usa la funcin de C longjmp para facilitar el manejo de errores. (Se puede tambin elegir usar
directamente excepciones si se trabaja en C++; vase el fichero luaconf.h.) Cuando Lua se encuentra con cualquier error
(tal como un error de asignacin de memoria, un error de tipo, un error de sintaxis o un error de ejecucin) entonces activa
un error, esto es, realiza un salto largo en la memoria. Un entorno protegido usa setjmp para establecer un punto de
recuperacin; cualquier error provoca un salto al punto de recuperacin activo ms reciente.
Muchas funciones de la AP pueden activar un error, por ejemplo debido a un problema de asignacin de memoria. La
documentacin de cada funcin indica si puede activar un error.
Dentro de una funcin C se puede activar un error invocando lua_error.
#.3 - Eunciones ! ti"os
He aqu la lista de todas las funciones y tipos de la AP de C por orden alfabtico. Cada funcin tiene un indicador como
ste: [-o, +p, %]
El primer campo, o, indica cuntos elementos elimina la funcin en la pila. El segundo campo, p, es cuantos elementos
coloca la funcin en la pila. (Toda funcin siempre coloca sus resultados despus de eliminar sus argumentos.) Un campo
de la forma x|y significa que la funcin puede colocar (o eliminar) x y elementos, dependiendo de la situacin; un signo de
interrogacin '?' significa que no se puede conocer cuntos elementos coloca/elimina la funcin observando slo sus
argumentos (por ejemplo, puede depender de lo qu est en la pila). El tercer, campo x, indica si la funcin puede activar
errores: '-' significa que la funcin nunca activa errores; 'm' indica que la funcin puede activar un error slo debido a falta
de memoria; 'e' indica que la funcin puede activar otros tipos de errores; 'v' indica que la funcin puede activar un error a
propsito.
luaFBlloc
typedef void * (*lua_Alloc) (void *ud,
void *ptr,
size_t osize,
size_t nsize);
El tipo de la funcin que maneja la memoria usada por los estados de Lua. La funcin que maneja memoria debe
proporcionar una funcionalidad similar a realloc, pero no exactamente la misma. Sus argumentos son: ud, un puntero opaco
pasado a lua_newstate; ptr, un puntero al bloque que est siendo reservado/reasignado/liberado; osize, el tamao original
del bloque; nsize, el nuevo tamao del bloque. ptr es NULL si y slo si osize es cero. Cuando nsize es cero, el manejador
debe retornar NULL; si osize no es cero debe ser liberado el bloque apuntado por ptr. Cuando nsize no es cero el
manejador retorna NULL si y slo si no puede ejecutar la peticin. Cuando nsize no es cero y osize es cero el manejador
debera comportarse como malloc. Cuando nsize y osize no son cero, el manejador se comporta como realloc. Lua asume
que el manejador nunca falla cuando osize >= nsize.
He aqu una implementacin simple para la funcin manejadora de memoria. Es usada en la biblioteca auxiliar por
lua_newstate.
static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) {
(void) ud; (void) osize; /* no usadas */
if (nsize == 0) {
free(ptr);
return NULL;
}
else
return realloc(ptr, nsize);
}
Este cdigo asume que free(NULL) no tiene efecto y que realloc(NULL, size) es equivalente a malloc(size). ANS C asegura
ambos comportamientos.
luaFat"anic
[-0, +0, -]
lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf);
Establece una nueva funcin de pnico y devuelve la vieja.
Si ocurre un error fuera de cualquier entorno protegido Lua llama a la funci+n pnico y luego invoca exit(EXT_FALURE),
saliendo por tanto de la aplicacin anfitriona. Si usa otra funcin de pnico diferente, sta puede evitar esta salida sin
retorno (por ejemplo, haciendo un salto largo).
La funcin de pnico puede acceder al mensaje de error en la parte superior de la pila.
luaFcall
[-(nargs + 1), +nresults, e]
void lua_call (lua_State *L, int nargs, int nresults);
Llama a una funcin.
Para llamar a una funcin se debe usar el siguiente protocolo: primero, la funcin a ser invocada se coloca en la parte
superior de la pila; entonces, se colocan tambin en la pila los argumentos de la funcin en orden directo; esto es, el primer
argumento se coloca primero. Finalmente, se llama a lua_call; nargs es el nmero de argumentos que se han colocado en
la pila. Todos los argumentos y el valor de la funcin se eliminan de la pila cuando la funcin es invocada. Los resultados de
la funcin se colocan en la parte superior de la pila cuando retorna la funcin. El nmero de resultados se ajusta a nresults,
a no ser que nresults sea LUA_MULTRET. En este caso se colocan todos los resultados de la funcin. Lua tiene cuidado de
que los valores retornados se ajusten en el espacio de pila. Los resultados de la funcin son colocados en la pila en orden
directo (el primero es colocado antes), por lo que despus de la llamada el ltimo resultado aparece en la parte superior de
la pila.
Cualquier error dentro de la funcin llamada se propaga hacia atrs (con un longjmp).
El siguiente ejemplo muestra cmo puede el programa anfitrin hacer algo equivalente a este cdigo en Lua:
a = f("how", t.x, 14)
Aqu est en C:
lua_getfield(L, LUA_GLOBALSNDEX, "f"); /* funcin que es llamada */
lua_pushstring(L, "how"); /* primer argumento */
lua_getfield(L, LUA_GLOBALSNDEX, "t"); /* tabla que es indexada */
lua_getfield(L, -1, "x"); /* coloca en la pila t.x (2 argumento) */
lua_remove(L, -2); /* elimina 't' de la pila */
lua_pushinteger(L, 14); /* 3 argumento */
lua_call(L, 3, 1); /* llama a la funcin con 3 argumentos y 1 resultado */
lua_setfield(L, LUA_GLOBALSNDEX, "a"); /* modifica la variable global 'a' */
Tngase presente que el cdigo de arriba est "equilibrado" al final, pues la pila ha vuelto a su configuracin inicial. Esto
est considerado como una buena prctica de programacin.
luaFCEunction
typedef int (*lua_CFunction) (lua_State *L);
Tipo para las funciones C.
Con objeto de comunicar adecuadamente con Lua, una funcin C debe usar el siguiente protocolo, el cual define la manera
en que son pasados los argumentos y los resultados: una funcin C recibe sus argumentos desde Lua en su pila en orden
directo (el primer argumento se coloca primero). Por tanto, cuando comienza una funcin, lua_gettop(L) devuelve el nmero
de argumentos recibidos por la funcin. Su primer argumento (si existe) est en el ndice 1 y su ltimo argumento est en el
ndice lua_gettop(L). Para retornar valores a Lua una funcin C slo los coloca en la pila, en orden directo (el primer
resultado va primero), y retorna el nmero de resultados. Cualquier otro valor en la pila por debajo de los resultados debe
ser adecuadamente descartado por Lua. Como una funcin Lua, una funcin C llamada desde Lua puede retornar varios
resultados.
Como ejemplo, la siguiente funcin recibe un nmero variable de argumentos numricos y retorna su media y su suma:
static int foo (lua_State *L) {
int n = lua_gettop(L); /* nmero de argumentos */
lua_Number sum = 0;
int i;
for (i = 1; i <= n; i++) {
if (!lua_isnumber(L, i)) {
lua_pushstring(L, "argumento incorrecto en la funcin 'media'");
lua_error(L);
}
sum += lua_tonumber(L, i);
}
lua_pushnumber(L, sum/n); /* primer resultado */
lua_pushnumber(L, sum); /* segundo resultado */
return 2; /* nmero de resultados */
}
luaFc0ec,stac,
[-0, +0, m]
int lua_checkstack (lua_State *L, int extra);
Se asegura de que hay al menos extra posiciones libres en la pila. Devuelve false si no puede hacer crecer la pila hasta ese
tamao. Esta funcin nunca disminuye la pila; si la pila es ya ms grande que el nuevo tamao la deja sin modificar.
luaFclose
[-0, +0, -]
void lua_close (lua_State *L);
Destruye todos los objetos en el estado dado de Lua (llamando al correspondiente metamtodo de liberacin de memoria,
si existe) y libera toda la memoria dinmica usada por este estado. En algunas plataformas puede no ser necesario llamar a
esta funcin, debido a que todos los recursos se liberan de manera natural cuando finaliza el programa anfitrin. Por otro
lado, programas de ejecucin larga, como puede ser el demonio de un servidor web, pueden necesitar la liberacin de
estados tan pronto como stos no se necesiten para evitar un crecimiento desmesurado.
luaFconcat
[-n, +1, e]
void lua_concat (lua_State *L, int n);
Concatena los n valores de la parte superior de la pila, los elimina y deja el resultado en la parte superior de la pila. Si n es
1 el resultado es el valor simple en la pila (esto es, la funcin no hace nada); si n es 0 el resultado es un string vaco. La
concatenacin se realiza siguiendo la semntica normal de Lua (vase 2.5.4).
luaFc"call
[-0, +(0|1), -]
int lua_cpcall (lua_State *L, lua_CFunction func, void *ud);
nvoca la funcin C func en modo protegido. func comienza con un solo elemento en su pila, un userdata ligero conteniendo
ud. En caso de errores lua_cpcall devuelve el mismo cdigo de error que lua_pcall, adems del objeto error en la parte
superior de la pila; en caso contrario retorna cero y no cambia la pila. Todos los valores retornados por func se descartan.
luaFcreateta$le
[-0, +1, m]
void lua_createtable (lua_State *L, int narr, int nrec);
Crea una nueva tabla vaca y la coloca en la pila. La nueva tabla tiene espacio reservado para narr elementos array y nrec
elementos no array. Esta reserva es til cuando no se sabe cuntos elementos va a contener la tabla. En otro caso se
puede usar la funcin lua_newtable.
luaFdu2"
[-0, +0, m]
int lua_dump (lua_State *L, lua_Writer writer, void *data);
Vuelca una funcin en forma de chunk binario. Recibe una funcin de Lua en la parte superior de la pila y produce un chunk
binario que si se carga de nuevo resulta en una funcin equivalente a la volcada previamente. Segn va produciendo partes
del chunk, lua_dump invoca a la funcin writer (vase lua_Writer) con los datos data para escribirlos.
El valor retornado es el cdigo de error devuelto por la ltima llamada a Writer; 0 significa no error.
Esta funcin no elimina de la pila la funcin de Lua.
luaFe+ual
[-0, +0, e]
int lua_equal (lua_State *L, int index1, int index2);
Retorna 1 si los dos valores en los ndices aceptables index1 e index2 son iguales, siguiendo la semntica del operador ==
de Lua (esto es, puede invocar metamtodos). En otro caso retorna 0. Tambin devuelve 0 si alguno de los ndices no es
vlido.
luaFerror
[-1, +0, v]
int lua_error (lua_State *L);
Genera un error de Lua. El mensaje de error (que puede ser realmente un valor de Lua de cualquier tipo) debe de estar en
la parte superior de la pila. Esta funcin realiza un salto largo, y por tanto nunca retorna. (vase luaL_error).
luaFgc
[-0, +0, e]
int lua_gc (lua_State *L, int what, int data);
Controla el liberador de memoria.
Esta funcin realiza varias tareas, de acuerdo con el valor del argumento what:
LUA_GCSTOP --- detiene el liberador de memoria.
LUA_GCRESTART --- reinicia el liberador de memoria.
LUA_GCCOLLECT --- realiza un ciclo completo de liberacin de memoria.
LUA_GCCOUNT --- retorna la cantidad actual de memoria (en Kbytes) en uso por Lua.
LUA_GCCOUNTB --- retorna el resto de dividir por 1024 la cantidad actual de memoria en bytes en uso por Lua.
LUA_GCSTEP --- realiza un paso incremental de liberacin de memoria. El "tamao" del paso est controlado por
data (un valor mayor significa ms pasos) de una manera no especificada. Si se desea controlar el tamao del
paso se debe afinar experimentalmente el valor de data. La funcin retorna 1 si el paso acab con un ciclo de
liberacin de memoria.
LUA_GCSETPAUSE --- establece data/100 como el nuevo valor de la pausa del liberador de memoria (vase
2.10). La funcin retorna el valor previo de la pausa.
LUA_GCSETSTEPMUL --- establece data/100 como el nuevo valor del multiplicador del paso del liberador de
memoria (vase 2.10). La funcin retorna el valor previo del multiplicador.
luaFgetallocf
[-0, +0, -]
lua_Alloc lua_getallocf (lua_State *L, void **ud);
Retorna la funcin manejadora de memoria de un estado dado. Si ud no es NULL Lua guarda en *ud el puntero opaco
pasado a lua_newstate.
luaFgetfenv
[-0, +1, -]
void lua_getfenv (lua_State *L, int index);
Coloca en la pila la tabla de entorno de un valor en el ndice dado.
luaFgetfield
[-0, +1, e]
void lua_getfield (lua_State *L, int index, const char *k);
Coloca en la pila el valor t[k], donde t es el valor dado por el ndice vlido. Como en Lua esta funcin puede activar un
metamtodo para el evento "index" (vase 2.8).
luaFgetglo$al
[-0, +1, e]
void lua_getglobal (lua_State *L, const char *name);
Coloca en la pila el valor del nombre global. Est definida como macro:
#define lua_getglobal(L,s) lua_getfield(L, LUA_GLOBALSNDEX, s)
luaFget2etata$le
[-0, +(0|1), -]
int lua_getmetatable (lua_State *L, int index);
Coloca en la pila la metatabla del valor situado en el ndice aceptable dado. Si el ndice no es vlido o si el valor no tiene
metatabla, la funcin retorna 0 y no coloca nada en la pila.
luaFgetta$le
[-1, +1, e]
void lua_gettable (lua_State *L, int index);
Coloca en la pila el valor t[k], donde t es el valor en el ndice vlido y k es el valor situado en la parte superior de la pila.
Esta funcin quita la clave de la parte superior de la pila (colocando a su vez el valor resultante en su lugar). Como en Lua
esta funcin puede activar un metamtodo para el evento "index" (vase 2.8).
luaFgetto"
[-0, +0, -]
int lua_gettop (lua_State *L);
Retorna el ndice del elemento situado en la parte superior de la pila. Debido a que los ndices comienzan en 1 este
resultado es igual al nmero de elementos en la pila (y as, 0 significa una pila vaca).
luaFinsert
[-1, +1, -]
void lua_insert (lua_State *L, int index);
Mueve el elemento situado en la parte superior de la pila hacia el ndice vlido dado, desplazando hacia arriba los
elementos por encima de este ndice para abrir hueco. No puede ser invocada con un pseudondice debido a que ste no
es una posicin real en la pila.
luaFInteger
typedef ptrdiff_t lua_nteger;
El tipo usado por la AP de Lua para representar valores enteros.
Por defecto es ptrdiff_t, que es normalmente el tipo entero con signo ms grande que la mquina maneja
"confortablemente".
luaFis$oolean
[-0, +0, -]
int lua_isboolean (lua_State *L, int index);
Retorna 1 si el valor en la situacin del ndice aceptable tiene tipo booleano y 0 en caso contrario.
luaFiscfunction
[-0, +0, -]
int lua_iscfunction (lua_State *L, int index);
Retorna 1 si el valor en la situacin del ndice aceptable es una funcin C y 0 en caso contrario.
luaFisfunction
[-0, +0, -]
int lua_isfunction (lua_State *L, int index);
Retorna 1 si el valor en la situacin del ndice aceptable es una funcin (en C o en Lua) y 0 en caso contrario.
luaFislig0tuserdata
[-0, +0, -]
int lua_islightuserdata (lua_State *L, int index);
Retorna 1 si el valor en la situacin del ndice aceptable es un userdata ligero y 0 en caso contrario.
luaFisnil
[-0, +0, -]
int lua_isnil (lua_State *L, int index);
Retorna 1 si el valor en la situacin del ndice aceptable es nil y 0 en caso contrario.
luaFisnone
[-0, +0, -]
int lua_isnone (lua_State *L, int index);
Retorna 1 si el valor en la situacin del ndice aceptable es no vlido (esto es, si se refiere a un elemento fuera de la pila
actual) y 0 en caso contrario.
luaFisnoneornil
[-0, +0, -]
int lua_isnoneornil (lua_State *L, int index);
Retorna 1 si el valor en la situacin del ndice aceptable es no vlido (esto es, si se refiere a un elemento fuera de la pila
actual) o si el valor en este ndice es nil, y 0 en caso contrario.
luaFisnu2$er
[-0, +0, -]
int lua_isnumber (lua_State *L, int index);
Retorna 1 si el valor en la situacin del ndice aceptable es un nmero o un string convertible a nmero y 0 en caso
contrario.
luaFisstring
[-0, +0, -]
int lua_isstring (lua_State *L, int index);
Retorna 1 si el valor en la situacin del ndice aceptable es un string o un nmero (que es siempre convertible a un string) y
0 en caso contrario.
luaFista$le
[-0, +0, -]
int lua_istable (lua_State *L, int index);
Retorna 1 si el valor en la situacin del ndice aceptable es una tabla y 0 en caso contrario.
luaFist0read
[-0, +0, -]
int lua_isthread (lua_State *L, int index);
Retorna 1 si el valor en la situacin del ndice aceptable es un proceso y 0 en caso contrario.
luaFisuserdata
[-0, +0, -]
int lua_isuserdata (lua_State *L, int index);
Retorna 1 si el valor en la situacin del ndice aceptable es un userdata (ligero o completo) y 0 en caso contrario.
luaFlesst0an
[-0, +0, e]
int lua_lessthan (lua_State *L, int index1, int index2);
Retorna 1 si el valor situado en la posicin del ndice aceptable index1 es menor que el situado en la posicin del ndice
aceptable index2, siguiendo la semntica del operador < de Lua (esto es, puede invocar metamtodos). En caso contrario
retorna 0. Tambin retorna 0 si alguno de los ndices es invlido.
luaFload
[-0, +1, -]
int lua_load (lua_State *L,
lua_Reader reader,
void *data,
const char *chunkname);
Carga un chunk de Lua. Si no hay errores, lua_load coloca el chunk compilado en la parte superior de la pila. En caso
contrario coloca ah un mensaje de error. Los valores de retorno de lua_load son:
0 --- sin errores.
LUA_ERRSYNTAX --- error de sintaxis durante la precompilacin.
LUA_ERRMEM --- error de reserva de memoria.
lua_load detecta automticametne si el chunk est en binario o en forma de texto, y lo carga de acuerdo con esto (vase el
programa luac).
lua_load usa una funcin lectora suplida por el usuario para leer el chunk (vase lua_Reader). El argumento data es un
valor opaco pasado a la funcin lectora.
El argumento chunkname da un nombre al chunk. el cual es usado en los mensajes de error y en la informacin de
depuracin (vase 3.8).
luaFne/state
[-0, +0, -]
lua_State *lua_newstate (lua_Alloc f, void *ud);
Crea un nuevo estado independiente. Retorna NULL si no puede crear el estado (debido a falta de memoria). El argumento
f es la funcin de reserva de memoria; Lua hace toda la reserva de memoria para este estado a travs de esta funcin. El
segundo argumento, ud, es un puntero opaco que Lua simplemente pasa al reservador de memoria en cada llamada.
luaFne/ta$le
[-0, +1, m]
void lua_newtable (lua_State *L);
Crea una nueva tabla vaca y la coloca en la pila. Equivale a lua_createtable(L, 0, 0).
luaFne/t0read
[-0, +1, m]
lua_State *lua_newthread (lua_State *L);
Crea un nuevo proceso, lo coloca en la pila y retorna un puntero a un lua_State que representa este nuevo proceso. El
nuevo estado retornado por esta funcin comparte con el original todos los objetos globales (como las tablas), pero tiene
una pila de ejecucin independiente.
No existe una funcin explcita para cerrar o destruir un proceso. Los procesos estn sujetos a liberacin de memoria, como
cualquier otro objeto de Lua.
luaFne/userdata
[-0, +1, m]
void *lua_newuserdata (lua_State *L, size_t size);
Esta funcin reserva un nuevo bloque de memoria con el tamao dado, coloca en la pila un nuevo userdata completo con la
direccin del bloque de memoria y retorna esta direccin.
Los userdata representan valores de C en Lua. Un userdata completo representa un bloque de memoria. Es un objeto
(como una tabla): se puede crear, puede tener su propia metatabla y se puede detectar cundo est siendo eliminado de
memoria. Un userdata completo es slo igual a s mismo (en un test de igualdad directa).
Cuando Lua libera un userdata completo con un metamtodo gc, llama al metamtodo y marca el userdata como finalizado.
Cuando este userdata es liberado de nuevo entonces es cuando Lua libera definitivamente la memoria correspondiente.
luaFnext
[-1, +(2|0), e]
int lua_next (lua_State *L, int index);
Elimina una clave de la pila y coloca un par clave-valor de una tabla en el ndice dado (la "siguiente" pareja despus de la
clave dada). Si no hay ms elementos en la tabla entonces lua_next retorna 0 (y no coloca nada en la pila).
Una tpica iteracin de recorrido de tabla sera:
/* la tabla est en la pila en el ndice 't' */
lua_pushnil(L); /* primera clave */
while (lua_next(L, t) != 0) {
/* 'clave' est 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 siguiente iteracin */
lua_pop(L, 1);
}
Mientras se recorre una tabla no debe llamarse a lua_tolstring directamente en una clave a no ser que se conozca que la
clave es realmente un string. Recuerde que lua_tolstring cambia el valor en el ndice dado; esto confunde a la siguiente
llamada a lua_next.
luaFGu2$er
typedef double lua_Number;
El tipo de los nmeros en Lua. Por defecto es un double, pero puede ser cambiado en luaconf.h.
A travs del fichero de configuracin se puede cambiar Lua para que opere con otro tipo de nmeros (por ejemplo, float o
long).
luaFo$jlen
[-0, +0, -]
size_t lua_objlen (lua_State *L, int index);
Retorna la "longitud" de un valor situado en el ndice aceptable: para un string, es la longitud del mismo; para una tabla, es
el resultado del operador longitud ('#'); para un userdata, es el tamao del bloque de memoria reservado para el mismo;
para otros valores es 0.
luaF"call
[-(nargs + 1), +(nresults|1), -]
int lua_pcall (lua_State *L, int nargs, int nresults, int errfunc);
nvoca una funcin 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 igual que lua_call. Sin embargo en caso de error lua_pcall lo captura, colocando un nico valor en la
pila (el mensaje de error) y retorna un cdigo de error. Como lua_call, lua_pcall siempre elimina la funcin y sus
argumentos de la pila.
Si errfunc es 0 entonces el mensaje de error retornado en la pila es exactamente el mensaje original. En otro caso, errfunc
es el ndice en la pila de una funci+n mane"adora de error. (En la implementacin actual, este ndice no puede ser un
pseudondice.) En caso de errores de ejecucin esta funcin ser llamada con el mensaje de error y el valor devuelto ser
el mensaje retornado en la pila por lua_pcall.
Tpicamente la funcin manejadora de error se usa para aadir ms informacin de depuracin al mensaje de error, tal
como un "trazado inverso" de la pila. Esa informacin no puede ser recolectada despus del retorno de lua_pcall, puesto
que por entonces la pila ya no tiene esa informacin.
La funcin lua_pcall retorna 0 en caso de xito o uno de los siguientes cdigos de error (definidos en lua.h):
LUA_ERRRUN --- un error de ejecucin.
LUA_ERRMEM --- un error de reserva de memoria. Para este error Lua no llama a la funcin manejadora de error.
LUA_ERRERR --- error mientras se est ejecutando la funcin manejadora de error.
luaF"o"
[-n, +0, -]
void lua_pop (lua_State *L, int n);
Elimina n elementos de la pila.
luaF"us0$oolean
[-0, +1, -]
void lua_pushboolean (lua_State *L, int b);
Coloca el valor booleano b en la pila.
luaF"us0cclosure
[-n, +1, m]
void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n);
Coloca en la pila una nueva instancia en C.
Cuando se crea una funcin C es posible asociarle algunos valores, creando entonces una instancia en . (vase 3.4);
estos valores son entonces accesibles a la funcin en cualquier momento en que sea invocada. Para asociar valores a una
funcin C, primero stos deberan colocarse en la pila (cuando hay varios, el primero se coloca antes). Entonces se invoca
lua_pushcclosure para crear y colocar la funcin C en la pila, con el argumento n indicando cuantos valores estn
asociados con la misma. lua_pushcclosure tambin elimina esos valores de la pila.
luaF"us0cfunction
[-0, +1, m]
void lua_pushcfunction (lua_State *L, lua_CFunction f);
Coloca una funcin C en la pila. Esta funcin recibe un puntero a una funcin C y coloca en la pila un valor de Lua de tipo
function que, cuando se llama, invoca la correspondiente funcin C.
Cualquier funcin que sea registrada en Lua debe seguir el protocolo correcto para recibir sus argumentos y devolver sus
resultados (vase lua_CFunction).
lua_pushcfunction(L, f) est definida como una macro:
#define lua_pushcfunction(L, f) lua_pushcclosure(L, f, 0)
luaF"us0fstring
[-0, +1, m]
const char *lua_pushfstring (lua_State *L, const char *fmt, ...);
Coloca en la pila un string formateado y retorna un puntero a este string. Es similar a la funcin sprintf de C, pero tiene con
ella algunas importantes diferencias:
No tiene que reservar memoria para el resultado, puesto que ste es un string de Lua, y Lua se encarga de
realizar la reserva de memoria (y tambin la liberacin).
Los especificadores de conversin son bastante restrictivos. No hay indicadores, anchuras o precisiones. Los
especificadores de conversin pueden ser slo: '%%' (inserta un '%' en el string), '%s' (inserta un string terminado
en cero sin restricciones de tamao), '%f' (inserta un lua_Number), '%p' (inserta un puntero como nmero
hexadecimal), '%d' (inserta un int), y '%c' (inserta un int como carcter).
luaF"us0integer
[-0, +1, -]
void lua_pushinteger (lua_State *L, lua_nteger n);
Coloca un nmero entero de valor n en la pila.
luaF"us0lig0tuserdata
[-0, +1, -]
void lua_pushlightuserdata (lua_State *L, void *p);
Coloca un userdata ligero en la pila.
Los userdata representan valores de C en Lua. Un userdata ligero representa un puntero. Es un valor (como un nmero):
no se crea ni tiene metatablas y no sufre liberacin de memoria (puesto que nunca fue reservada). En una comparacin de
igualdad, un userdata ligero es igual que cualquier otro userdata ligero con la misma direccin en C.
luaF"us0literal
[-0, +1, m]
void lua_pushliteral (lua_State *L, const char *s);
Esta macro es equivalente a lua_pushlstring, pero puede ser usada solamente cuando s es un string literal. En esos casos,
proporciona automticamente la longitud del string.
luaF"us0lstring
[-0, +1, m]
void lua_pushlstring (lua_State *L, const char *s, size_t len);
Coloca el string apuntado por s con tamao len en la pila. Lua realiza (o reutiliza) una copia interna del string dado, as que
la memoria en s puede ser liberada o reutilizada inmediamente despus de que la funcin retorne. El string puede contener
ceros.
luaF"us0nil
[-0, +1, -]
void lua_pushnil (lua_State *L);
Coloca un valor nil en la pila.
luaF"us0nu2$er
[-0, +1, -]
void lua_pushnumber (lua_State *L, lua_Number n);
Coloca un nmero con valor n en la pila.
luaF"us0string
[-0, +1, m]
void lua_pushstring (lua_State *L, const char *s);
Coloca el string terminado en cero al que apunta s en la pila. Lua realiza (o reutiliza) una copia interna del string dado, as
que la memoria en s puede ser liberada o reutilizada inmediamente despus de que la funcin retorne. El string no puede
contener caracteres cero; se asume que el final del mismo es el primer carcter cero que aparezca.
luaF"us0t0read
[-0, +1, -]
int lua_pushthread (lua_State *L);
Coloca un proceso representado por L en la pila. Retorna 1 si este proceso es el proceso principal de su estado.
luaF"us0value
[-0, +1, -]
void lua_pushvalue (lua_State *L, int index);
Coloca una copia del elemento situado en el ndice vlido dado en la pila.
luaF"us0vfstring
[-0, +1, m]
const char *lua_pushvfstring (lua_State *L,
const char *fmt,
va_list argp);
Equivalente a lua_pushfstring, excepto que recibe un argumento de tipo va_list en lugar de un nmero variable de
argumentos.
luaFra/e+ual
[-0, +0, -]
int lua_rawequal (lua_State *L, int index1, int index2);
Retorna 1 si los dos valores situados en los ndices aceptables index1 e index2 son iguales de manera primitiva (esto es,
sin invocar metamtodos). En caso contrario retorna 0. Tambin retorna 0 si alguno de los ndices no es vlido.
luaFra/get
[-1, +1, -]
void lua_rawget (lua_State *L, int index);
Similar a lua_gettable, pero realiza un acceso directo (sin metamtodos).
luaFra/geti
[-0, +1, -]
void lua_rawgeti (lua_State *L, int index, int n);
Coloca en la pila el valor t[n], donde t es el valor en el ndice vlido. El acceso es directo, esto es, sin invocar metamtodos.
luaFra/set
[-2, +0, m]
void lua_rawset (lua_State *L, int index);
Similar a lua_settable, pero realizando una asignacin directa (sin invocar metamtodos).
luaFra/seti
[-1, +0, m]
void lua_rawseti (lua_State *L, int index, int n);
Realiza el equivalente a t[n] = v, donde t es el valor en el ndice vlido y v es el valor en la parte superior de la pila.
Esta funcin elimina el valor de la parte superior de la pila. La asignacin es directa, sin invocar metamtodos.
luaFReader
typedef const char * (*lua_Reader) (lua_State *L,
void *data,
size_t *size);
La funcin de lectura usada por lua_load. Cada vez que necesita otro fragmento de chunk, lua_load llama al "lector",
pasndole su argumento data. El lector debe retornar un puntero a un bloque de memoria con un nuevo fragmento de
chunk y establece size como el tamao del bloque. El bloque debe existir hasta que la funcin lectora se invoque de nuevo.
Para sealar el final del chunk el lector debe retornar NULL. La funcin lectora puede retornar fragmentos de cualquier
tamao mayor que cero.
luaFregister
[-0, +0, e]
void lua_register (lua_State *L,
const char *name,
lua_CFunction f);
Establece la funcin C f como el nuevo valor del nombre global. Est definida en la macro:
#define lua_register(L,n,f) \
(lua_pushcfunction(L, f), lua_setglobal(L, n))
luaFre2ove
[-1, +0, -]
void lua_remove (lua_State *L, int index);
Elimina el elemento en la posicin del ndice vlido dado, desplazando hacia abajo los elementos que estaban por encima
de este ndice para llenar el hueco. No puede ser llamada con un pseudondice, debido a que ste no es una posicin real
en la pila.
luaFre"lace
[-1, +0, -]
void lua_replace (lua_State *L, int index);
Mueve el elemento que est en la parte superior de la pila a la posicin dada (y lo elimina de la parte superior de la pila), sin
desplazar ningn elemento de la misma (por tanto reemplazando el valor en la posicin dada).
luaFresu2e
[-?, +?, -]
int lua_resume (lua_State *L, int narg);
Comienza y resume una co-rutina en un proceso dado.
Para comenzar una co-rutina se debe crear un nuevo proceso (vase lua_newthread); entonces se coloca en su propia pila
la funcin principal ms cualquier posible argumento; posteriormente se invoca lua_resume, con narg siendo el nmero de
argumentos. Esta llamada retorna cuando la co-rutina suspende o finaliza su ejecucin. Cuando retorna, la pila contiene
todos los valores pasados a lua_yield, o todos los valores retornados por el cuerpo de la funcin. lua_resume retorna
LUA_YELD si la co-rutina cedi el control, 0 si la co-rutina acab su ejecucin sin errores, o un cdigo de error en caso de
errores (vase lua_pcall). En caso de error, se deja informacin en la pila, as que se puede usar la AP de depuracin con
ella. El mensaje de error est en la parte superior de la pila. Para reiniciar una co-rutina se ponen en la pila slo los valores
que son pasados como resultado de yield, y entonces se invoca lua_resume.
luaFsetallocf
[-0, +0, -]
void lua_setallocf (lua_State *L, lua_Alloc f, void *ud);
Utiliza f con el userdata ud como funcin de reserva de memoria de un estado dado .
luaFsetfenv
[-1, +0, -]
int lua_setfenv (lua_State *L, int index);
Elimina una tabla de la parte superior de la pila y la toma como nuevo entorno para el valor situado en la posicin del ndice.
Si el valor dado no es ni una funcin ni un proceso ni un userdata entonces lua_setfenv retorna 0. En caso contrario retorna
1.
luaFsetfield
[-1, +0, e]
void lua_setfield (lua_State *L, int index, const char *k);
Realiza el equivalente a t[k] = v, donde t es el valor en la posicin del ndice vlido y v es el valor en la parte superior de la
pila.
Esta funcin elimina el valor de la pila. Como en Lua, esta funcin puede activar un metamtodo para el evento "newindex"
(vase 2.8).
luaFsetglo$al
[-1, +0, e]
void lua_setglobal (lua_State *L, const char *name);
Elimina un valor de la pila y lo toma como nuevo valor del nombre global. Est definida en una macro:
#define lua_setglobal(L,s) lua_setfield(L, LUA_GLOBALSNDEX, s)
luaFset2etata$le
[-1, +0, -]
int lua_setmetatable (lua_State *L, int index);
Elimina una tabla de la pila y la toma como nueva metatabla para el valor en la situacin del ndice aceptable.
luaFsetta$le
[-2, +0, e]
void lua_settable (lua_State *L, int index);
Hace el equivalente a t[k] = v, donde t es el valor en la posicin del ndice vlido, v es el valor en la parte superior de la pila
y k es el valor justamente debajo.
Esta funcin elimina de la pila tanto la clave como el valor. Como en Lua, esta funcin puede activar un metamtodo para el
evento "newindex" (vase 2.8).
luaFsetto"
[-?, +?, -]
void lua_settop (lua_State *L, int index);
Acepta cualquier ndice aceptable 0 y establece la parte superior de la pila en este ndice. Si ese valor es mayor que el
antiguo entonces los nuevos elementos se rellenan con nil. Si index es 0 entonces todos los elementos de la pila se
eliminan.
luaF(tate
typedef struct lua_State lua_State;
Estructura opaca que almacena todo el estado de un intrprete de Lua. La biblioteca de Lua es totalmente re-entrante: no
tiene variables globales. Toda la informacin acerca de un estado se guarda en esta estructura.
Un puntero a este estado debe ser pasado como primer argumento a cualquier funcin de la biblioteca, excepto a
lua_newstate, la cual crea un nuevo estado de Lua desde cero.
luaFstatus
[-0, +0, -]
int lua_status (lua_State *L);
Retorna el estatus del proceso L.
El estatus puede ser 0 para un proceso normal, un cdigo de error si el proceso finaliza su ejecucin con un error, o
LUA_YELD si el proceso est suspendido.
luaFto$oolean
[-0, +0, -]
int lua_toboolean (lua_State *L, int index);
Convierte el valor de Lua situado en la posicin del ndice aceptable en un booleano de C (0 1). Como todos los test en
Lua, lua_toboolean retorna 1 para cada valor de Lua diferente de false y nil; en caso contrario retorna 0. Tambin retorna 0
cuando se invoca sin un ndice vlido. (Si se desea aceptar slo los valores booleanos reales, sese lua_isboolean para
verificar el tipo del valor.)
luaFtocfunction
[-0, +0, -]
lua_CFunction lua_tocfunction (lua_State *L, int index);
Convierte en una funcin C el valor situado en el ndice aceptable. Este valor debe ser una funcin C; en caso contrario
retorna NULL.
luaFtointeger
[-0, +0, -]
lua_nteger lua_tointeger (lua_State *L, int index);
Convierte el valor de Lua situado en el ndice aceptable en un entero sin signo del tipo lua_nteger. El valor de Lua debe ser
un nmero o un string convertible a un nmero (vase 2.2.1); en otro caso lua_tointeger retorna 0.
Si el nmero no es entero se trunca de una manera no especificada.
luaFtolstring
[-0, +0, m]
const char *lua_tolstring (lua_State *L, int index, size_t *len);
Convierte el valor de Lua situado en la posicin del ndice aceptable en un string (const char*). Si len no es NULL, tambin
establece *len como longitud del mismo. El valor Lua puede ser un string o un nmero; en caso contrario la funcin retorna
NULL. Si el valor es un nmero entonces lua_tolstring tambin cambia el valor actual en la pila a un string. (Este cambio
confunde a lua_next cuando lua_tolstring se aplica a claves durante el recorrido de una tabla.)
lua_tolstring retorna un puntero totalmente alineado a un string dentro de un estado de Lua. Este string siempre tiene un
cero ('\0') despus de su ltimo carcter (como en C), pero puede contener otros ceros en su cuerpo. Debido a que Lua
tiene liberacin de memoria, no existen garantas de que el puntero retornado por lua_tolstring siga siendo vlido despus
de que el valor correspondiente sea eliminado de la pila.
luaFtonu2$er
[-0, +0, -]
lua_Number lua_tonumber (lua_State *L, int index);
Convierte el valor Lua dado en la posicion del ndice aceptable en un nmero (vase lua_Number). El valor Lua debe ser un
nmero o un string convertible a nmero (vase 2.2.1); en caso contrario lua_tonumber retorna 0.
luaFto"ointer
[-0, +0, -]
const void *lua_topointer (lua_State *L, int index);
Convierte el valor situado en el ndice aceptable en un puntero genrico de C (void*). El valor puede ser un userdata, una
tabla, un proceso o una funcin; en caso contrario lua_topointer retorna NULL. Lua se asegura de que diferentes objetos
retornen diferentes punteros. No hay una manera directa de convertir un puntero de nuevo a su valor original.
Tpicamente esta funcin slo es usada para informacin de depuracin.
luaFtostring
[-0, +0, m]
const char *lua_tostring (lua_State *L, int index);
Equivalente a lua_tolstring con len igual a NULL.
luaFtot0read
[-0, +0, -]
lua_State *lua_tothread (lua_State *L, int index);
Convierte el valor en la posicin del ndice aceptable en un proceso de Lua (representado como lua_State*). Este valor
debe ser un proceso; en caso contrario la funcin retorna NULL.
luaFtouserdata
[-0, +0, -]
void *lua_touserdata (lua_State *L, int index);
Si el valor en la posicin del ndice aceptable es un userdata completo retorna la direccin de su bloque de memoria. Si el
valor es un userdata ligero retorna su puntero. En otro caso retorna NULL.
luaFt!"e
[-0, +0, -]
int lua_type (lua_State *L, int index);
Retorna el tipo del valor situado en el ndice aceptable o LUA_TNONE si la direccin es invlida (esto es, un ndice a una
posicin "vaca" en la pila). Los tipos retornados por lua_type estn codificados por las siguientes constantes, definidas en
lua.h: LUA_TNL, LUA_TNUMBER, LUA_TBOOLEAN, LUA_TSTRNG, LUA_TTABLE, LUA_TFUNCTON,
LUA_TUSERDATA, LUA_TTHREAD y LUA_TLGHTUSERDATA.
luaFt!"ena2e
[-0, +0, -]
const char *lua_typename (lua_State *L, int tp);
Retorna el nombre del tipo codificado por el valor tp, el cual debe ser uno de los valores retornados lua_type.
luaFHriter
typedef int (*lua_Writer) (lua_State *L,
const void* p,
size_t sz,
void* ud);
La funcin escritora usada por lua_dump. Cada vez que produce otro fragmento de chunk, lua_dump llama al escritor,
pasndole el buffer para ser escrito (p), su tamao (sz) y el argumento data proporcionado a lua_dump.
El escritor retorna un cdigo de error: 0 significa no errores y cualquier otro valor significa un error y evita que lua_dump
llame de nuevo al escritor.
luaFx2ove
[-?, +?, -]
void lua_xmove (lua_State *from, lua_State *to, int n);
ntercambia valores entre diferentes procesos del mismo estado global.
Esta funcin elimina n valores de la pila indicada por from y los coloca en la pila indicada por to.
luaF!ield
[-?, +?, -]
int lua_yield (lua_State *L, int nresults);
Produce la cesin de una co-rutina.
Esta funcin debera ser llamada solamente como expresin de retorno de una funcin C, como sigue:
return lua_yield (L, nresults);
Cuando una funcin C llama a lua_yield de esta manera, la co-rutina que est ejecutndose suspende su ejecucin, y la
llamada a lua_resume que comenz esta co-rutina retorna. El argumento nresults es el nmero de valores de la pila que
son pasados como resultados a lua_resume.
#.; - El interface de de"uracin
Lua no tiene utilidades de depuracin internas. En su lugar ofrece una interface especial por medio de funciones y hooks.
Esta interface permite la construccin de diferentes tipos de depuradores, analizadores de cdigo y otras herramientas que
necesitan "informacin interna" del intrprete.
luaF4e$ug
typedef struct lua_Debug {
int event;
const char *name; /* (n) */
const char *namewhat; /* (n) */
const char *what; /* (S) */
const char *source; /* (S) */
int currentline; /* (l) */
int nups; /* (u) number of upvalues */
int linedefined; /* (S) */
int lastlinedefined; /* (S) */
char short_src[LUA_DSZE]; /* (S) */
/* private part */
other fields
} lua_Debug;
Una estructura usada para contener diferentes fragmentos de informacin acerca de la funcin activa. lua_getstack rellena
slo la parte privada de esta estructura, para su uso posterior. Para rellenar otros campos de lua_debug con informacin
til, llmese a lua_getinfo.
Los campos de lua_debug tienen el siguiente significado:
source< Si la funcin fue definida en un string entonces source es ese string. Si la funcin fue definida en un
fichero entonces source comienza con un carcter '@' seguido del nombre del fichero.
s0ortFsrc< una versin "imprimible" de source, que ser usada en los mensajes de error.
linedefined< el nmero de lnea donde comienza la definicin de la funcin.
lastlinedefined< el nmero de lnea donde acaba la definicin de funcin.
/0at< el string "Lua" si la funcin es una funcin Lua, "C" si la funcin es una funcin C, "main" si es la parte
principal de un chunk, y "tail" si es una funcin que realiza una llamada de cola. Es el ltimo caso Lua no tiene ms
informacin acerca de la funcin.
currentline< la lnea actual donde la funcin dada se est ejecutando. Cuando esta informacin no est disponible,
currentline toma el valor -'.
na2e< un nombre razonable para la funcin dada. Debido a que las funciones en Lua son valores de primera
clase, no tienen un nombre fijo: algunas funciones pueden ser el valor de variables globales, mientras que otras
pueden ser almacenadas slo en un campo de una tabla. La funcin lua_getinfo analiza cmo fue invocada la
funcin para encontrarle un nombre adecuado. Si no puede encontrarlo entonces nombre se hace NULL.
na2e/0at< explica el campo nombre. El valor de namewhat puede ser "global", "local", "method", "field", "upvalue"
o "" (un string vaco), de acuerdo a cmo fue invocada la funcin. (Lua usa un string vaco cuando otras opciones
no son idneas.)
nu"s< el numero de upvalues de la funcin.
luaFget0oo,
[-0, +0, -]
lua_Hook lua_gethook (lua_State *L);
Retorna la funcin hook actual.
luaFget0oo,count
[-0, +0, -]
int lua_gethookcount (lua_State *L);
Retorna el contador de hook actual.
luaFget0oo,2as,
[-0, +0, -]
int lua_gethookmask (lua_State *L);
Retorna la mscara del hook actual.
luaFgetinfo
[-(0|1), +(0|1|2), m]
int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar);
Devuelve informacin acerca de una funcin especfica o de una invocacin de funcin.
Para obtener informacin acerca de una invocacin de funcin, el parmetro ar debe ser un registro de activacin vlido,
que haya sido llenado con una llamada previa a lua_getstack o dada como argumento a un hook (vase lua_Hook).
Para obtener informacin de una funcin se coloca la misma en la parte superior de la pila y se comienza el string what con
el carcter '>'. (En ese caso, lua_getinfo elimina la funcin de la parte superior de la pila.) Por ejemplo, para conocer en qu
lnea fue definida una funcin f se puede utilizar el siguiente cdigo:
lua_Debug ar;
lua_getfield(L, LUA_GLOBALSNDEX, "f"); /* obtiene la 'f' global */
lua_getinfo(L, ">S", &ar);
printf("%d\n", ar.linedefined);
Cada carcter en el string what selecciona los campos de la estructura ar que sern rellenados o un valor que ser
colocado en la parte superior de la pila:
InI< rellena los campos name y namewhat;
I(I< rellena los campos source, short_src, linedefined, lastlinedefined y what;
IlI< rellena el campo currentline;
IuI< rellena el campo nups;
IfI< coloca en la pila la funcin que est ejecutndose al nivel dado;
ILI< coloca en la pila una tabla cuyos ndices son los nmeros de las lneas que son vlidas en la funcin. (Una
l,nea vlida es una lnea con algn cdigo asociado, esto es, una lnea donde se puede poner un punto de rotura.
Las lneas no vlidas incluyen lneas vacas y comentarios.
Esta funcin devuelve 0 en caso de error (por ejemplo, una opcin invlida en what).
luaFgetlocal
[-0, +(0|1), -]
const char *lua_getlocal (lua_State *L, lua_Debug *ar, int n);
Obtiene informacin acerca de una variable local de un registro de activacin dado. El argumento ar debe ser un registro de
activacin vlido que fue rellenado en una llamada previa a lua_getstack o dado como argumento a un hook (vase
lua_Hook). El ndice n selecciona qu variable local inspeccionar (1 es el primer argumento o la primera variable local
activa, y as sucesivamente, hasta la ltima variable local activa). lua_getlocal coloca el valor de la variable en la pila y
retorna su nombre.
Los nombres de variable que comienzan con '(' (parntesis de abrir) representan variables internas (variables de control de
bucle, variables temporales y variables locales de funciones C).
Retorna NULL (y no coloca nada en la pila) cuando el ndice es mayor que el nmero de variables locales activas.
luaFgetstac,
[-0, +0, -]
int lua_getstack (lua_State *L, int level, lua_Debug *ar);
Obtiene informacin acerca de la pila en ejecucin del intrprete.
Esta funcin rellena partes de una estructura lua_debug con una identificacin del registro de activaci+n de la funcin que
se est ejecutando al nivel dado. Nivel 0 es la funcin actualmente en ejecucin, mientras que el nivel n/' es la funcin que
ha invocado a la del nivel n. Cuando no hay errores, lua_getstack retorna 1; cuando se llama con un nivel mayor que el
tamao de la pila retorna 0.
luaFgetu"value
[-0, +(0|1), -]
const char *lua_getupvalue (lua_State *L, int funcindex, int n);
Obtiene informacin acerca de un upavalue de una instancia. (Para las funciones Lua los upvalues son variables locales
externas a la funcin que las usa, y que, por consiguiente, estn incluidas en su instancia.) lua_getupvalue obtiene el ndice
n de un upvalue, coloca su valor en la pila y retorna su nombre. funcindex apunta hacia la instancia en la pila. (Los
upvalues no siguen un orden particular, puesto que estn activos a lo largo de toda la funcin. Por tanto, estn numerados
siguiendo un orden arbitrario.)
Retorna NULL (y no coloca nada en la pila) cuando el ndice es mayor que el nmero de upvalues. Para funciones C esta
funcin usa el string vaco "" como nombre para todos los upvalues.
luaFJoo,
typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);
Tipo para funciones hook de depuracin.
Cada vez que se invoca un hook su argumento ar tiene en su campo event el evento que ha activado el hook. Lua identifica
estos eventos con las siguientes constantes: LUA_HOOKCALL, LUA_HOOKRET, LUA_HOOKTALRET, LUA_HOOKLNE
y LUA_HOOKCOUNT. Adems, para eventos de lnea, tambin se establece el campo currentline. Para obtener el valor de
algn otro campo en ar, el hook debe invocar a lua_getinfo. Para eventos de retorno, event puede ser LUA_HOOKRET, el
valor normal, o LUA_HOOKTALRET. En el ltimo caso, Lua est simulando un retorno de una funcin que ha hecho una
llamada de cola; en este caso, es intil llamar a lua_getinfo.
Mientras Lua est ejecutando un hook, deshabilita otras llamadas a hooks. Por tanto, si un hook llama de nuevo a Lua para
ejecutar una funcin o un chunk entonces esa ejecucin ocurre sin ninguna llamada a hooks.
luaFset0oo,
[-0, +0, -]
int lua_sethook (lua_State *L, lua_Hook f, int mask, int count);
Establece la funcin hook de depuracin.
func es la funcin hook. mask especifica en qu eventos debe ser llamado el hook: se forma mediante la operacin "or"
aplicada a los bits de las constantes LUA_MASKCALL, LUA_MASKRET, LUA_MASKLNE, y LUA_MASKCOUNT. El
argumento count slo tiene sentido cuando la mscara incluye LUA_MASKCOUNT. Para cada evento, el hook es invocado
como se explica a continuacin:
El 0oo, ti"o >call> es invocado cuando el intrprete llama a una funcin. El hook es invocado justo despus de
que Lua entre en la nueva funcin, antes de que la funcin tome sus argumentos.
El 0oo, de ti"o >return> es invocado cuando el intrprete retorna desde una funcin. El hook es invocado justo
antes de que Lua deje la funcin. No se tiene acceso a los valores retornados por la funcin.
El 0oo, ti"o >line> es invocado cuando el intrprete va a comenzar la ejecucin de una nueva lnea de cdigo, o
cuando salta hacia atrs en el cdigo (incluso en la misma lnea). (Este evento slo ocurre cuando Lua est
ejecutando una funcin Lua.)
El 0oo, ti"o >count> es invocado despus de que el intrprete ejecute un nmero de instrucciones igual a count.
(Este evento slo ocurre cuando Lua est ejecutando una funcin Lua.)
Un hook se deshabilita estableciendo mask a cero.
luaFsetlocal
[-(0|1), +0, -]
const char *lua_setlocal (lua_State *L, lua_Debug *ar, int n);
Establece el valor de una variable local de un registro de activacin dado. Los argumentos ar y n son como los de
lua_getlocal. lua_setlocal asigna el valor en la parte superior de la pila a la variable y retorna su nombre. Tambin elimina
de la pila su valor.
Retorna NULL (y no hace nada con la pila) cuando el ndice es mayor que el nmero de variables locales activas.
luaFsetu"value
[-(0|1), +0, -]
const char *lua_setupvalue (lua_State *L, int funcindex, int n);
Establece el valor de un upvalue de una instancia. Los argumentos funcindex y n son como los de lua_getupvalue. Asigna
el valor que est en la parte superior de la pila al upvalue y retorna su nombre. Tambin elimina de la pila el valor.
Retorna NULL (y no hace nada con la pila) cuando el ndice es mayor que el nmero de upavalues.
' - La $i$lioteca auxiliar
La biblioteca au%iliar proporciona varias funciones convenientes para realizar la interface de C con Lua. Mientras que la AP
bsica proporciona las funciones primitivas para todas las interaciones entre C y Lua, la biblioteca auxiliar proporciona
funciones de alto nivel para algunas tareas comunes.
Todas las funciones de la biblioteca auxiliar estn definidas en el fichero de cabecera lauxlib.h y llevan el prefijo luaL_.
Todas ellas estn construidas encima de la AP bsica as que realmente no proporcionan nada nuevo que no pueda ser
realizado con la AP.
Algunas funciones en la biblioteca auxiliar son usadas para verificar argumentos de funciones C. Sus nombres son siempre
luaL_check* o luaL_opt*. Todas estas funciones activan un error si la verificacin no se satisface. Debido a que el mensaje
de error se formatea para los argumentos (por ejemplo, "bad argument #1"), no se deberan usar estas funciones para otros
valores de la pila.
'.1 - Eunciones ! ti"os
Aqu tenemos la lista de todas las funciones y tipos de la biblioteca auxiliar por orden alfabtico.
luaLFaddc0ar
[-0, +0, m]
void luaL_addchar (luaL_Buffer *B, char c);
Aade el carcter c al buffer B (vase luaL_Buffer).
luaLFaddlstring
[-0, +0, m]
void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l);
Aade el string al que apunta s con longitud l al buffer B (vase luaL_Buffer). El string puede contener ceros.
luaLFaddsi@e
[-0, +0, m]
void luaL_addsize (luaL_Buffer *B, size_t n);
Aade un string de longitud n previamente copiado en el rea del buffer (vase luaL_prepbuffer) al buffer B (vase
luaL_Buffer).
luaLFaddstring
[-0, +0, m]
void luaL_addstring (luaL_Buffer *B, const char *s);
Aade un string terminado en cero al que apunta s al buffer B (vase luaL_Buffer). El string no puede contener ceros.
luaLFaddvalue
[-1, +0, m]
void luaL_addvalue (luaL_Buffer *B);
Aade el valor situado en la parte superior de la pila al buffer B (vase luaL_Buffer), eliminndolo de la pila.
sta es la nica funcin asociada a los buffers de string que puede (y debe) ser invocada con un elemento extra en la pila,
que es el valor que debe ser aadido al buffer.
luaLFargc0ec,
[-0, +0, v]
void luaL_argcheck (lua_State *L,
int cond,
int narg,
const char *extramsg);
Verifica si cond es verdadero. Si no es as activa un error con el mensaje
"bad argument #<numarg> to <func> (<extramsg>)"
donde func es recuperado de la pila de llamada.
luaLFargerror
[-0, +0, v]
int luaL_argerror (lua_State *L, int narg, const char *extramsg);
Activa un error con el mensaje
"bad argument #<numarg> to <func> (<extramsg>)"
donde func es recuperado de la pila de llamada.
Esta funcin nunca retorna, pero es corriente usarla en funciones C en la forma return luaL_argerror(args).
luaLF*uffer
typedef struct luaL_Buffer luaL_Buffer;
Tipo para un buffer de string.
Un buffer de string permite al cdigo en C construir a trozos strings de Lua. Su metodologa de uso es como sigue:
Primero se declara una variable b de tipo luaL_Buffer.
Luego se inicializa la misma con una llamada a luaL_buffinit(L, &b).
Entonces se aaden las piezas del string al buffer, invocando alguna de las funciones luaL_add*.
Se finaliza llamando a luaL_pushresult(&b). Esta llamada deja el string final en la parte superior de la pila.
Durante su operacin normal, un buffer de strings usa un nmero variable de posiciones en la pila. As, mientras se est
usando el buffer, no se puede asumir que se conoce la posicin de la parte superior de la pila. Se puede usar la pila entre
llamadas sucesivas a las operaciones de buffer siempre que su uso est euilibrado; esto es, cuando se invoca una
operacin con el buffer, la pila est al mismo nivel en el que estaba inmediatamente antes de la operacin previa con el
buffer. (La nica excepcin a esta regla es luaL_addvalue.) Despus de llamar a luaL_pushresult la pila est de nuevo en el
mismo nivel que tena cuando el buffer fue inicializado, ms el string final en su parte superior.
luaLF$uffinit
[-0, +0, e]
void luaL_buffinit (lua_State *L, luaL_Buffer *B);
nicializa un buffer B. Esta funcin no reserva ningn espacio nuevo de memoria; el buffer debe ser declarado como
variable (vase luaL_Buffer).
luaLFcall2eta
[-0, +(0|1), e]
int luaL_callmeta (lua_State *L, int obj, const char *e);
nvoca un metamtodo.
Si el objeto con ndice obj tiene una metatabla y sta tiene un campo e, esta funcin llama a este campo y le pasa el objeto
como nico argumento. En este caso la funcin retorna 1 y coloca en la pila el valor devuelto por la llamada. Si no hay
metatabla o no hay metamtodo la funcin retorna 0 (sin colocar ningn valor en la pila).
luaLFc0ec,an!
[-0, +0, v]
void luaL_checkany (lua_State *L, int narg);
Verifica si la funcin tiene un argumento de algn tipo (incluyendo nil) en la posicin narg.
luaLFc0ec,int
[-0, +0, v]
int luaL_checkint (lua_State *L, int narg);
Verifica si el argumento narg de la funcin es un nmero y retorna este nmero como int (realizando un cast en C).
luaLFc0ec,integer
[-0, +0, v]
lua_nteger luaL_checkinteger (lua_State *L, int narg);
Verifica si el argumento narg de la funcin es un nmero y lo retorna como tipo lua_nteger.
luaLFc0ec,long
[-0, +0, v]
long luaL_checklong (lua_State *L, int narg);
Verifica si el argumento narg de la funcin es un nmero y lo retorna como long (realizando un cast en C).
luaLFc0ec,lstring
[-0, +0, v]
const char *luaL_checklstring (lua_State *L, int narg, size_t *l);
Verifica si el argumento narg de la funcin es un string y retorna el mismo; si l no es NULL coloca la longitud del string en *l.
Esta funcin usa lua_tolstring para obtener su resultado, por lo que todas las conversiones y precauciones asociados a esa
funcin se aplican aqu.
luaLFc0ec,nu2$er
[-0, +0, v]
lua_Number luaL_checknumber (lua_State *L, int narg);
Verifica si el argumento narg de la funcin es un nmero y retorna el mismo.
luaLFc0ec,o"tion
[-0, +0, v]
int luaL_checkoption (lua_State *L,
int narg,
const char *def,
const char *const lst[]);
Verifica si el argumento narg de la funcin es un string y busca ste en el array lst (que debe estar terminado con NULL).
Retorna el ndice en el array donde se encontr el string. Activa un error si el argumento no es un string o si no pudo ser
encontrado el string.
Si def no es NULL, se usa def como valor por defecto cuando la funcin no tiene un argumento narg o si este argumento es
nil.
sta es una funcin til para hacer corresponder strings con enumeraciones de C. La convencin normal en las bibliotecas
de Lua es usar strings en lugar de nmeros para seleccionar opciones.
luaLFc0ec,stac,
[-0, +0, v]
void luaL_checkstack (lua_State *L, int sz, const char *msg);
ncrementa el tamao de la pila a top + sz elementos, activando un error si la pila no puede crecer hasta ese tamao. msg
es un texto adicional que ira en el mensaje de error.
luaLFc0ec,string
[-0, +0, v]
const char *luaL_checkstring (lua_State *L, int narg);
Verifica si el argumento narg de la funcin es un string y retorna ste.
Esta funcin usa lua_tolstring para obtener su resultado, por lo que todas las conversiones y precauciones asociados a esa
funcin se aplican aqu.
luaLFc0ec,t!"e
[-0, +0, v]
void luaL_checktype (lua_State *L, int narg, int t);
Verifica si el argumento narg de la funcin tiene tipo t.
luaLFc0ec,udata
[-0, +0, v]
void *luaL_checkudata (lua_State *L, int narg, const char *tname);
Verifica si el argumento narg de la funcin es un userdata del tipo tname (vase luaL_newmetatable).
luaLFdofile
[-0, +?, m]
int luaL_dofile (lua_State *L, const char *filename);
Carga y ejecuta el fichero dado. Est definida en una macro:
(luaL_loadfile(L, filename) || lua_pcall(L, 0, LUA_MULTRET, 0))
Devuelve 0 si no hay errores 1 en caso de error.
luaLFdostring
[-0, +?, m]
int luaL_dostring (lua_State *L, const char *str);
Carga y ejecuta el string dado. Est definida en una macro:
(luaL_loadstring(L, str) || lua_pcall(L, 0, LUA_MULTRET, 0))
Devuelve 0 si no hay errores 1 en caso de error.
luaLFerror
[-0, +0, v]
int luaL_error (lua_State *L, const char *fmt, ...);
Activa un error. El formato del mensaje est dado por fmt ms cualesquiera argumentos extra, siguiendo las mismas reglas
de lua_pushfstring. Tambin aade al principio del mensaje el nombre del fichero y el nmero de lnea donde ocurri el
error, si esta informacin est disponible.
Esta funcin nunca retorna, pero es corriente usarla en la forma return luaL_error(args) en funciones C.
luaLFget2etafield
[-0, +(0|1), m]
int luaL_getmetafield (lua_State *L, int obj, const char *e);
Coloca en la parte superior de la pila el campo e de la metatabla del objeto situado en la posicin del ndice obj. Si el objeto
no tiene metatabla o si el objeto no tiene este campo retorna 0 y deja la pila intacta.
luaLFget2etata$le
[-0, +1, -]
void luaL_getmetatable (lua_State *L, const char *tname);
Coloca en la parte superior de la pila la metatabla asociada con el nombre tname en el registro (vase luaL_newmetatable).
luaLFgsu$
[-0, +1, m]
const char *luaL_gsub (lua_State *L,
const char *s,
const char *p,
const char *r);
Crea una copia del string s reemplazando cualquier aparicin del string p por el string r. Coloca el string resultante en la
parte superior de la pila y devuelve su valor.
luaLFload$uffer
[-0, +1, m]
int luaL_loadbuffer (lua_State *L,
const char *buff,
size_t sz,
const char *name);
Carga un buffer como chunk de Lua. Esta funcin usa lua_load para cargar el chunk en el buffer apuntado por buff con
tamao sz.
Esta funcin retorna el mismo resultado que lua_load. name es el nombre del chunk, usado para informacin de depuracin
y en los mensajes de error.
luaLFloadfile
[-0, +1, m]
int luaL_loadfile (lua_State *L, const char *filename);
Carga un fichero como chunk de Lua. Esta funcin usa lua_load para cargar el chunk que est en el fichero filename. Si
filename es NULL entonces se carga desde la entrada estndar. La primera lnea en el fichero se ignora si comienza por #.
Esta funcin retorna el mismo resultado que lua_load, pero tiene un cdigo extra de error LUA_ERRFLE si no puede leer o
abrir el fichero.
Como lua_load esta funcin slo carga el chunk y no lo ejecuta.
luaLFloadstring
[-0, +1, m]
int luaL_loadstring (lua_State *L, const char *s);
Carga un string como chunk de Lua. Esta funcin usa lua_load para cargar el chunk que est en el string s terminado en un
carcter cero.
Esta funcin retorna el mismo resultado que lua_load.
Como lua_load esta funcin slo carga el chunk y no lo ejecuta.
luaLFne/2etata$le
[-0, +1, m]
int luaL_newmetatable (lua_State *L, const char *tname);
Si el registro tiene ya una clave tname retorna 0. En caso contrario crea una nueva tabla que ser usada como metatabla
del userdata, aadiendo la clave tname al registro, y retornando 1.
En ambos caso coloca en la parte superior de la pila el valor final asociado con tname en el registro.
luaLFne/state
[-0, +0, -]
lua_State *luaL_newstate (void);
Crea un nuevo estado de Lua, invocando lua_newstate con una funcin de reserva de memoria basada en la funcin C
estndar realloc y estableciendo una funcin de "pnico" (vase lua_atpanic) que imprime un mensaje en la salida estndar
de error en caso de error fatal.
Retorna el nuevo estado o NULL si surgi un error de reserva de memoria.
luaLFo"enli$s
[-0, +0, m]
void luaL_openlibs (lua_State *L);
Abre todas las bibliotecas estndar de Lua en el estado dado.
luaLFo"tint
[-0, +0, v]
int luaL_optint (lua_State *L, int narg, int d);
Si el argumento narg de la funcin es un nmero retorna ste como un int. Si este argumento est ausente o es nil retorna
d. En otro caso activa un error.
luaLFo"tinteger
[-0, +0, v]
lua_nteger luaL_optinteger (lua_State *L,
int narg,
lua_nteger d);
Si el argumento narg de la funcin es un nmero retorna el mismo como lua_nteger. Si este argumento est ausente o es
nil retorna d. En caso contrario activa un error.
luaLFo"tlong
[-0, +0, v]
long luaL_optlong (lua_State *L, int narg, long d);
Si el argumento narg de la funcin es un nmero retorna el mismo como long. Si este argumento est ausente o es nil
retorna d. En caso contrario activa un error.
luaLFo"tlstring
[-0, +0, v]
const char *luaL_optlstring (lua_State *L,
int narg,
const char *d,
size_t *l);
Si el argumento narg de la funcin es un string retorna ste. Si este argumento est ausente o es nil retorna d. En caso
contrario activa un error.
Si l no es NULL coloca la longitud del resultado en *l.
luaLFo"tnu2$er
[-0, +0, v]
lua_Number luaL_optnumber (lua_State *L, int narg, lua_Number d);
Si el argumento narg de la funcin es un nmero retorna el mismo. Si este argumento est ausente o es nil retorna d. En
caso contrario activa un error.
luaLFo"tstring
[-0, +0, v]
const char *luaL_optstring (lua_State *L,
int narg,
const char *d);
Si el argumento narg de la funcin es un string retorna ste. Si este argumento est ausente o es nil retorna d. En caso
contrario activa un error.
luaLF"re"$uffer
[-0, +0, -]
char *luaL_prepbuffer (luaL_Buffer *B);
Retorna una direccin que apunta a un espacio de tamao LUAL_BUFFERSZE donde se puede copiar un string para ser
aadido al buffer B (vase luaL_Buffer). Despus de copiar el string en este espacio se debe invocar luaL_addsize con el
tamao del string para aadirlo realmente en el buffer.
luaLF"us0result
[-?, +1, m]
void luaL_pushresult (luaL_Buffer *B);
Finaliza el uso del buffer B dejando el string en la parte superior de la pila.
luaLFref
[-1, +0, m]
int luaL_ref (lua_State *L, int t);
Crea y retorna una referencia en la tabla en la posicin del ndice t para el objeto en la parte superior de la pila (y elimina el
mismo de la pila).
Una referencia es una clave entera nica. Mientras que no se aadan manualmente claves enteras a la tabla t, luaL_ref
asegura la unicidad de la clave que retorna. Se puede recuperar un objeto apuntado por la referencia r invocando
lua_rawgeti(L, t, r). La funcin luaL_unref elimina una referencia y su objeto asociado.
Si el objeto en la parte superior de la pila es nil, luaL_ref retorna la constante LUA_REFNL. Est garantizado que la
constante LUA_NOREF es diferente de cualquier referencia retornada por luaL_ref.
luaLFReg
typedef struct luaL_Reg {
const char *name;
lua_CFunction func;
} luaL_Reg;
Tipo para arrays de funciones para ser registradas por luaL_register. name es el nombre de la funcin y func es un puntero
a la misma. Cualquier array de luaL_Reg debe finalizar con una entrada "centinela" en la que tanto name como func son
NULL.
luaLFregister
[-(0|1), +1, m]
void luaL_register (lua_State *L,
const char *libname,
const luaL_Reg *l);
Abre una biblioteca.
Cuando se llama con libname igual a NULL simplemente registra todas las funciones de la lista l (vase luaL_Reg) en la
tabla que est en la parte superior de la pila.
Cuando se llama con un valor libname no nulo crea una nueva tabla t, establece la misma como valor de la variable global
libname, establece la misma como valor de package.loaded[libname] y registra en ella todas las funciones de la lista l. Si
existe una tabla en package.loaded[libname] o en la variable libname reutiliza esta tabla en lugar de crear una nueva.
En cualquier caso la funcin deja la tabla en la parte superior de la pila.
luaLFt!"ena2e
[-0, +0, -]
const char *luaL_typename (lua_State *L, int index);
Retorna el nombre del tipo del valor situado en el ndice dado.
luaLFt!"error
[-0, +0, v]
int luaL_typerror (lua_State *L, int narg, const char *tname);
Genera un error con un mensaje de la forma:
location: bad argument narg to function (tname expected, got rt)
donde location est producida por luaL_where, function es el nombre de la funcin actual y rt es el nombre del tipo del
argumento actual.
luaLFunref
[-0, +0, -]
void luaL_unref (lua_State *L, int t, int ref);
Libera la referencia ref de la tabla en el ndice t (vase luaL_ref). La entrada es eliminada de la tabla, por lo que la memoria
reservada para el objeto referido en la misma puede ser liberada. La referencia ref tambin es liberada para poder ser
reutilizada.
Si ref es LUA_NOREF o LUA_REFNL, luaL_unref no hace nada.
luaLF/0ere
[-0, +1, m]
void luaL_where (lua_State *L, int lvl);
Coloca en la parte superior de la pila un string identificando la posicin actual del control en el nivel lvl en la pila de llamada.
Tpicamente este string tiene el formato:
chunkname:currentline:
Nivel 0 es la funcin actualmente ejecutndose, nivel 1 es la funcin que llam a la funcin actual, etc.
Esta funcin se usa para construir un prefijo para los mensajes de error.
5 - *i$liotecas estKndar
Las bibliotecas estndar de Lua proporcionan funciones tiles que estn implementadas directamente a travs de la AP de
C. Algunas de estas funciones proveen servicios esenciales al lenguaje (por ejemplo, type y getmetatable); otras
proporcionan acceso a servicios "externos" (por ejemplo, /O); y otras podran ser implementadas en Lua mismo pero son
muy tiles o tienen requerimientos crticos de tiempo de ejecucin y merecen una implementacin en C (por ejemplo, sort).
Todas las bibliotecas estn implementadas a travs de la AP oficial de C y se proporcionan como mdulos separados en
C. En estos momentos Lua tiene las siguientes bibliotecas estndar:
biblioteca bsica;
biblioteca de empaquetado;
manejo de strings;
manejo de tablas;
funciones matemticas (sin, log, etc.);
entrada y salida (/O);
interaccin con el sistema operativo;
utilidades de depuracin.
Excepto para las bibliotecas bsica y de empaquetado, cada biblioteca proporciona todas sus funciones como campos de
tablas globales o como mtodos de sus objetos.
Para tener acceso a estas bibliotecas el programa anfitrin en C debe invocar a luaL_openlibs, la cual abre todas las
bibliotecas estndar. De manera alternativa se pueden abrir individualmente invocando a luaopen_base (la biblioteca
bsica), luaopen_package (la biblioteca de empaquetado), luaopen_string (la biblioteca de strings), luaopen_table (la
biblioteca de tablas), luaopen_math (la biblioteca matemtica), luaopen_io (la biblioteca de entrada/salida), luaopen_os (la
biblioteca del Sistema Operativo) y luaopen_debug (la biblioteca de depuracin). Estas funciones estn declaradas en
lualib.h y no deberan ser invocadas directamente: se deben llamar como a otra funcin C cualquiera de Lua, por ejemplo,
usando lua_call.
5.1 - Eunciones $Ksicas
La biblioteca bsica proporciona algunas funciones del ncleo de Lua. Si no se desea incluir esta biblioteca en una
aplicacin se debe analizar cuidadosamente si se necesitan proporcionar implementaciones de algunas de sus utilidades.
assert 5v %. 2ensaje&6
Activa un error cuando el valor de su argumento v es falso (por ejemplo, nil o false); en otro caso retorna todos sus
argumentos. mensaje es un mensaje de error; cuando est ausente se utiliza por defecto "assertion failed!".
collectgar$age 5o"t %. arg&6
Esta funcin es una interface genrica al liberador de memoria. Realiza diversas funciones de acuerdo a su primer
argumento, opt:
>sto">< detiene el liberador de memoria.
>restart>< reinicia el liberador de memoria.
>collect>< realiza un ciclo completo de liberacin de memoria.
>count>< devuelve la memoria total en uso por Lua (en Kbytes).
>ste">< realiza un paso de liberacin de memoria. El "tamao" del paso se controla por arg (valores grandes
significan ms pasos) de una manera no especificada. Si se desea controlar el tamao del paso se debe afinar
experimentalmente el valor de arg. Devuelve true si el paso acaba un ciclo de liberacin.
>ste""ause>< establece arg/100 como el nuevo valor para la pausa del liberador (vase 2.10).
>setste"2ul>< establece arg/100 como el nuevo valor para el multiplicador del paso del liberador (vase 2.10).
dofile 5no2$reFdeFfic0ero6
Abre el fichero con el nombre dado y ejecuta su contenido como un chunk de Lua. Cuando se invoca sin argumentos, dofile
ejecuta el contenido de la entrada estndar (stdin). Devuelve todos los valores retornados por el chunk. En caso de error,
dofile propaga el error a su invocador (esto es, dofile no se ejecuta en modo protegido).
error 52ensaje %. nivel&6
Termina la ltima funcin protegida llamada, estableciendo mensaje como mensaje de error. La funcin error nunca retorna.
Normalmente error aade, al comienzo del mensaje, cierta informacin acerca de la posicin del error. El argumento nivel
especifica cmo obtener la posicin del error. Con nivel 1 (por defecto) la posicin del error es donde fue invocada la
funcin error. Nivel 2 apunta el error hacia el lugar en que fue invocada la funcin que llam a error; y as sucesivamente.
Pasar un valor 0 como nivel evita la adicin de la informacin de la posicin al mensaje.
FL
Una variable global (no una funcin) que almacena el entorno global (o sea, _G._G = _G). Lua mismo no usa esta variable;
cambiar su valor no afecta ningn entorno, ni viceversa. (sese setfenv para cambiar entornos.)
getfenv 5%f&6
Retorna el entorno actualmente en uso por la funcin. f puede ser una funcin Lua o un nmero que especifica la funcin a
ese nivel de la pila: nivel 1 es la funcin que invoca a getfenv. Si la funcin dada no es una funcin Lua o si f es 0, getfenv
retorna el entorno global. El valor por defecto de f es 1.
get2etata$le 5o$jeto6
Si objeto no tiene una metatabla devuelve nil. En otro caso, si la metatabla del objeto tiene un campo "__metatable" retorna
el valor asociado, o si no es as retorna la metatabla del objeto dado.
i"airs 5t6
Retorna tres valores: una funcin iteradora, la tabla t, y 0, de tal modo que la construccin
for i,v in ipairs(t) do bloue end
iterar sobre los pares (1,t[1]), (2,t[2]), , hasta la primera clave entera con un valor nil en la tabla.
load 5func %. no2$reFdeFc0un,&6
Carga un chunk usando la funcin func para obtener sus partes. Cada llamada a func debe retornar un string que se
concatena con los resultados previos. Un retorno de nil (o no valor) seala el final del chunk.
Si no hay errores retorna el chunk compilado como una funcin; en otro caso retorna nil ms un mensaje de error. El
entorno de la funcin retornada es el global.
nombre_de_chunk se utiliza para identificar el chunk en los mensajes de error y para informacin de depuracin.
loadfile 5%no2$reFdeFfic0ero&6
Similar a load, pero obtiene el chunk del fichero nombre_de_fichero o de la entrada estndar si no se proporciona un
nombre.
loadstring 5string %. no2$reFdeFc0un,&6
Similar a load, pero obtiene el chunk del string proporcionado.
Para cargar y ejecutar un string dado sese
assert(loadstring(s))()
Cuando est ausente, nombre_de_chunk toma por defecto el string dado.
next 5ta$la %. Dndice&6
Permite al programa recorrer todos los campos de una tabla. Su primer argumento es una tabla y su segundo argumento es
un ndice en esta tabla. next retorna el siguiente ndice de la tabla y su valor asociado. Cuando se invoca con nil como
segundo argumento next retorna un ndice inicial y su valor asociado. Cuando se invoca con el ltimo ndice o con nil en
una tabla vaca next retorna nil. Si el segundo argumento est ausente entonces se interpreta como nil. En particular se
puede usar next(t) para comprobar si una tabla est vaca.
El orden en que se enumeran los ndices no est especificado, incluso para ,ndices num!ricos. (Para recorrer una tabla en
orden numrico sese el for numrico o la funcin ipairs.)
El comportamiento de next es indefinido si durante el recorrido se asigna un valor a un campo no existente previamente en
la tabla. No obstante se pueden modificar campos existentes. En particular se pueden borrar campos existentes.
"airs 5t6
Retorna tres valores: la funcin next, la tabla t, y nil, por lo que la construccin
for k,v in pairs(t) do bloue end
iterar sobre todas las parejas clave-valor de la tabla t.
Vase next para las precauciones a tomar cuando se modifica la tabla durante las iteraciones.
"call 5f. arg1. MMM6
nvoca la funcin f con los argumentos dados en modo protegido. Esto significa que ningn error dentro de f se propaga; en
su lugar pcall captura el error y retorna un cdigo de estatus. Su primer resultado es el cdigo de estatus (booleano), el cual
es verdadero si la llamada tiene xito sin errores. En ese caso pcall tambin devuelve todos los resultados de la llamada
despus del primer resultado. En caso de error pcall retorna false ms un mensaje de error.
"rint 5MMM6
Recibe cualquier nmero de argumentos e imprime sus valores en el fichero estndar de salida (stdout), usando tostring
como funcin para convertir los argumentos a strings. print no est diseada para salida formateada sino slo como una
manera rpida de mostrar valores, tpicamente para la depuracin del cdigo. Para salida formateada sese string.format.
ra/e+ual 5v1. v26
Verifica si v1 es igual a v2, sin invocar ningn metamtodo. Devuelve un booleano.
ra/get 5ta$la. Dndice6
Obtiene el valor real de tabla[ndice] sin invocar ningn metamtodo. tabla debe ser una tabla e ndice cualquier valor
diferente de nil.
ra/set 5ta$la. Dndice. valor6
Asigna valor a tabla[ndice] sin invocar ningn metamtodo. tabla debe ser una tabla, ndice cualquier valor diferente de nil
y valor un valor cualquiera de Lua.
select 5Dndice. MMM6
Si ndice es un nmero retorna todos los argumentos despus del nmero ndice. En otro caso ndice debe ser el string "#",
y select retorna el nmero total de argumentos extra que recibe.
setfenv 5f. ta$la6
Establece el entorno que va a ser usado por una funcin. f puede ser una funcin Lua o un nmero que especifica la
funcin al nivel de pila: nivel 1 es la funcin que invoca a setfenv. setfenv retorna la funcin dada.
Como caso especial, cuando f es 0 setfenv cambia el entorno del proceso que est en ejecucin. En este caso setfenv no
retorna valores.
set2etata$le 5ta$la. 2etata$la6
Establece la metatabla de una tabla dada. (No se puede cambiar la metatabla de otros tipos desde Lua, sino slo desde C.)
Si metatabla es nil entonces se elimina la metatabla de la tabla dada. Si la metatabla original tiene un campo "__metatable"
se activa un error.
Esta funcin retorna tabla.
tonu2$er 5e %. $ase&6
ntenta convertir su argumento en un nmero. Si el argumento es ya un nmero o un string convertible a un nmero
entonces tonumber retorna este nmero; en otro caso devuelve nil.
Un argumento opcional especifica la base para interpretar el nmero. La base puede ser cualquier entero entre 2 y 36,
ambos inclusive. En bases por encima de 10 la letra 'A' (en mayscula o minscula) representa 10, 'B' representa 11, y as
sucesivamente, con 'Z' representando 35. En base 10 (por defecto), el nmero puede tener parte decimal, as como un
exponente opcional (vase 2.1). En otras bases slo se aceptan enteros sin signo.
tostring 5e6
Recibe un argumento de cualquier tipo y lo convierte en un string con un formato razonable. Para un control completo de
cmo se convierten los nmeros, sese string.format.
Si la metatabla de e tiene un campo "__tostring" entonces tostring invoca al correspondiente valor con e como argumento y
usa el resultado de la llamada como su propio resultado.
t!"e 5v6
Retorna el tipo de su nico argumento, codificado como string. Los posibles resultados de esta funcin son "nil" (un string,
no el valor nil), "number", "string", "boolean, "table", "function", "thread" y "userdata".
un"ac, 5lista %. i %. j&&6
Retorna los elementos de una tabla dada. Esta funcin equivale a
return lista[i], lista[i+1], , lista[j]
excepto que este cdigo puede ser escrito slo para un nmero fijo de elementos. Por defecto i es 1 y j es la longitud de la
lista, como se define a travs del operador longitud (vase 2.5.5).
FER(I7G
Una variable global (no una funcin) que almacena un string que contiene la versin actual del intrprete. En esta versin
de Lua el contenido actual de esta variable es "Lua 5.1".
x"call 5f. err6
Esta funcin es similar a pcall, excepto que se puede establecer un manejador de error.
xpcall invoca a la funcin f en modo protegido, usando err como manejador de error. Ningn error dentro de f se propaga;
en su lugar xpcall captura el error, llamando a la funcin err con el objeto de error original, y retorna un cdigo de estatus.
Su primer resultado es el cdigo de estatus (un booleano), que es verdadero si la llamada tiene xito sin errores. En ese
caso xpcall tambin devuelve todos los resultados de la llamada despus del primer resultado. En caso de error xpcall
retorna false ms el resultado de err.
5.2 - Manejo de co-rutinas
Las operaciones relacionadas con co-rutinas comprenden una sub-biblioteca de la biblioteca bsica y se sita en la tabla
coroutine. Vase 2.11 para una descripcin general de las co-rutinas.
coroutine.create 5f6
Crea una nueva co-rutina con cuerpo f. f debe ser una funcin Lua. Retorna una nueva co-rutina, un objeto de tipo "thread".
coroutine.resu2e 5co %. val1. MMM&6
Comienza o contina la ejecucin de la co-rutina co. La primera vez que se llama a esta funcin la co-rutina comienza
ejecutando su cuerpo. Los valores val1, se pasan como argumentos al cuerpo de la funcin. Si la co-rutina ha cedido el
control del flujo, resume la reinicia; los valores val1, son pasados como resultados de la cesin.
Si la co-rutina se ejecuta sin error resume retorna true ms los valores pasados a yield (si la co-rutina realiza la cesin) o
los valores retornados por el cuerpo de la funcin (si la co-rutina acaba). Si existe cualquier error resume retorna false ms
un mensaje de error.
coroutine.running 56
Retorna la co-rutina en ejecucin o nil cuando se invoca desde el proceso principal.
coroutine.status 5co6
Retorna el estatus de la co-rutina co como un string: "running", si la co-rutina est en ejecucin (esto es, invoc a status);
"suspended", si la co-rutina est suspendida en una llamada a yield, o si todava no ha comenzado a ejecutarse; "normal" si
la co-rutina est activa pero no ejecutndose (esto es, si ha resumido otra co-rutina); y "dead" si la co-rutina ha finalizado su
funcin o si se ha detenido con un error.
coroutine./ra" 5f6
Crea una nueva co-rutina con cuerpo f. f debe ser una funcin Lua. Retorna una funcin que resume la co-rutina cada vez
que es invocada. Cualquier argumento pasado a la funcin se comporta como un argumento extra para resume. Retorna
los mismos valores devueltos por resume, excepto el primer booleano. En caso de error, ste se propaga.
coroutine.!ield 5MMM6
Suspende la ejecucin de la co-rutina invocante. La co-rutina no puede estar ejecutando una funcin C, un metamtodo o
un iterador. Cualquier argumento de yield es pasado como resultado extra a resume.
5.# - Mdulos
La biblioteca de empaquetado proporciona utilidades bsicas para cargar y construir mdulos en Lua. Exporta dos de sus
funciones directamente al entorno global: module y require. Las dems se exportan en la tabla package.
2odule 5no2$re %. MMM&6
Crea un mdulo. Si existe una tabla en package.loaded[nombre] sta es el mdulo. En otro caso si existe una tabla global t
con el nombre dado sta es el mdulo. Sino, finalmente, crea una nueva tabla t y le da el nombre global de nombre y el
valor de package.loaded[nombre]. Esta funcin tambin inicializa t._NAME con el nombre dado, t._M con el mdulo (t
mismo), y t._PACKAGE con el nombre del paquete (el mdulo nombre completo menos su ltimo componente; vase ms
abajo). Para acabar, module establece t como nuevo entorno de la funcin actual y el nuevo valor de
package.loaded[nombre], de tal manera que require retorna t.
Si nombre es un nombre compuesto (esto es, uno con componentes separados por puntos) module crea (o reutiliza, si ya
existen) tablas para cada componente. Por ejemplo, si nombre es a.b.c, entonces module almacena la tabla mdulo en el
campo c del campo b de la tabla global a.
Esta funcin puede recibir argumentos opcionales despus del nombre del mdulo, donde cada opcin es una funcin que
ser aplicada sobre el mdulo.
re+uire 5no2$re6
Carga el mdulo dado. La funcin comienza buscando en la tabla package.loaded para determinar si nombre est ya
cargado. Si es as entonces require devuelve el valor almacenado en package.loaded[nombre]. En otro caso intenta
encontrar un cargador para el mdulo.
Para encontrar un cargador, primero require se gua por package.preload[nombre]. Cambiando este array, se cambia la
manera que en require busca un mdulo. La siguiente explicacin est basada en la configuracin por defecto de
package.loaders.
Primero require mira en package.prelodad[modname]. Si tiene un valor, ste (que debe ser una funcin) es el cargador. En
otro caso require busca un cargador en Lua usando el camino de bsqueda guardado en package.path. Si tambin esto
falla, busca un cargador en C usando el camino almacenado en package.cpath. Si tambin finalmente esto falla intenta un
cargador todo en uno (vase package.loaders).
Una vez que se encontr el cargador, require lo invoca con un nico argumento, nombre. Si el cargador retorna un valor,
require lo asigna a package.loaded[nombre]. Si el cargador no retorna un valor y no est asignado un valor a
package.loaded[nombre], entonces require asigna true a esta entrada. En cualquier caso, require retorna el valor final de
package.loaded[nombre].
Si existen errores durante la carga o ejecucin del mdulo en proceso o si no se pudo encontrar un cargador para el
mdulo, entonces require activa un error.
"ac,age.c"at0
El camino de bsqueda usado por require para buscar un cargador en C.
Lua inicializa este camino package.cpath de la misma manera en que inicializa el camino de Lua package.path, usando la
variable de entorno LUA_CPATH (adems de otro camino por defecto definido en luaconf.h).
"ac,age.loaded
Una tabla usada por require para controlar qu mdulos estn ya cargados. Cuando se solicita un mdulo nombre y
package.loaded[nombre] no es falso, require simplemente retorna el valor almacenado.
"ac,age.loaders
Una tabla usada por require que controla cmo se cargan los mdulos
Cada entrada en esta tabla es una funci+n buscadora. Cuando busca un mdulo, require llama a cada uno de esas
buscadoras en orden ascendente, con el nombre del mdulo (el argumento pasado a require) com nico argumento. La
funcin puede retornar otra funcin (el mdulo cargador o un string que explica que no encontr ese mdulo (o nil si no
tuvo nada que decir). Lua inicializa esta tabla con cuatro funciones.
La primera buscadora simplemente busca un cargador en la tabla package.preload.
La segunda buscadora busca un cargador como biblioteca de Lua, usando el camino de bsqueda guardado en
package.path. Un camino es una secuencia de plantillas separadas por puntos y comas (;). En cada plantilla, el buscador
cambia cada signo de interrogacin que aparezca por nombre_de_fichero, que es el nombre del mdulo con cada punto
reemplazado por un "separador de directorios" (como "/" en Unix); entonces intentar abrir el fichero con el nombre
resultante. As, por ejemplo, si el el camino de Lua es el string:
"./?.lua;./?.lc;/usr/local/?/init.lua"
la bsqueda de un fichero fuente de Lua para el mdulo foo intentar abrir los ficheros ./foo.lua., ./foo.lc y
/usr/local/foo/init.lua, en ese orden
La tercera buscadora busca un cargador como biblioteca de C, usando el camino dado en la variable package.cpath. Por
ejemplo, si el camino de C es el string:
"./?.so;./?.dll;/usr/local/?/init.so"
la buscadora, para el mdulo foo intentar abrir los ficheros ./foo.so., ./foo.dll y /usr/local/foo/init.so, en ese orden. Una vez
que encuentre una biblioteca en C, el buscador usa la utilidad de enlace dinmico para enlazar la aplicacin con la
biblioteca. Entones intenta encontrar la funcin C dentro de la biblioteca para ser usada como cargador. El nombre de esta
funcin es el string "luaopen_" concatenado con una copia del nombre del mdulo donde cada punto es reemplazado por
un carcter de subrayado (_). Adems, si el nombre del mdulo tiene un guin, su prefijo hasta el primer guin incluido se
elimina. Por ejemplo, si el nombre del mdulo es a.v1-b.c el nombre de funcin ser luaopen_b_c.
La cuarta buscadora intenta un cargador todo-en-uno. Busca en el camino de C una biblioteca con el nombre raiz del
mdulo dado. Por ejemplo, cuando se pide a.b.c buscar a en una bibliteca C. S la encuentra busca dentro de ella una
funcin para abrir el submdulo; en nuestro ejemplo, sera luaopen_a_b_c. Con esta utilidad, un paquete puede guardar
varios submdulos C en una nica biblioteca, con cada submdulo manteniendo su funcin original de apertura.
"ac,age.loadli$ 5no2$reFdeF$i$lioteca. no2$reFdeFfunc6
Enlaza dinmicamente el programa anfitrin con la biblioteca en C nombre_de_biblio. Dentro de esta biblioteca busca una
funcin nombre_de_func y la retorna como una funcin C. (Por tanto, nombre_de_func debe seguir el protocolo; vase
lua_CFunction).
sta es una funcin de bajo nivel. Se salta completamente el sistema de paquetes y de mdulos. A diferencia de require, no
realiza ninguna bsqueda en el camino y no aade automticamente extensiones. nombre_de_biblio debe ser un nombre
completo de fichero de la biblioteca en C, incluyendo si es necesario el camino completo y la extensin. nombre_de_func
debe ser el nombre exacto exportado por la biblioteca en C (el cual puede depender del compilador de C y del cargador del
sistema operativo usados).
Esta funcin no est soportada por el C ANS. Por tanto slo est disponible en algunas plataformas (Windows, Linux, Mac
OS X, Solaris, BSD, adems de otros sistemas Unix que soportan el estndar dlfcn).
"ac,age."at0
El camino de bsqueda usado por require para buscar un cargador de Lua.
Al comienzo Lua inicializa esta variable con el valor de la variable de entorno LUA_PATH o con un camino por defecto
definido en luaconf.h, si la variable de entorno no est definida. Si aparece ";;" en el valor de la variable de entorno se
reemplaza por el camino por defecto.
"ac,age."reload
Una tabla que almacena cargadores para mdulos especficos (vase require).
"ac,age.seeall 52dulo6
Establece una metatabla para mdulo con su campo __index refirindose al entorno global, de tal manera que este mdulo
hereda los valores del entorno global. Se usa como una opcin para la funcin module.
5.' - Manejo de strings
Esta biblioteca proporciona funciones genricas de manejo de strings, tales como encontrar y extraer substrings y detectar
patrones. Cuando se indexa un string en Lua el primer carcter est en la posicin 1 (no en 0 como en C). Se permite el
uso de ndices negativos que se interpretan como indexado hacia atrs, desde el final del string. Por tanto el ltimo carcter
del string est en la posicin -1, y as sucesivamente.
La biblioteca de strings proporciona todas sus funciones en la tabla string. Tambin establece una metatabla para string
donde el campo __index apunta a la misma metatabla. Por tanto, se pueden usar las funciones de manejo de string en un
estilo orientado a objetos. Por ejemplo, string.byte(s, i) puede ponerse s:byte(i).
string.$!te 5s %. i %. j&&6
Devuelve los cdigos numricos internos de los caracteres s[i], s[i+1], , s[j]. El valor por defecto de i es 1; el valor por
defecto de j es i.
Tngase en cuenta que los cdigos numricos no son necesariamente portables de unas plataformas a otras.
string.c0ar 5MMM6
Recibe cero o ms enteros. Devuelve un string con igual longitud que el nmero de argumentos, en el que cada carcter
tiene un cdigo numrico interno igual a su correspondiente argumento.
Tngase en cuenta que los cdigos numricos no son necesariamente portables de unas plataformas a otras.
string.du2" 5function6
Devuelve un string que contiene la representacin binaria de la funcin dada, de tal manera que una llamada posterior a
loadstring con este string devuelve una copia de la funcin. func debe ser una funcin Lua sin upvalues.
string.find 5s. "atrn %. inicio %. $Ksica&&6
Busca la primera aparicin de patrn en el string s. Si la encuentra, find devuelve los ndices de s donde comienza y acaba
la aparacin; en caso contrario retorna nil. Un tercer argumento numrico opcional inicio especifica dnde comenzar la
bsqueda; su valor por defecto es 1 y puede ser negativo. Un valor true como cuarto argumento opcional bsica desactiva
las utilidades de deteccin de patrones, realizando entonces la funcin una operacin de "bsqueda bsica de substring",
sin caracteres "mgicos" en el patrn. Tngase en cuenta que si se proporciona el argumento bsica tambin debe
proporcionarse el argumento inicio.
Si el patrn tiene capturas entonces en una deteccin con xito se devuelven los valores capturados, despus de los dos
ndices.
string.for2at 5for2ato. MMM6
Devuelve una versin formateada de sus argumentos (en nmero variable) siguiendo la descripcin dada en su primer
argumento (formato, que debe ser un string). El string de formato sigue las mismas reglas que la familia de funciones C
estndar printf. Las nicas diferencias son que las opciones/modificadores *, l, L, n, p, y h no estn soportadas, y que existe
una opcin extra q. Esta ltima opcin da formato a un string en una forma adecuada para ser leda de manera segura de
nuevo por el intrprete de Lua: el string es escrito entre dobles comillas, y todas las dobles comillas, nuevas lneas, ceros y
barras inversas del string se sustituyen por las secuencias de escape adecuadas en la escritura. Por ejemplo, la llamada
string.format('%q', 'un string con "comillas" y \n nueva lnea')
producir el string:
"un string con \"comillas\" y \
nueva lnea"
Las opciones c, d, E, e, f, g, G, i, o, u, X y x esperan un nmero como argumento, mientras que q y s esperan un string.
Esta funcin no acepta valores de string que contengan caracteres cero, excepto como argumentos de la opcin q.
string.g2atc0 5s. "atrn6
Devuelve una funcin iteradora que, cada vez que se invoca, retorna las siguientes capturas del patrn en el string s.
Si el patrn no produce capturas entonces la coincidencia completa se devuelve en cada llamada.
Como ejemplo, el siguiente bucle
s = "hola mundo desde Lua"
for w in string.gmatch(s, "%a+") do
print(w)
end
iterar sobre todas las palabras del string s, imprimiendo una por lnea. El siguiente ejemplo devuelve en forma de tabla
todos los pares clave=valor del string dado:
t = {}
s = "desde=mundo, a=Lua"
for k, v in string.gmatch(s, "(%w+)=(%w+)") do
t[k] = v
end
Para esta funcin, un '^' al principio de un patrn no funciona como un ancla, sino que previene la iteracin.
string.gsu$ 5s. "atrn. ree2"la@a2iento %. n&6
Devuelve una copia de s en la que todas (o las n primeras, si se especifica el argumento opcional) las apariciones del
patrn han sido reemplazadas por el reemplazamiento especificado, que puede ser un string, una tabla o una funcin. gsub
tambin devuelve, como segundo valor, el nmero total de coincidencias detectadas.
Si reemplazamiento es un string entonces su valor se usa en la sustitucin. El carcter % funciona como un carcter de
escape: cualquier secuencia en reemplazamiento de la forma %n, con n entre 1 y 9, significa el valor de la captura nmero
n en el substring (vase ms abajo). La secuencia %0 significa toda la coincidencia. La secuencia %% significa un carcter
porcentaje %.
Si reemplazamiento es una tabla entonces en cada captura se devuelve el elemento de la tabla que tiene por clave la
primera captura; si el patrn no proporciona ninguna captura entonce toda la coincidencia se utiliza como clave.
Si reemplazamiento es una funcin entonces la misma es invocada cada vez que exista una captura con todos los
substrings capturados pasados como argumentos en el mismo orden; si no existen capturas entonces toda la coincidencia
se pasa como un nico argumento.
Si el valor devuelto por la tabla o por la llamada a la funcin es un string o un nmero, entonces se usa como string de
reemplazamiento; en caso contrario si es false o nil, entonces no se realiza ninguna sustitucin (esto es, la coincidencia
original se mantiene en el string).
He aqu algunos 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 desde"
x = string.gsub("casa = $HOME, usuario = $USER", "%$(%w+)", os.getenv)
--> x="casa = /home/roberto, usuario = roberto"
x = string.gsub("4+5 = $return 4+5$", "%$(.-)%$", function (s)
return loadstring(s)()
end)
--> x="4+5 = 9"
local t = {nombre="lua", versin="5.1"}
x = string.gsub("$nombre-$versin.tar.gz", "%$(%w+)", t)
--> x="lua-5.1.tar.gz"
string.len 5s6
Recibe un string y devuelve su longitud. El string vaco "" tiene longitud 0. Los caracteres cero dentro del string tambin se
cuentan, por lo que "a\000bc\000" tiene longitud 5.
string.lo/er 5s6
Recibe un string y devuelve una copia del mismo con todas las letras maysculas cambiadas a minsculas. El resto de los
caracteres permanece sin cambios. La definicin de letra mayscula depende del sistema local.
string.2atc0 5s. "atrn %. inicio&6
Busca la primera aparici+n del patrn en el string s. Si encuentra una, entonces match retorna la captura del patrn; en
caso contrario devuelve nil. Si el patrn no produce ninguna captura entonces se devuelve la coincidencia completa. Un
tercer y opcional argumento numrico inicio especifica dnde comenzar la bsqueda; su valor por defecto es 1 y puede ser
negativo.
string.re" 5s. n6
Devuelve un string que es la concatenacin de n copias del string s.
string.reverse 5s6
Devuelve un string que es el original s invertido.
string.su$ 5s. i %. j&6
Retorna el substring de s que comienza en i y contina hasta j; i y j pueden ser negativos. Si j est ausente entonces se
asume que vale -' (equivalente a la longitud del string). En particular, la llamada string.sub(s,1,j) retorna un prefijo de s con
longitud j, y string.sub(s, -i) retorna un sufijo de s con longitud i.
string.u""er 5s6
Recibe un string y devuelve una copia del mismo con todas las letras minsculas cambiadas a maysculas. El resto de los
caracteres permanece sin cambios. La definicin de letra minscula depende del sistema local.
5.'.1 - 8atrones
Clases de caracteres<
Se usan clases de caracteres para representar conjuntos de caracteres. Estn permitidas las siguientes combinaciones
para describir una clase de caracteres:
x< (donde % no es uno de los caracteres mgicos ^$()%.[]*+-?) representa el propio caracter %.
.< (un punto) representa cualquier carcter.
Na< representa cualquier letra.
Nc< representa cualquier carcter de control.
Nd< representa cualquier dgito.
Nl< representa cualquier letra minscula.
N"< representa cualquier carcter de puntuacin.
Ns< representa cualquier carcter de espacio.
Nu< representa cualquier letra mayscula.
N/< representa cualquier carcter alfanumrico.
Nx< representa cualquier dgito hexadecimal.
N@< representa el carcter con valor interno 0 (cero).
Nx< (donde % es cualquier carcter no alfanumrico) representa el carcter %. sta es la manera estndar de
"escapar" los caracteres mgicos. Cualquier caracter de puntuacin (incluso los no mgicos) pueden ser
precedidos por un signo de porcentaje '%' cuando se quieran representarse a s mismos en el patrn.
%conjunto&< representa la clase que es la unin de todos los caracteres en el con"unto. Un rango de caracteres
puede ser especificado separando el carcter del principio y del final mediante un guin '-'. Todas las clases del
tipo %% descritas ms arriba pueden ser tambin utilizadas como componentes del con"unto. Todos los otros
caracteres en el con"unto se representan a s mismos. Por ejemplo, [%w_] (o [_%w]) representa cualquier carcter
alfanumrico o el subrayado, [0-7] representa un dgito octal, y [0-7%l%-] representa un dgito octal, una letra
minscula o el carcter '-'.
La interaccin entre los rangos y las clases no est definida. Por tanto, patrones como [%a-z] o [a-%%] carecen de
significado.
%Oconjunto&< representa el complemento de con"unto, donde con"unto se interpreta como se ha indicado ms
arriba.
Para todas las clases representadas por letras simples (%a, %c, etc.) las correspondientes letras maysculas representan
la clase complementaria. Por ejemplo, %S representa cualquier carcter no espacio.
Las definiciones de letra, espacio y otros grupos de caracteres dependen del sistema local. En particular, la clase [a-z]
puede no ser equivalente a %l.
Ele2entos de un "atrn
Cada elemento de un patr+n puede ser
una clase de carcter simple, que equivale a cualquier carcter simple de la clase;
una clase de carcter simple seguida por '*', que equivale a 0 ms repeticiones de los caracteres de la clase.
Estos elementos de repeticin siempre equivaldrn a la secuencia de caracteres ms larga posible;
un clase de carcter simple seguida por '+', que equivale a 1 ms repeticiones de los caracteres de la clase.
Estos elementos de repeticin siempre equivaldrn a la secuencia de caracteres ms larga posible;
un clase de carcter simple seguida por '-', que tambin equivale a 0 ms repeticiones de los caracteres de la
clase. Al contrario que '*', Estos elementos de repeticin siempre equivaldrn a la secuencia de caracteres ms
corta posible;
una clase de carcter simple seguida por '?', que equivale a 0 1 apariciones de un carcter de la clase;
%n, para n entre 1 y 9; este elemento equivale a un substring igual a la captura nmero n;
%b%y, donde % e y son dos caracteres diferentes; este elemento equivale a strings que comienzan con %, finalizan
con y, estando euilibrados % e y. Esto significa que, iniciando un contador a 0, si se lee el string de izquierda a
derecha, sumando /' por cada % que aparezca y -' por cada y, el y final es el primero donde el contador alcanza
0. Por ejemplo, el elemento %b() equivale a una expresin con parntesis emparejados.
8atrn
Un patr+n es una secuencia de elementos de patrn. Un '^' al comienzo de un patrn ancla la bsqueda del patrn al
comienzo del string en el que se produce la bsqueda. Un '$' al final de un patrn ancla la bsqueda del patrn al final del
string en el que se produce la bsqueda. En otras posiciones '^' y '$' no poseen un significado especial y se representan a s
mismos.
Ca"turas
Un patrn puede contener subpatrones encerrados entre parntesis que describen capturas. Cuando sucede una
coincidencia entre un patrn y un string dado, los substrings que concuerdan con lo indicado entre parntesis en el patrn,
son almacenados (capturados) para uso futuro. Las capturas son numeradas de acuerdo a sus parntesis izquierdos. Por
ejemplo, en el patrn "(a*(.)%w(%s*))", la parte del string que concuerda con "a*(.)%w(%s*)" se guarda en la primera
captura (y por tanto tiene nmero 1); el carcter que concuerda con "." se captura con el nmero 2, y la parte que
concuerda con "%s*" tiene el nmero 3.
Como caso especial, la captura vaca () retorna la posicin actual en el string (un nmero). Por ejemplo, si se aplica el
patrn "()aa()" al string "flaaap", dar dos capturas: 3 y 5.
Un patrn no puede contener caracteres cero. sese %z en su lugar.
5.5 - Manejo de ta$las
Esta biblioteca proporciona funciones genricas para manejo de tablas. Todas estas funciones estn definidas dentro de la
tabla table.
La mayora de las funciones en la biblioteca de tablas asume que las mismas representan arrays o listas (o sea, estn
indexadas numricamente). Para estas funciones, cuando hablamos de la "longitud" de una tabla queremos decir el
resultado del operador longitud (#).
ta$le.concat 5ta$la %. se"arador %. i %. j&&&6
Dado una table donde todos sus elementos son strings o nmeros devuelve tabla[i]..separador..tabla[i+1]
separador..tabla[j]. El valor por defecto de separador es el string vaco, el valor por defecto de i es 1 y el valor por defecto
de j es la longitud de la tabla. Si i es mayor que j, la funcin devuelve un string vaco.
ta$le.insert 5ta$la. %"osicin.& valor6
nserta el elemento valor en la posicin dada en la tabla, desplazando hacia adelante otros elementos para abrir hueco, si
es necesario. El valor por defecto de posicin es n+1, donde n = #tabla es la longitud de la tabla (vase 2.5.5), de tal
manera que table.insert(t,x) inserta x al final de la tabla t.
ta$le.2axn 5ta$la6
Devuelve el mayor ndice numrico positivo de una tabla dada o cero si la tabla no tiene ndices numricos positivos. (Para
hacer su trabajo esta funcin realiza un barrido lineal de la tabla completa.)
ta$le.re2ove 5ta$la %. "osicin&6
Elimina de tabla el elemento situado en la posicin dada, desplazando hacia atrs otros elementos para cerrar espacio, si
es necesario. Devuelve el valor del elemento eliminado. El valor por defecto de posicin es n, donde n es la longitud de la
tabla, por lo que la llamada table.remove(t) elimina el ltimo elemento de la tabla t.
ta$le.sort 5ta$la %. co2"arador&6
Ordena los elementos de la tabla en un orden dado modificando la propia tabla, desde table[1] hasta table[n], donde n es la
longitud de la tabla. Si se proporciona el argumento comparador ste debe ser una funcin que recibe dos elementos de la
tabla y devuelve verdadero cuando el primero es menor que el segundo (por lo que not comparador(a[i+1],a[i]) ser
verdadero despus de la ordenacin). Si no se proporciona una funcin comparador entonces se usa el operador estndar
< de Lua.
El algoritmo de ordenacin no es estable; esto es, los elementos considerados iguales por la ordenacin dada pueden sufrir
cambios de orden relativos despus de la ordenacin.
5.1 - Eunciones 2ate2Kticas
Esta biblioteca es una interface a la biblioteca matemtica estndar de C. Proporciona todas sus funciones dentro de la
tabla math.
2at0.a$s 5x6
Devuelve el valor absoluto de x.
2at0.acos 5x6
Devuelve el arco coseno de x (en radianes).
2at0.asin 5x6
Devuelve el arco seno de x (en radianes).
2at0.atan 5x6
Devuelve el arco tangente de x (en radianes).
2at0.atan2 5!. x6
Devuelve el arco tangente de y/x (en radianes), pero usa los signos de ambos argumentos para determinar el cuadrante del
resultado. (Tambin maneja correctamente el caso en que x es cero.)
2at0.ceil 5x6
Devuelve el menor entero mayor o igual que x.
2at0.cos 5x6
Devuelve el coseno de x (se asume que est en radianes).
2at0.cos0 5x6
Devuelve el coseno hiperblico de x.
2at0.deg 5x6
Devuelve en grados sexagesimales el valor de x (dado en radianes).
2at0.ex" 5x6
Devuelve el valor de e
%
.
2at0.floor 5x6
Devuelve el mayor entero menor o igual que x.
2at0.f2od 5x. !6
Devuelve el resto de la divisin de x por y.
2at0.frex" 5x6
Devuelve m y e tales que % 0 m (
e
, e es un entero y el valor absoluto de m est en el intervalo 12345 ') (o cero cuando x es
cero).
2at0.0uge
El valor HUGE_VAL, un valor ms grande o igual que otro valor numrico cualquiera.
2at0.ldex" 52. e6
Devuelve m (
e
(e debe ser un entero).
2at0.log 5x6
Devuelve el logaritmo natural de x.
2at0.log1? 5x6
Devuelve el logaritmo decimal (base 10) de x.
2at0.2ax 5x. MMM6
Devuelve el mayor valor de entre sus argumentos.
2at0.2in 5x. MMM6
Devuelve el menor valor de entre sus argumentos.
2at0.2odf 5x6
Devuelve dos nmeros, las partes entera y fraccional de x .
2at0."i
El valor de pi.
2at0."o/ 5x. !6
Devuelve %
y
. (Se puede tambin usar la expresin x^y para calcular este valor.)
2at0.rad 5x6
Devuelve en radianes el valor del ngulo x (dado en grados sexagesimales).
2at0.rando2 5%2 %. n&&6
Esta funcin es un interface a rand, generador simple de nmeros pseudo-aleatorios proporcionado por el ANS C. (Sin
garantas de sus propiedades estadsticas.)
Cuando se invoca sin argumentos devuelve un nmero pseudoaleatorio real uniforme en el rango [0,1). Cuando se invoca
con un nmero entero m, math.random devuelve un nmero pseudoaleatorio entero uniforme en el rango [1, m]. Cuando se
invoca con dos argumentos m y n enteros, math.random devuelve un nmero pseudoaleatorio entero uniforme en el rango
[m, n].
2at0.rando2seed 5x6
Establece x como "semilla" para el generador de nmeros pseudoaleatorios: iguales semillas producen iguales secuencias
de nmeros.
2at0.sin 5x6
Devuelve el seno de x (se asume que est en radianes).
2at0.sin0 5x6
Devuelve el seno hiperblico de x.
2at0.s+rt 5x6
Devuelve la raiz cuadrada de x. (Se puede usar tambin la expresin x^0.5 para calcular este valor.)
2at0.tan 5x6
Devuelve la tangente de x (se asume que est en radianes).
2at0.tan0 5x6
Devuelve la tangente hiperblica de x.
5.3 - Ptilidades de entradaQsalida
La biblioteca de entrada/salida (/O de sus siglas en ingls) proporciona dos estilos diferentes de manejo de ficheros. El
primero de ellos usa descriptores de fichero implcitos; esto es, existen dos ficheros por defecto, uno de entrada y otro de
salida, y las operaciones se realizan sobre stos. El segundo estilo usa descriptores de fichero explcitos.
Cuando se usan descriptores implcitos todas las operaciones soportadas estn en la tabla io. Cuando se usan descriptores
explcitos, la operacin io.open devuelve un descriptor de fichero y todas las operaciones se proporcionan como mtodos
asociados al descriptor.
La tabla io tambin proporciona tres descriptores de fichero predefinidos con sus significados usuales en C: io.stdin,
io.stdout e io.stderr. La biblioteca de entrada/salida nunca cierra esos ficheros.
A no ser que se especifique, todas las funciones de entrada/salida devuelven nil en caso de fallo (ms un mensaje de error
como segundo resultado y un cdigo de error dependiente del sistema como un tercer resultado) y valores diferentes de nil
si hay xito.
io.close 5%descri"torFdeFfic0ero&6
Equivalente a descriptor_de_fichero:close(). Sin argumento cierra el fichero de salida por defecto.
io.flus0 56
Equivalente a descriptor_de_fichero:flush aplicado al fichero de salida por defecto.
io.in"ut 5%descri"torFdeFfic0ero R no2$reFdeFfic0ero&6
Cuando se invoca con un nombre de fichero entonces lo abre (en modo texto), y establece su manejador de fichero como
fichero de entrada por defecto. Cuando se llama con un descriptor de fichero simplemente lo establece como manejador
para el fichero de entrada por defecto. Cuando se invoca sin argumento devuelve el fichero por defecto actual.
En caso de errores esta funcin activa error en lugar de devolver un cdigo de error.
io.lines 5%no2$reFdeFfic0ero&6
Abre el fichero de nombre dado en modo lectura y devuelve una funcin iteradora que, cada vez que es invocada, devuelve
una nueva lnea del fichero. Por tanto, la construccin
for linea in io.lines(nombre_de_fichero) do bloue end
iterar sobre todas las lneas del fichero. Cuando la funcin iteradora detecta el final del fichero devuelve nil (para acabar el
bucle) y cierra automticamente el fichero.
La llamada a io.lines() (sin nombre de fichero) equivale a io.input():lines(); esto es, itera sobre todas las lneas del fichero
por defecto de entrada. En ese caso no cierra el fichero cuando acaba el bucle.
io.o"en 5no2$reFdeFfic0ero %. 2odo&6
Esta funcin abre un fichero, en el modo especificado en el string mode. Devuelve un descriptor de fichero o, en caso de
error, nil adems de un mensaje de error.
El string que indica modo puede ser uno de los siguientes:
>r>< modo lectura (por defecto);
>/>< modo escritura;
>a>< modo adicin;
>rS>< modo actualizacin, todos los datos preexistentes se mantienen;
>/S>< modo actualizacin, todos los datos preexistentes se borran;
>aS>< modo adicin con actualizacin, todos los datos preexistentes se mantienen, y la escritura se permite slo al
final del fichero.
El string que indica el modo puede contener tambin 'b' al final, lo que es necesario en algunos sistemas para abrir el
fichero en modo binario. Este string es exactamente el que se usa en la funcin estndar de C fopen.
io.out"ut 5%descri"torFdeFfic0ero R no2$reFdeFfic0ero&6
Similar a io.input, pero operando sobre el fichero por defecto de salida.
io."o"en 5"rog %. 2odo&6
Comienza a ejecutar el programa prog en un proceso separado y retorna un descriptor de fichero que se puede usar para
leer datos que escribe prog (si modo es "r", el valor por defecto) o para escribir datos que lee prog (si modo es "w").
Esta funcin depende del sistema operativo y no est disponible en todas las plataformas.
io.read 5MMM6
Equivalente a io.input():read.
io.t2"file 56
Devuelve un descriptor de fichero para un fichero temporal. ste se abre en modo actualizacin y se elimina
automticamente cuando acaba el programa.
io.t!"e 5o$jeto6
Verifica si objeto es un descriptor vlido de fichero. Devuelve el string "file" si objeto es un descriptor de fichero abierto,
"closed file" si objeto es un descriptor de fichero cerrado, o nil si objeto no es un descriptor de fichero.
io./rite 5MMM6
Equivalente a io.output():write.
descri"torFdeFfic0ero<close 56
Cierra el descriptor de fichero descriptor_de_fichero. Tngase en cuenta que los ficheros son cerrados automticamente
cuando sus descriptores se eliminan en un ciclo de liberacin de memoria, pero que esto toma un tiempo impredecible de
ejecucin.
descri"torFdeFfic0ero<flus0 56
Salva cualquier dato escrito en descriptor_de_fichero.
descri"torFdeFfic0ero<lines 56
Devuelve una funcin iteradora que, cada vez que es invocada, devuelve una nueva lnea leda del fichero. Por tanto, la
construccin
for linea in descriptor_de_fichero:lines() do bloue end
iterar sobre todas las lneas del fichero. (A diferencia de io.lines, esta funcin no cierra el fichero cuando acaba el bucle.)
file<read 5MMM6
Lee en el fichero dado por el descriptor_de_fichero, de acuerdo el formato proporcionado, el cual especifica qu leer. Para
cada formato, la funcin devuelve un string (o un nmero) con los caracteres ledos, o nil si no pudo leer los datos con el
formato especificado. Cuando se invoca sin formato se usa uno por defecto que lee la prxima lnea completa (vase ms
abajo).
Los formatos disponibles son
>Tn>< lee un nmero; ste es el nico formato que devuelve un nmero en lugar de un string.
>Ta>< lee el resto del fichero completo, empezando en la posicin actual. Al final del fichero devuelve un string
vaco.
>Tl>< lee la prxima lnea (saltndose el final de lnea), retornando nil al final del fichero. ste es el formato por
defecto.
un nmero< lee un string con como mximo este nmero de caracteres, devolviendo nil si se llega al final del
fichero. Si el nmero es cero no lee nada y devuelve un string vaco, o nil si se alcanza el final del fichero.
file<see, 5%deFdnde& %. des"la@a2iento&6
Establece (o solicita) la posicin actual (del puntero de lectura/escritura) en el descriptor_de_fichero, medida desde el
principio del fichero, en la posicin dada por desplazamiento ms la base especificada por el string dnde, como se
especifica a continuacin:
>set>< sita la posicin base en 0 (comienzo del fichero);
>cur>< sita la posicin base en la actual;
>end>< sita la posicin base al final del fichero.
En caso de xito la funcin seek retorna la posicin final (del puntero de lectura/escritura) en el fichero medida en bytes
desde el principio del fichero. Si la llamada falla retorna nil, ms un string describiendo el error.
El valor por defecto de dnde es "cur", y para desplazamiento es 0. Por tanto, la llamada descriptor_de_fichero:seek()
devuelve la posicin actual, sin cambiarla; la llamada descriptor_de_fichero:seek("set") establece la posicin al principio del
fichero (y devuelve 0); y la llamada descriptor_de_fichero:seek("end") establece la posicin al final del fichero y devuelve su
tamao.
file<setv$uf 52odo %. ta2aCo&6
Establece un modo buffer para un fichero de salida. El argumento modo puede ser uno de estos tres:
>no>< sin buffer; el resultado de cualquier operacin de salida se produce inmediatamente.
>full>< con buffer completo; la operacin de salida se realiza slo cuando el buffer est lleno o cuando se invoca
explcitamente la funcin flush en el descriptor del fichero.
>line>< con buffer de lnea; la salida se demora hasta que se produce una nueva lnea en la salida o existe una
entrada de algn fichero especial (como una terminal).
Para los dos ltimos casos, tamao especifica el tamao del buffer, en bytes. El valor por defecto es un tamao adecuado.
file</rite 5MMM6
Escribe el valor de sus argumentos en el fichero dado por su descriptor_de_fichero. Los argumentos pueden ser strings o
nmeros. Para escribir otros valores sese tostring o string.format antes que write.
5.; - Ptilidades del siste2a o"erativo
Esta biblioteca est implementada a travs de la tabla os.
os.cloc, 56
Devuelve una aproximacin al total de segundos de CPU usados por el programa.
os.date 5%for2ato %. tie2"o&&6
Devuelve un string o una tabla conteniendo la fecha y hora, formateada de acuerdo con el string dado en formato.
Si el argumento tiempo est presente entonces ese tiempo concreto es el que se formatea (vase la funcin os.time para
una descripcin de este valor). En caso contrario, date formatea el tiempo actual.
Si formato comienza con '!' entonces el tiempo se formatea de acuerdo al Tiempo Universal Coordinado. Despus de este
carcter opcional, si formato es *t entonces date devuelve una tabla con los siguientes campos: year (cuatro dgitos), month
(1--12), day (1--31), hour (0--23), min (0--59), sec (0--61), wday (da de la semana, el domingo es 1), yday (da dentro del
ao), e isdst (booleano, verdadero si es horario de verano).
Si formato no es *t entonces date devuelve el tiempo como un string, formateado de acuerdo con las mismas reglas que la
funcin strftime de C.
Cuando se invoca sin argumentos date devuelve una representacin razonable de la fecha y la hora que depende de la
mquina y del sistema local (esto es, os.date() equivale a os.date("%c")).
os.diffti2e 5t2. t16
Devuelve el nmero de segundos desde el instante t1 hasta el t2. En POSX, Windows y algunos otros sistemas este valor
es exactamente t2-t1.
os.execute 5%co2ando&6
Esta funcin equivale a la funcin system de C. Pasa la orden comando para que sea ejecutada en el intrprete de
comandos del sistema operativo. Devuelve un cdigo de estatus, que es dependiente del sistema. Si el argumento
comando est ausente devuelve un valor no cero si est disponible un intrprete de comandos y cero si no est disponible.
os.exit 5%cdigo&6
nvoca la funcin exit de C, con un cdigo entero opcional, para terminar el programa anfitrin. El valor por defecto de
cdigo es el valor correspondiente a xito.
os.getenv 5varia$le6
Devuelve el valor asignado a la variable de entorno variable, o nil si la variable no est definida.
os.re2ove 5no2$reFdeFfic0ero6
Elimina el fichero o directorio dado. Los directorios deben estar vacos para poder ser eliminados. Si la funcin falla retorna
nil, ms un string describiendo el error.
os.rena2e 5no2$reFviejo. no2$reFnuevo6
Renombra un fichero o directorio de nombre_viejo a nombre_nuevo. Si la funcin falla retorna nil, ms un string
describiendo el error.
os.setlocale 5local %. categorDa&6
Establece valores en el sistema local del programa. local es un string que especifica un valor local; categora es un string
opcional que describe qu categora cambiar: "all", "collate", "ctype", "monetary", "numeric", or "time"; la categora por
defecto es "all". Esta funcin retorna el nombre del nuevo local o nil si la peticin no pudo ser aceptada.
Si local es el string vaco, el local actual se establece como el local nativo (que depende de la implementacin). Si local es
el string "C", el local actual se establece en el local estndar de C.
Cuando se invoca con nil como primer argumento, esta funcin retorna slo el nombre del local actual en la categora dada.
os.ti2e 5%ta$la&6
Devuelve el tiempo actual cuando se llama sin argumentos, o un tiempo representando la fecha y hora especificadas en la
tabla dada. sta debe tener los campos year, month y day, y puede tener los campos hour, min, sec e isdst (para una
descripcin de esos campos, vase la funcin os.date).
El valor retornado es un nmero, cuyo significado depende del sistema. En POSX, Windows y algunos otros sistemas este
nmero cuenta el nmero de segundos desde alguna fecha inicial dada (la "poca"). En otros sistemas el significado no
est especificado, y el nmero retornado por time puede ser usado slo como argumento de las funciones date y difftime.
os.t2"na2e 56
Devuelve un string con un nombre de fichero que puede ser usado como fichero temporal. El fichero debe ser abierto
explcitamente antes de su uso y tambin eliminado explcitamente cuando no se necesite ms.
5.= - La $i$lioteca de de"uracin
Esta biblioteca proporciona a los programas en Lua las funcionalidades de la interface de depuracin. Se debe usar con
cuidado. Las funciones proporcionadas aqu deben ser usadas exclusivamente para depuracin y labores similares, tales
como el anlisis de cdigo. Por favor, resstase la tentacin de usar la biblioteca como una herramienta de programacin:
puede llegar a ser muy lenta. Adems, alguna de sus funciones viola alguna de las asunciones acerca del cdigo en Lua
(por ejemplo, que las variables locales de una funcin no pueden ser accedidas desde fuera de la funcin o que los
userdata no pueden ser cambiados desde el cdigo Lua) y por tanto pueden comprometer cdigo de otra manera seguro.
Todas las funciones de esta biblioteca se proporcionan en la tabla debug.
de$ug.de$ug 56
Entra en modo interactivo con el usuario, ejecutando cada string que introduce el usuario. Usando comandos simples y
otras utilidades de depuracin el usuario puede inspeccionar variables globales y locales, cambiar sus valores, evaluar
expresiones, etc. Una lnea que contiene slo la palabra cont finaliza esta funcin, por lo que el programa invocante
contina su ejecucin.
Tngase presente que los comandos para degub.debug no estn lxicamente anidados dentro de ninguna funcin, y no
tienen acceso directo a las variables locales.
de$ug.getfenv 5o6
Devuelve el entorno del objeto o.
de$ug.get0oo, 5%"roceso&6
Devuelve informacin sobre el hook actual del proceso, en forma de tres valores: la funcin del hook actual, la mscara del
hook actual y el contador del hook actual (como fue establecida por la funcin debug.sethook).
de$ug.getinfo 5%"roceso.& func %. +u&6
Devuelve una tabla con informacin acerca de la funcin func. Se puede dar la funcin directamente, o se puede dar un
nmero en el lugar de func, lo que significa la funcin al nivel de ejecucin de la llamada de pila: nivel 0 es el de la funcin
actual (getinfo misma); nivel 1 es la funcin que llam a getinfo; y as sucesivamente. Si func es un nmero mayor que el
total de funciones activas entonces getinfo retorna nil.
La tabla devuelta contiene todos los campos retornados por lua_getinfo, con el string qu describiendo los campos a
rellenar. Por defecto, si no se proporciona qu, se obtiene toda la informacin disponible. Si est presente, la opcin 'f'
aade un campo denominado func con la funcin misma. Si est presente, la opcin 'L' aade un campo denominado
activelines con la tabla de lneas vlidas.
Por ejemplo, la expresin debug.getinfo(1,"n").nombre retorna una tabla con un nombre para la funcin actual, si pudo
encontrar un nombre razonable, y debug.getinfo(print) retorna una tabla con toda la informacin disponible sobre la funcin
print.
de$ug.getlocal 5%"roceso.& nivel. local6
Esta funcin devuelve el nombre y el valor de una variable local con ndice local de la funcin al nivel dado de la pila. (El
primer argumento o variable local tiene ndice 1, y as sucesivamente, hasta la ltima variable local activa.) La funcin
retorna nil si no existe una variable local con el ndice dado, y activa un error cuando se invoca con nivel fuera de rango.
(Se puede llamar a debug.getinfo para verificar si el nivel es vlido.)
Los nombres de variable que comienzan con '(' (parntesis de abrir) representan variables internas (de control de bucles,
temporales y locales de funciones C).
de$ug.get2etata$le 5o$jeto6
Devuelve la metatabla del objeto dado o nil si ste no tiene metatabla.
de$ug.getregistr! 56
Retorna la tabla de registro (vase 3.5).
de$ug.getu"value 5func. u"6
Esta funcin retorna el nombre y el valor del upvalue con ndice up de la funcin func. La funcin retorna nil si no hay un
upvalue con el ndice dado.
de$ug.setfenv 5o$jeto. ta$la6
Establece la tabla de entorno de un objeto dado.
de$ug.set0oo, 5%"roceso.& funcF0oo,. 2Kscara %. contador&6
Establece la funcin func_hook como hook. El string dado en mscara y el nmero contador describen como se invoca al
hook. La mscara puede tener los siguientes caracteres, con el significado indicado:
>c>< El hook se invoca cada vez que Lua llama a una funcin;
>r>< El hook se invoca cada vez que Lua retorna de una funcin;
>l>< El hook se invoca cada vez que Lua entra en una nueva lnea de cdigo.
Con un contador diferente de cero el hook se invoca cada ese nmero de instrucciones.
Cuando se invoca sin argumentos debug.sethook desactiva el hook.
Cuando se invoca el hook su primer argumento es un string describiendo el evento que ha activado su invocacin: "call",
"return" (o "tail return"), "line" y "count". Para los eventos de lnea, el hook tambin devuelve el nmero de lnea como
segundo valor. Dentro de un hook se puede invocar a getinfo con nivel 2 para obtener ms informacin acerca de la funcin
en ejecucin (nivel 0 es la funcin getinfo y nivel 1 es la funcin hook), a no ser que el evento sea "tail return". En ese caso
Lua slo simula el retorno, y una llamada a getinfo devolver datos invlidos.
de$ug.setlocal 5%"roceso.& nivel. local. valor6
Esta funcin asigna el valor a la variable local con ndice local de la funcin al nivel dado en la pila, retornando el nombre de
la variable local. La funcin retorna nil si no existe una variable local con el ndice dado, y activa un error cuando se llama
con un nivel fuera de rango. (Se puede invocar getinfo para verificar si el nivel es vlido.)
de$ug.set2etata$le 5o$jeto. ta$la6
Establece tabla (que puede ser nil) como la metatabla del objeto dado.
de$ug.setu"value 5func. u". valor6
Esta funcin asigna el valor al upvalue con ndice up de la funcin func, retornando el nombre del upvalue. La funcin
retorna nil si no existe el upvalue con el ndice dado.
de$ug.trace$ac, 5%"roceso.& %2ensaje& %. nivel&6
Devuelve un string con el "trazado inverso" de la llamada en la pila. Un mensaje opcional se aade al principio del "trazado
inverso". Un nmero de nivel opcional indica en qu nivel se comienza el "trazado inverso" (por defecto es 1, la funcin que
est invocando a traceback).
1 - Lua co2o lenguaje inde"endiente
Aunque Lua ha sido diseado como un lenguaje de extensin, para ser embebido en programas en C, tambin es
frecuentemente usado como lenguaje independiente. Con la distribucin estndar se proporciona un intrprete
independiente denominado simplemente lua. ste incluye todas las bibliotecas estndar, incluyendo la de depuracin. Se
usa as:
lua [opciones] [fichero_de_script [argumentos]]
Las opciones son:
-e sentencia< ejecuta el string sentencia;
-l mdulo< carga m+dulo con la funcin require;
-i< entra en modo interactivo despus de ejecutar el fichero*de*script;
-v< imprime informacin de la versin;
--< deja de procesar opciones en el resto de la lnea;
-< toma stdin como fichero para ejecutar y no procesa ms opciones.
Despus de gestionar las opciones proporcionadas, lua ejecuta el fichero*de*script dado, pasndole los argumentos dados
como strings. Cuando se invoca sin argumentos lua se comporta como lua -v -i cuando la entrada estndar (stdin) es una
terminal, y como lua - en otro caso.
Antes de ejecutar cualquier argumento el intrprete comprueba si existe una variable de entorno LUA_NT. Si su formato
es @nombre*de*fichero entonces lua ejecuta este fichero. En otro caso lua ejecuta el propio string.
Todas las opciones se procesan en orden, excepto -i. Por ejemplo, una invocacin como
$ lua -e'b=1' -e 'print(b)' script.lua
primero establecer el valor de b a 1, luego imprimir el valor de b (que es '1'), y finalmente ejectuar el fichero script.lua sin
argumentos. (Aqu $ es el prompt del intrprete de comandos del sistema operativo. El de cada sistema concreto puede ser
diferente.)
Antes de comenzar a ejecutar fichero*de*script lua recolecta todos los argumentos de la lnea de comandos en una tabla
global denominada arg. El nombre del fichero*de*script se guarda en el ndice 0, el primer argumento depus del nombre
del programa se guarda en el ndice 1, y as sucesivamente. Cualesquiera argumentos antes del nombre del programa
(esto es, el nombre del intrprete ms las opciones) van a los ndices negativos. Por ejemplo, en la invocacin
$ lua -la b.lua t1 t2
el intrprete primero ejecuta el fichero b.lua, luego crea la tabla
arg = { [-2] = "lua", [-1] = "-la",
[0] = "b.lua",
[1] = "t1", [2] = "t2" }
y finalmente ejecuta el fichero b.lua. ste se invoca con arg[1], arg[2], como argumentos; tambin se accede a estos
argumentos con la expresin vararg '...'.
En modo interactivo si se escribe una sentencia incompleta el intrprete espera para que sea completada, indicndolo con
otro prompt diferente.
Si la variable global _PROMPT contiene un string entonces su valor se usa como prompt. De manera similar, si la variable
global _PROMPT2 contiene un string su valor se usa como prompt secundario (el que se utiliza durante las sentencias
incompletas). Por tanto, ambos prompts pueden ser cambiados directamente en la lnea de comandos o en cualquier
programa en Lua asignando un valor a _PROMPT. Vase el siguiente ejemplo:
$ lua -e"_PROMPT='myprompt> '" -i
(la pareja externa de comillas es para el intrprete de comandos del sistema operativo; la interna para Lua). Ntese el uso
de -i para entrar en modo interactivo; en otro caso el programa acabara silenciosamente justo despus de la asignacin a
_PROMPT.
Para permitir el uso de Lua como un intrprete de scripts en los sistemas Unix, el intrprete independiente de Lua se salta
la primera lnea de un chunk si sta comienza con #. Por tanto, los programas de Lua pueden convertirse en ejecutables
usando chmod +x y la forma #!, como en
#!/usr/local/bin/lua
(Por supuesto, la localizacin del intrprete de Lua puede ser diferente en cada mquina. Si lua est en el camino de
bsqueda de ejecutables, PATH, entonces
#!/usr/bin/env lua
es una solucin ms portable.)
3 - Inco2"ati$ilidades con la versin anterior
Aqu se listan las incompatibilidades que pueden aparecer cuando se porta un programa de Lua 5.0 a Lua 5.1. Se pueden
evitar la mayora de ellas compilando Lua con las opciones apropiadas (vase el fichero luaconf.h). Sin embargo todas esas
opciones de compatibilidad sern eliminadas en la siguiente versin de Lua.
3.1 - Ca2$ios en el lenguaje
El sistema de gestin de funciones con un nmero de argumentos variable cambi desde el pseudoargumento arg
con una tabla con argumentos extra a la expresin vararg. (Vase la opcin de compilacin
LUA_COMPAT_VARARG en luaconf.h.)
Existe un sutil cambio en el mbito de las variables implcitas de las sentencias for y re"eat.
La sintaxis [[...]] para string largo y para comentario largo no permite anidamientos. Se puede usar la nueva
sintaxis [=[...]=] en esos casos. (Vase la opcin de compilacin LUA_COMPAT_LSTR en luaconf.h.)
3.2 - Ca2$ios en las $i$liotecas
La funcin string.gfind ha sido renombrada a string.gmatch. (Vase la opcin de compilacin
LUA_COMPAT_GFND en luaconf.h.)
Cuando se invoca string.gsub con una funcin como su tercer argumento, siempre que esta funcin devuelva nil o
false el string de reemplazamiento es la coincidencia completa en lugar de un string vaco.
Se desaconseja el uso de la funcin table.setn. La funcin table.getn corresponde al nuevo operador de longitud
(#); sese el operador en lugar de la funcin. (Vase la opcin de compilacin LUA_COMPAT_GETN en
luaconf.h.)
La funcin loadlib ha sido renombrada a package.loadlib. (Vase la opcin de compilacin
LUA_COMPAT_LOADLB en luaconf.h.)
La funcin math.mod ha sido renombrada a math.fmod. (Vase la opcin de compilacin LUA_COMPAT_MOD en
luaconf.h.)
Se desaconseja el uso de las funciones table.foreach y table.foreachi. En su lugar se puede usar un bucle con
pairs o ipairs.
Hay cambios sustanciales en la funcin require debido al nuevo sistema de mdulos. No obstante, el nuevo
comportamiento es casi totalmente compatible con el viejo, aunque require obtiene el camino de bsqueda de
package.path en lugar de LUA_PATH.
La funcin collectgarbage tiene otros argumentos. Se desaconseja el uso de la funcin gcinfo; sese
collectgarbage("count") en su lugar.
3.# - Ca2$ios en la B8I
Las funciones luaopen_* (para abrir bibliotecas) no pueden ser invocadas directamente como funciones C
regulares. Deben ser llamadas a travs de Lua, como otra funcin Lua.
La funcin lua_open ha sido reemplazada por lua_newstate para permitir al usuario establecer una funcin de
asignacin de memoria. Se puede usar luaL_newstate de la biblioteca estndar para crear un estado con la
funcin estndar de asignacin de memoria (basada en realloc).
Las funciones luaL_getn y luaL_setn (de la biblioteca auxiliar) no deben usarse. sese lua_objlen en lugar de
luaL_getn y nada en lugar de luaL_setn.
La funcin luaL_openlib ha sido reemplazada por luaL_register.
La funcin luaL_checkudata ahora provoca un error cuando el valor dado no es un userdata del tipo esperado. (En
Lua 5.0 retornaba NULL.)
; - La sintaxis co2"leta de Lua
Aqu aparece la sintaxis completa de Lua en la notacin BNF extendida. No describe las prioridades de los operadores.
chunk ::= {sentencia [')']} [ltima_sentencia[')']]
bloque ::= chunk
sentencia ::= varlist '-' explist |
llamada_a_func |
do bloque end |
/0ile exp do bloque end |
re"eat bloque until exp |
if exp t0en bloque {elseif exp t0en bloque} [else bloque] end |
for nombre '-' exp '.' exp ['.' exp] do bloque end |
for lista_de_nombres in explist do bloque end |
function nombre_de_func cuerpo_de_func |
local function nombre cuerpo_de_func |
local lista_de_nombres ['-' explist]
ltima_sentencia ::= return [explist] | $rea,
nombre_de_func ::= nombre {'.' nombre} ['<' nombre]
varlist ::= var {'.' var}
var ::= nombre | prefixexp '%' exp '&' | prefixexp '.' nombre
lista_de_nombres ::= nombre {'.' nombre}
explist ::= {exp '.'} exp
exp ::= nil | false | true | nmero | string | '...' |
func | prefixexp | constructor_de_tabla |
exp operador_binario exp | operador_unario exp
prefixexp ::= var | llamada_a_func | '5' exp '6'
llamada_a_func ::= prefixexp arg_actuales | prefixexp '<' nombre args_actuales
args_actuales ::= '5' [explist] '6' | constructor_de_tabla | string
func ::= function cuerpo_de_func
cuerpo_de_func ::= '5' [args_formal_list] '6' bloque end
args_formal_list ::= lista_de_nombres ['.' '...'] | '...'
constructor_de_tabla ::= '9' [lista_de_campos] ':'
lista_de_campos ::= campo {separador_de_campo campo} [separador_de_campo]
campo ::= '%' exp '&' '-' exp | nombre '-' exp | exp
separador_de_campo ::= '.' | ')'
operador_binario ::= 'S' | '-' | 'T' | 'Q' | 'O' | 'N' |
'..' | 'U' | 'U-' | 'V' | 'V-' | '--' |
'W-' | and | or
operador_unario ::= '-' | not | 'X'
Gotas so$re la traduccin
He intentado ser lo ms fiel posible al original; probablemente hay errores y erratas; en caso de duda consltese el original
en ingls.
Algunas palabras son de uso tan comn en informtica que se utilizan en espaol sin traducir. Otras tienen por traduccin
una oracin completa y por tanto sera bastante poco coherente introducir esa frase en cada lugar. He preferido, por tanto,
dejarlas en el texto (indicadas en itlica como es costumbre en espaol con palabras de otros idiomas), exponiendo aqu la
traduccin.
arrays: vectores, matrices, etc.; un conjunto de datos identificado por un nombre (que se le da a todo el conjunto);
los arrays se pueden indexar mediante nmeros enteros o mediante cualquier tipo de dato (en este caso se habla
de arrays asociativos).
buffer: se puede traducir por "tampn" (aunque el nombre en ingls es muy utilizado); es un espacio auxiliar de
memoria para diversas operaciones.
chunk: unidad de ejecucin en Lua, que es simplemente una secuencia de sentencias.
hook: en Lua se denomina as a una funcin en la sombra que se activa al ocurrir ciertos eventos en el cdigo (por
ejemplo un retorno de una funcin); se usa en la depuracin del cdigo.
prompt: un indicador de que el intrprete de comandos del sistema operativo est esperando por una entrada del
usuario.
script: normalmente se denominan as a los programas que se interpretan (por oposicin a los ejecutables
compilados).
string: una tira o secuencia de caracteres.
upvalue: una variable no-local, externa a una funcin (a la que sta tiene acceso).
userdata: en Lua es un espacio de memoria utilizado por funciones C.
Algunas otras palabras han tenido la traduccin siguiente:
closure: instancia (de funcin).
loop: bucle.
statement: sentencia.
thread: proceso.
Last update: Wed Sep 28 01:06:07 BRT 2011