Академический Документы
Профессиональный Документы
Культура Документы
5.1
por Roberto Ierusalimschy, 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.
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
ANSI 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
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.
break
false
local
return
do
for
nil
then
else
function
not
true
elseif
if
or
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 _VERSION) estn
reservados para uso como variables globales internas de Lua.
Los siguientes strings denotan otros elementos:
+
==
(
;
~=
)
:
*
<=
{
,
/
>=
}
.
%
<
[
..
^
>
]
...
#
=
3
0x56
3.0
3.1416
314.16e-2
0.31416E1
Existen
ocho
tipos
bsicos
en
Lua: nil, boolean, number, string, function, userdata, thread y table. Nil es
el tipo del valor nil, cuya principal propiedad es ser diferente de cualquier
otro valor; normalmente representa la ausencia de un valor
til. Boolean es el tipo de los valores false (falso) y true (verdadero).
Tantonil como false hacen una condicin falsa; cualquier otro valor la
hace verdadera. Number 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 API 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 (exceptonil). Las tablas pueden ser heterogneas, 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 ab["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 mtodos (vase 2.5.9).
Los valores de las tablas, las funciones, los procesos y
los userdata (completos)
son objetos:
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 stringintenta 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.3 - Variables
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 lxicamente: 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 (prefixexp) debe dar como resultado un valor tabla;
la segunda expresin (exp) 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
2.4 - Sentencias
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.4.1 - Chunks
La unidad de ejecucin en Lua se denomina chunk, el cual es
simplemente un conjunto de sentencias que se ejecutan
= val
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 break 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 break. Si se necesita el valor de la
variable var entonces debe asignarse a otra variable antes
del break 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_1, ..., var_n in explist do bloque end
equivale al cdigo:
do
local f, s, var = explist
while true do
local var_1, ... , var_n = f(s, var)
var = var_1
if var == nil then break end
bloque
end
end
Ntese lo siguiente:
explist 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 break 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 break).
2.4.6 - Sentencias de llamadas 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.4.7 - Declaraciones 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.
2.5 - Expresiones
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
')'
'(' exp
>=
compara
tablas
-- resultados ajustados a
1
return 2 * f(x)
return x, f(x)
f(x); return
return x or f(x)
-- resultados adicionales
-- resultados descartados
-- resultados ajustados a
1
2.5.9 - Definicin de funciones
La sintaxis para la definicin de funciones es
func ::= function cuerpo_de_func
a=3,
a=3,
a=3,
a=1,
a=1,
b=nil
b=4
b=4
b=10
b=2
g(3)
g(3, 4)
g(3, 4, 5, 8)
g(5, r())
a=3,
a=3,
a=3,
a=5,
b=nil,
b=4,
b=4,
b=1,
...
...
...
...
-->
-->
-->
-->
(nada)
(nada)
5 8
2 3
function
(self,
params)
-- variable global
-- nuevo bloque
-- nueva 'x', con valor
10
print(x)
x = x+1
do
local x = x+1
print(x)
end
print(x)
end
print(x)
variable global)
--> 10
-- otro bloque
-- otra 'x'
--> 12
--> 11
--> 10
(el valor de la
2.8 - Metatablas
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 metamtodos. 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 API 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
+ op2
es
"len": La operacin #.
equivale a not
(a == b).
equivale a b
< a.
= valor.
2.9 - Entornos
a lua_gc o en Lua
un porcentaje (y
de 1). Con esas
directamente (por
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 cesin 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
print("co-body", r, s)
return b, "end"
end)
print("main", coroutine.resume(co,
print("main", coroutine.resume(co,
print("main", coroutine.resume(co,
print("main", coroutine.resume(co,
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
1, 10))
"r"))
"x", "y"))
"x", "y"))
coroutine
3.3 - Pseudondices
Excepto en los casos en que se indique, cualquier funcin que acepta
ndices vlidos tambin puede ser invocada con pseudondices, 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_GLOBALSINDEX. El entorno de una funcin C
que est en ejecucin est siempre en el pseudondice LUA_ENVIRONINDEX.
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,
nombre_de_variable_global);
3.4 - Instancias en C
LUA_GLOBALSINDEX,
3.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_REGISTRYINDEX. 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 stringconteniendo 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.
[-0, +0, -]
[-0, +0, m]
[-0, +0, -]
[-n, +1, e]
[-0, +(0|1), -]
[-0, +1, m]
void lua_createtable
nrec);
(lua_State
*L,
int
narr,
int
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.
lua_dump
[-0, +0, m]
[-0, +0, e]
[-1, +0, v]
[-0, +0, e]
LUA_GCSTOP
LUA_GCRESTART
LUA_GCCOLLECT
LUA_GCCOUNT
LUA_GCCOUNTB
LUA_GCSTEP
LUA_GCSETPAUSE
LUA_GCSETSTEPMUL
lua_getallocf
[-0, +0, -]
[-0, +1, -]
[-0, +1, e]
[-0, +1, e]
lua_getfield(L,
lua_getmetatable
[-0, +(0|1), -]
[-1, +1, e]
lua_gettop
[-0, +0, -]
[-1, +1, -]
[-0, +0, -]
[-0, +0, -]
[-0, +0, -]
[-0, +0, -]
[-0, +0, -]
[-0, +0, -]
lua_isnoneornil
[-0, +0, -]
[-0, +0, -]
[-0, +0, -]
[-0, +0, -]
[-0, +0, -]
[-0, +0, -]
[-0, +0, e]
int lua_lessthan
index2);
(lua_State
*L,
int
index1,
int
[-0, +1, -]
LUA_ERRSYNTAX
LUA_ERRMEM
[-0, +0, -]
[-0, +1, m]
[-0, +1, m]
[-0, +1, m]
[-1, +(2|0), e]
[-0, +0, -]
LUA_ERRRUN
LUA_ERRMEM
LUA_ERRERR
lua_pop
[-n, +0, -]
[-0, +1, -]
[-n, +1, m]
[-0, +1, m]
void
f);
lua_pushcfunction
(lua_State
*L,
lua_CFunction
#define
lua_pushcclosure(L, f, 0)
lua_pushcfunction(L,
f)
lua_pushfstring
[-0, +1, m]
[-0, +1, -]
[-0, +1, -]
[-0, +1, m]
lua_pushlstring
[-0, +1, m]
void lua_pushlstring
size_t len);
(lua_State
*L,
const
char
*s,
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.
lua_pushnil
[-0, +1, -]
[-0, +1, -]
[-0, +1, m]
[-0, +1, -]
[-0, +1, -]
[-0, +1, m]
[-0, +0, -]
int lua_rawequal
index2);
(lua_State
*L,
int
index1,
int
[-1, +1, -]
[-0, +1, -]
[-2, +0, m]
[-1, +0, m]
[-0, +0, e]
[-1, +0, -]
[-1, +0, -]
[-?, +?, -]
[-0, +0, -]
lua_setfenv
[-1, +0, -]
[-1, +0, e]
[-1, +0, e]
nombre
global.
lua_setfield(L,
lua_setmetatable
[-1, +0, -]
Elimina una tabla de la pila y la toma como nueva metatabla para el valor
en la situacin del ndice aceptable.
lua_settable
[-2, +0, e]
[-?, +?, -]
[-0, +0, -]
[-0, +0, -]
[-0, +0, -]
lua_CFunction
index);
lua_tocfunction
(lua_State
*L,
int
[-0, +0, -]
[-0, +0, m]
lua_tonumber
[-0, +0, -]
[-0, +0, -]
[-0, +0, m]
[-0, +0, -]
[-0, +0, -]
[-0, +0, -]
[-0, +0, -]
Retorna el nombre del tipo codificado por el valor tp, el cual debe ser uno
de los valores retornados lua_type.
lua_Writer
[-?, +?, -]
[-?, +?, -]
int lua_yield
lua_Debug
/*
/*
/*
/*
/*
(n)
(n)
(S)
(S)
(l)
*/
*/
*/
*/
*/
/* (u) number of
/* (S) */
/* (S) */
/* (S) */
source:
short_src:
linedefined:
funcin.
lastlinedefined:
funcin.
what:
currentline:
name:
namewhat:
nups:
lua_gethook
[-0, +0, -]
[-0, +0, -]
[-0, +0, -]
[-(0|1), +(0|1|2), m]
int lua_getinfo
lua_Debug *ar);
(lua_State
*L,
const
char
*what,
/*
los
[-0, +(0|1), -]
[-0, +0, -]
[-0, +(0|1), -]
const
char
*lua_getupvalue
funcindex, int n);
(lua_State
*L,
int
typedef
*ar);
void
(*lua_Hook)
(lua_State
*L,
lua_Debug
[-0, +0, -]
[-(0|1), +0, -]
[-(0|1), +0, -]
const
char
*lua_setupvalue
funcindex, int n);
(lua_State
*L,
int
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.
4 - La biblioteca auxiliar
La biblioteca auxiliar proporciona varias funciones convenientes para
realizar la interface de C con Lua. Mientras que la API 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 API bsica as que realmente
no proporcionan nada nuevo que no pueda ser realizado con la API.
[-0, +0, m]
[-0, +0, m]
[-0, +0, m]
rea
[-0, +0, m]
[-1, +0, m]
de
la
pila
[-0, +0, v]
[-0, +0, v]
[-0, +0, e]
[-0, +(0|1), e]
[-0, +0, v]
[-0, +0, v]
[-0, +0, v]
lua_Integer
narg);
luaL_checkinteger
(lua_State
*L,
int
[-0, +0, v]
[-0, +0, v]
[-0, +0, v]
[-0, +0, v]
[-0, +0, v]
[-0, +0, v]
[-0, +0, v]
[-0, +0, v]
la
funcin
es
un userdata del
luaL_dofile
[-0, +?, m]
[-0, +?, m]
str)
||
lua_pcall(L,
0,
[-0, +0, v]
[-0, +(0|1), m]
[-0, +1, -]
void luaL_getmetatable
*tname);
(lua_State
*L,
const
char
[-0, +1, m]
[-0, +1, m]
[-0, +1, m]
int
luaL_loadfile
*filename);
(lua_State
*L,
const
char
Carga un fichero como chunk de Lua. Esta funcin usa lua_load para
cargar
el chunk que
est
en
el
fichero filename.
[-0, +1, m]
[-0, +1, m]
int
luaL_newmetatable
*tname);
(lua_State
*L,
const
char
[-0, +0, -]
[-0, +0, m]
[-0, +0, v]
[-0, +0, v]
[-0, +0, v]
[-0, +0, v]
[-0, +0, v]
lua_Number luaL_optnumber
lua_Number d);
(lua_State
*L,
int
narg,
[-0, +0, v]
[-0, +0, -]
[-?, +1, m]
[-1, +0, m]
[-(0|1), +1, m]
[-0, +0, -]
[-0, +0, v]
[-0, +0, -]
[-0, +1, m]
5 - Bibliotecas estndar
Las bibliotecas estndar de Lua proporcionan funciones tiles que estn
implementadas directamente a travs de la API de C. Algunas de estas
funciones
proveen
servicios
esenciales
al
lenguaje
(por
ejemplo, type y getmetatable); otras proporcionan acceso a servicios
"externos" (por ejemplo, I/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 API 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 (I/O);
el
nuevo
valor
para
valor
para
dofile (nombre_de_fichero)
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 ([f])
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.
se utiliza para identificar el chunk en los mensajes de
error y para informacin de depuracin.
nombre_de_chunk
loadfile ([nombre_de_fichero])
Obtiene
el
valor
real
de tabla[ndice] sin
invocar
ningn
metamtodo. tabla debe ser una tabla e ndice cualquier valor diferente
de nil.
rawset (tabla, ndice, valor)
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.
setmetatable (tabla, metatabla)
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".
xpcall (f, err)
Crea una nueva co-rutina con cuerpo f. f debe ser una funcin Lua.
Retorna una nueva co-rutina, un objeto de tipo "thread".
cocoha
no
co-
coroutine.wrap (f)
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.yield ()
5.3 - 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.
module (nombre [, ])
entorno LUA_CPATH(adems
en luaconf.h).
de
otro
camino
por
defecto
definido
package.loaded
Una tabla usada por require que controla cmo se cargan los mdulos
Cada entrada en esta tabla es una funcin 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
tabla package.preload.
simplemente
busca
un
cargador
en
la
(Por
este stringdevuelve una copia de la funcin. func debe ser una funcin
Lua sin upvalues.
string.find (s, patrn [, inicio [, bsica]])
un
nmero
como
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 delstring 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.gsub (s, patrn, reemplazamiento [, n])
"%$
string.len (s)
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.match (s, patrn [, inicio])
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 -1 (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.upper (s)
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.4.1 - Patrones
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 x no es uno de los caracteres mgicos ^$()%.[]*+-?)
representa el propio caracter x.
(un punto) representa cualquier carcter.
.:
%a:
%c:
%d:
%l:
%p:
%s:
%u:
%w:
%x:
%z:
%x:
[conjunto]:
representa
el
complemento
de conjunto,
donde conjunto se interpreta como se ha indicado ms arriba.
[^conjunto]:
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.
Elementos de un patrn
Cada elemento de un patrn 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,
%bxy,
Patrn
Un patrn 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.
Capturas
Un patrn puede contener subpatrones encerrados entre parntesis que
describen capturas. Cuando sucede una coincidencia entre un patrn y
un stringdado, 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.
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.
table.insert (tabla, [posicin,] valor)
math.atan (x)
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.)
math.ceil (x)
math.huge
El valor de pi.
math.pow (x, y)
Devuelve xy. (Se puede tambin usar la expresin x^y para calcular este
valor.)
math.rad (x)
Devuelve en radianes
sexagesimales).
el
valor
del
ngulo x (dado
en
grados
puede
usar
math.tan (x)
tambin
la
Equivalente a io.input():read.
io.tmpfile ()
Equivalente a io.output():write.
descriptor_de_fichero:close ()
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
bloque 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 ()
Establece
un
modo buffer para
un
fichero
argumento modo puede ser uno de estos tres:
de
salida.
El
Cuando se invoca con nil como primer argumento, esta funcin retorna
slo el nombre del local actual en la categora dada.
os.time ([tabla])
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.
"c":
"r":
"l":
El hook se invoca cada vez que Lua entra en una nueva lnea
de cdigo.
Establece tabla (que puede ser nil) como la metatabla del objeto dado.
debug.setupvalue (func, up, valor)
-e
-l
-i:
entra
en
modo
el fichero_de_script;
interactivo
despus
de
ejecutar
-v:
--:
-:
7 - Incompatibilidades 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.
break
false
func
constructor_de_tabla
true
|
nmero
prefixexp
|
exp
operador_binario
exp
operador_unario exp
prefixexp ::= var
llamada_a_func
'(' exp
')'
llamada_a_func ::=
prefixexp
prefixexp ':' nombre args_actuales
args_actuales
constructor_de_tabla
::=
'('
| string
arg_actuales
[explist]
')'
::=
'('
[args_formal_list]
')'
{separador_de_campo
|
';'
not
'/'
|
|
'>'
'#'