Noes de Lua 3.

1
Noes bsicas da linguagem de programao Lua

NDICE

Lua 3.1................................................................................................................................................................................................................1 1. 2. 3. 4. Copyright.......................................................................................................................................................................................4 Viso Geral....................................................................................................................................................................................5 Ambiente de Programao.......................................................................................................................................................6 Variveis e tipos...........................................................................................................................................................................7 Tipo nil............................................................................................................................................................................................7 Tipo number....................................................................................................................................................................................8 Tipo string.......................................................................................................................................................................................8 Tipo function...................................................................................................................................................................................9 Tipo userdata..................................................................................................................................................................................9 Tipo table........................................................................................................................................................................................9 5. Atribuio e operadores......................................................................................................................................................... 10 Atribuio simples e mltipla ............................................................................................................................................... 10 Operadores................................................................................................................................................................................. 11 6. Controle de fluxo e variveis locais.................................................................................................................................... 14 Tomadas de deciso com if................................................................................................................................................... 14 Laos iterativos com tomada de deciso no incio (while)............................................................................................. 15 Laos iterativos com tomada de deciso no fim (repeat) ............................................................................................... 15 Declarao de variveis locais .............................................................................................................................................. 16 7. 8. Funes....................................................................................................................................................................................... 17 Tabelas (vetores associativos)............................................................................................................................................... 20 Criao de tabelas..................................................................................................................................................................... 20 Inicializao de tabelas via indexao consecutiva......................................................................................................... 22 Inicializao de tabelas via atribuio de campos........................................................................................................... 22 Inicializao mista .................................................................................................................................................................... 23 9. Tratamento de erros................................................................................................................................................................ 24 dofile( filename ).......................................................................................................................................................................... 25 dostring( string [, errmethod ] ).................................................................................................................................................. 25 next( table, index )....................................................................................................................................................................... 26 nextvar( name )........................................................................................................................................................................... 27 type( value ).................................................................................................................................................................................. 27 10. Funes pr-definidas............................................................................................................................................................. 25

tonumber( e ).............................................................................................................................................................................. 28 tostring( e ).................................................................................................................................................................................. 28 print( expr1, expr2, ... ).............................................................................................................................................................. 29 error( msg ) .................................................................................................................................................................................. 29 call( func, arg, [retmode] )............................................................................................................................................................. 30 assert( value ) ............................................................................................................................................................................... 30 11. Bibliotecas de funes............................................................................................................................................................ 32 Biblioteca de manipulao de strings ................................................................................................................................... 32 Biblioteca de funes matemticas..................................................................................................................................... 39 Biblioteca de funes de entrada e sada........................................................................................................................... 40 Apndice. Relevncia de Lua.......................................................................................................................................................... 47 Relevncia Tecnolgica.......................................................................................................................................................... 47 Relevncia Acadmica............................................................................................................................................................ 49

1. Copyright O texto aqui includo foi extrado em parte dos documentos Programando em Lua Teoria e Prtica (verso 2.1) e A Linguagem de Extenso Lua escrito por Waldemar Celes Filho, Luiz Henrique de Figueiredo e Roberto Ierusalimschy. Atualizaes para a verso 3.1 de Lua foram feitas por Roberto de Beauclair Seixas, baseado no texto original de Anna Magdalena Hester. Este documento est disponvel em: ftp://ftp.tecgraf.puc-rio.br/pub/lua/nocoes-3.1.pdf http://www.tecgraf.puc-rio.br/lua/ftp/nocoes-3.1.pdf
Lua uma linguagem de programao de distribuio aberta, gratuita. A

implementao descrita aqui est disponvel em:

ftp://ftp.tecgraf.puc-rio.br/pub/lua/lua-3.1.tar.gz http://www.tecgraf.puc-rio.br/lua/

Copyright de Lua:
Copyright (c) 1994-1998 TeCGraf, PUC-Rio. Written by Waldemar Celes Filho, Roberto Ierusalimschy, Luiz Henrique de Figueiredo. All rights reserved. Permission is hereby granted, without written agreement and without license or royalty fees, to use, copy, modify, and distribute this software and its documentation for any purpose, subject to the following conditions: The above copyright notice and this permission notice shall appear in all copies or substantial portions of this software. The name "Lua" cannot be used for any modified form of this software that does not originate from the authors. Nevertheless, the name "Lua" may and should be used to designate the language implemented and described in this package, even if embedded in any other system, as long as its syntax and semantics remain unchanged. The authors specifically disclaim any warranties, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose. The software provided hereunder is on an "as is" basis, and the authors have no obligation to provide maintenance, support, updates, enhancements, or modifications. In no event shall TeCGraf, PUC-Rio, or the authors be liable to any party for direct, indirect, special, incidental, or consequential damages arising out of the use of this software and its authors be liable to any party for direct, indirect, special, incidental, or consequential damages arising out of the use of this software and its documentation.

2. Viso Geral
Lua uma linguagem de extenso projetada para ser usada como linguagem de

configurao, acoplada a um programa hospedeiro (escrito na linguagem de programao C). Aplicaes em geral podem acoplar cdigos em Lua, permitindo prototipagem rpida e acesso programvel pelo usurio tecnologia implementada pela aplicao. No entanto bastante comum o uso de Lua como um interpretador stand-alone. Nesse enfoque o cdigo Lua a linha de execuo principal, o programador escreve todo o cdigo da aplicao em Lua e no precisa ter conhecimento da API em C. O ambiente de programao formado pelas funes pr-definidas de Lua, pelas bibliotecas padro da linguagem e por eventuais pacotes de extenso adicionados.
CGILua essencialmente um interpretador Lua com uma srie de pacotes de

extenso, de forma que seu ambiente de programao capaz de prover diversas funcionalidades teis para o desenvolvimento de scripts CGI e pginas HTML dinmicas.
Lua prov as construes fundamentais para definio de funes e controle de fluxo

( if-elseif-else-end, while-do-end, repeat-until ), um poderoso tipo para descrio de estruturas de dados, a tabela, e facilidades para manipulao de strings em especial, os recursos de pattern matching. Todos os mecanismos e recursos citados acima so facilmente acessados atravs de uma sintaxe simples, semelhante de Pascal. Lua garante ainda uma programao com alto nvel de abstrao, j que o programador no precisa se preocupar com detalhes como declarao de variveis e gerenciamento de memria. Com estruturas internas dinmicas e coleta automtica de lixo, o programador usa livremente as diversas opes de estruturao de dados, e deixa a cargo da prpria linguagem as tarefas de re-alocao e liberao de memria. Este texto apresenta, passo a passo, as principais caractersticas da linguagem de programao Lua. A abordagem concentrada na utilizao stand-alone da linguagem, ignorando a existncia de um programa hospedeiro escrito em C. O texto pretende ter um carter didtico; alguns recursos da linguagem so omitidos, em especial o mecanismo de tags methods, os contrutores de tipos, a API C e a interface para debug. A definio oficial da linguagem est descrita no seu manual de referncia, disponvel online em http://www.tecgraf.puc-rio.br/lua/manual. Nas sees subseqentes, so apresentadas as diversas caractersticas da linguagem Lua, atravs de uma discusso detalhada e ilustrada com exemplos de programao.

3. Ambiente de Programao Todos os comandos e construes de Lua so executados em um nico ambiente global. Este ambiente, que guarda todas as variveis globais e definies de funes, automaticamente inicializado quando o interpretador ativado e persiste enquanto o interpretador estiver em execuo. O ambiente global de Lua pode ser manipulado por cdigos escritos em Lua ou por bibliotecas C que utilizem funes da interface C-Lua. Cdigos Lua so compostos por comandos globais e definies de funes. Um mdulo Lua um arquivo ou uma cadeia de caracteres contendo cdigos Lua. Quando se carrega um mdulo Lua, os cdigos so compilados para uma linguagem de mquina interna, para serem posteriormente executados. Os cdigos globais (que no esto dentro de funes) so automaticamente executados ao fim da compilao do mdulo. Os cdigos de funes so armazenados e executados na chamada das respectivas funes. Em outras palavras, Lua usa uma estratgia hbrida de compilao e interpretao, que evita o custo de desempenho de interpretao textual direta, ao mesmo tempo que mantm a versatilidade de um ambiente interpretativo. Pode-se carregar diversos mdulos inicialmente independentes. Todos, no entanto, so carregados dentro do nico ambiente global de Lua. Portanto, a ordem com que se carrega diversos mdulos importante, tendo em vista que os comandos globais de cada mdulo so executados imediatamente aps sua compilao. No existe uma formatao rgida para o cdigo Lua, isto , a linguagem permite comandos em qualquer coluna do texto, podendo ocupar diversas linhas. Os comandos de Lua podem opcionalmente ser separados por ponto e vrgula (;). Comentrios iniciam-se com traos duplos (--) e persistem at o final da linha.

4. Variveis e tipos As variveis globais1 de Lua no precisam ser declaradas. vlido, por exemplo, escrever o comando
a = 2.3

sem necessidade prvia de declarar a varivel global a. Uma caracterstica fundamental de Lua que as variveis no tm tipo: os tipos esto associados aos dados armazenados na varivel. Assim, o cdigo acima armazena em a um dado do tipo numrico, com valor 2.3, enquanto, aps o comando
a = "Linguagem Lua"

a varivel a passa a armazenar um dado do tipo cadeia de caracteres (string). Os dados em Lua podem ser de sete tipos bsicos: nil, number, string, function, cfunction, userdata e table, descritos a seguir.
Tipo nil

O tipo nil representa o valor indefinido. Todas as variveis ainda no inicializadas assumem o valor nil. Assim, se o cdigo:
a = b

for encontrado antes de qualquer atribuio varivel b, ento esta assumida como contendo o valor nil, o que significa que a tambm passa a armazenar nil, independentemente do valor anteriormente armazenado em a. A palavra reservada nil pode ser usada na programao para expressar o valor do tipo nil. Com isto, pode-se escrever:
a = nil

que atribui o valor nil varivel a (a partir deste ponto, como se a varivel a ainda no tivesse sido atribuda). Pode-se testar se uma varivel foi inicializada comparando o seu valor com nil:

1Lua tambm permite a definio de variveis locais (veja pg. 16).

a == nil

Tipo number

O tipo number representa valores numricos. Lua no faz distino entre valores numricos com valores inteiros e reais. Todos os valores numricos so tratados como sendo do tipo number. Assim, o cdigo
a b c d = = = = 4 4.0 0.4e1 40e-1

armazena o valor numrico quatro nas variveis a, b, c e d.

Tipo string

O tipo string representa cadeia de caracteres. Uma cadeia de caracateres em Lua definida por uma seqncia de caracteres delimitadas por aspas simples (' ') ou duplas (" "). A seqncia de caracteres deve estar numa mesma linha de cdigo. Dentro de um string, so interpretadas as seguintes seqncias de escape:
\n \t \r \v \f \xxx \a \b \ \ \\
new line tab carriage return vertical tab form feed caracter com cdigo decimal xxx bell backspace aspas duplas () aspas simples () barra invertida (\)

Por simplicidade, quando a cadeia de caracteres delimitada por aspas duplas, podese usar aspas simples no seu contedo, sem necessidade de trat-las como seqncias de escape. Entretanto, para reproduzir na cadeia de caracteres as aspas usadas como delimitadoras, necessrio usar os caracteres de escape. Assim, so vlidas e equivalentes as seguintes atribuies:
s = "Olho d'agua" s = 'Olho d\'agua'

Colchetes duplos ([[ ]]) tambm podem ser utilizados como delimitadores de strings. Diferentemente dos delimitadores aspas simples e aspas duplas, esse delimitador no interpreta sequncias de escape e tolera que a string tenha quebras de linhas e pode conter strings com delimitadores aninhados. Exemplo:

s = [[Esse um texto que atravessa mais de uma linha e contm uma string aninhada: [[aninhada]] no final !]]

Tipo function

Funes em Lua so consideradas valores de primeira classe. Isto significa que funes podem ser armazenadas em variveis, passadas como parmetros para outras funes, ou retornadas como resultados. A definio de uma funo equivale a atribuir a uma varivel global o valor do cdigo que executa a funo (seo 7). Esta varivel global passa a armazenar um dado do tipo function. Assim, adiantando um pouco a sintaxe de definio de funes, o trecho ilustrativo de cdigo abaixo armazena na varivel func1 um valor do tipo function:
function func1 (...) ... end

que pode posteriormente ser executada atravs de uma chamada de funo:

func1(...)

Tipo userdata

O tipo userdata permite armazenar numa varivel de Lua um ponteiro qualquer de C. Este tipo corresponde ao tipo void* de C e s pode ser atribudo ou comparado para igualdade a outro valor de mesmo tipo em Lua. Este tipo muito til para programadores de aplicao que fazem a ligao Lua-C, mas no manipulado por usurios que programam somente em Lua, pois no possvel criar dados deste tipo diretamente em Lua.
Tipo table

O tipo table (tabela) o tipo mais expressivo da linguagem. Este tipo implementa os chamados vetores associativos, que permitem indexao por valores de qualquer outro tipo, com exceo do tipo nil. As tabelas em Lua permitem a construo de vetores convencionais, listas e records numa mesma estrutura. Tabelas devem ser explicitamente criadas. Adiantando a sintaxe de criao de uma tabela, o cdigo
a = { }

cria uma tabela vazia e armazena em a este valor. Novos campos podem ser adicionados posteriormente a esta tabela. Tabelas so detalhadamente discutidas na seo 8.

5. Atribuio e operadores Conforme mencionado, as variveis em Lua no tm tipos; elas apenas armazenam valores de diferentes tipos. Diz-se que as variveis so tipadas dinamicamente. Quando se atribui um valor a uma varivel, armazenado na varivel um valor de um determinado tipo. Se feita uma outra atribuio mesma varivel, ela passa a armazenar o valor correspondente segunda atribuio. Portanto, antes da segunda atribuio, a varivel armazenava um valor de um determinado tipo; aps a segunda atribuio, a varivel passa a armazenar um valor de um tipo possivelmente diferente. Quando se efetua operaes sobre os valores armazenados nas variveis, a linguagem verifica, em tempo de execuo, a validade dos tipos armazenados para a operao em questo. Por exemplo, ao tentar efetuar uma operao de soma sobre uma varivel que armazena o valor de uma funo, a linguagem reporta um erro de execuo2.

Atribuio simples e mltipla

Os exemplos das sees anteriores ilustraram a sintaxe de atribuio simples. Lua tambm permite atribuio mltipla. possvel atribuir diversas variveis em um mesmo comando. Por exemplo, o cdigo
s, v = "Linguagem Lua", 2

atribui a cadeia de caracteres Linguagem Lua varivel s e o valor numrico 2 varivel v. Quando o nmero de variveis listadas esquerda do sinal de igualdade diferente do nmero de resultados direita da igualdade, a linguagem automaticamente ajusta as listas: ou preenchendo as ltimas variveis da esquerda com valores nils ou descartando os ltimos resultados da direita. Assim, o cdigo
a, b = 2 c, d = 2, 4, 6

atribui 2 varivel a, nil varivel b, 2 varivel c, 4 varivel d, e despreza o valor 6. A possibilidade de atribuio mltipla permite a troca de valores armazenados em duas variveis com um nico comando. Portanto
a, b = b, a

faz com que a receba o valor anteriormente armazenado por b e que b receba o valor anteriormente armazenado por a, sem necessidade de variveis temporrias.
2Este comportamento pode ser alterado usando tag methods (veja o Manual de Referncia de Lua).

10

Operadores

A linguagem Lua prov os operadores aritmticos, relacionais e lgicos usuais. Existe, ainda, um operador para concatenao de cadeias de caracteres. Lua possui tambm algumas regras de converso automtica de tipos.
Operadores aritmticos

Lua dispe dos operadores aritmticos usuais: os operadores binrios so + (adio), - (subtrao), * (multiplicao) e / (diviso); e o operador unrio -. permitido o uso de parnteses para alterar a precedncia dos operadores. Portanto, so vlidas as expresses abaixo:
a = 2 * 3.4 b = (a + 1) / 3.4 c = 2 * (-3)

Os operadores aritmticos s podem ser aplicados sobre valores do tipo number (ou strings que possam ser convertidas para nmeros; veja tpico "Coero" nessa mesma seo). O operador binrio ^, com precedncia superior aos demais, pode ser implementado atravs do mecanismo de tag methods (veja o Manual de Referncia de Lua). A biblioteca de funes matemticas distribuda com a linguagem implementa a operao de exponenciao usual para este operador.
Operadores relacionais

Os operadores relacionais disponveis em Lua so:

< > <= >= == ~=
menor que maior que menor que ou igual a maior que ou igual a igual a diferente de

Os operadores relacionais retornam o valor nil quando o resultado falso e o valor 1 quando o resultado verdadeiro. Assim, as atribuies
a = 4 < 3 b = 4 > 3

armazenam em a o valor nil e em b o valor 1. Os operadores >, <, >=, <= s so aplicveis em dados do tipo number ou string, e tm a interpretao usual. Este comportamento pode ser alterado usando tag methods (consultar o Manual de Referncia de Lua para maiores informaes).

11

O operador de igualdade (==) primeiro compara se os tipos dos dados comparados so iguais. Caso no sejam, retorna-se nil. Se os valores tiverem o mesmo tipo, compara-se a igualdade entre os valores. A igualdade de nmeros e cadeias de caracteres feita da forma usual. Tabelas, funes e userdata so comparados por referncia, isto , duas tabelas so consideradas iguais somente se as duas forem a mesma tabela, e no se as duas contm armazenados os mesmos dados. O operador de no-igualdade (~=) a negao do operador de igualdade.
Operadores lgicos

Os trs operadores lgicos disponveis so:

and or not
conjuno disjuno negao

Conjunes ou disjunes mltiplas so avaliadas da esquerda para a direita; a avaliao pra assim que a veracidade ou falsidade do resultado for conhecida. Assim, o cdigo
a b c d = = = = 23 15 a < 20 or b > a a < 20 and b > a

resulta no valor nil em c e d, sendo que, para avaliar d, no necessrio avaliar b>a, pois o resultado j era conhecido tendo em vista que a expresso era conectada com o operador lgico and e a<20 j falso.
Operador de concatenao

O operador para concatenao de cadeias de caracteres em Lua representado por dois caracteres ponto (..). Aplicado a dois valores do tipo string, este operador retorna uma terceira cadeia de caracteres que corresponde unio das duas cadeias originais. Portanto, o cdigo
a = "Linguagem" b = "Lua" c = a .. " " .. b

resulta no armazenamento da cadeia de caracteres Linguagem Lua na varivel c, resultante da concatenao da varivel a com uma cadeia composta por um caractere branco, seguida da varivel b.

12

Coero

Lua prov alguns mecanismos para converso automtica entre tipos. Qualquer operao aritmtica aplicada sobre cadeias de caracteres tenta converter a cadeia de caracteres no valor numrico correspondente. Mais especificamente, se os caracteres da string representam um valor numrico, ento este valor numrico assumido na operao. Quando a converso no possvel, a linguagem reporta um erro de execuo. Portanto, o cdigo
b = "53" c = 2 + b

resulta no armazenamento do valor numrico 55 na varivel c, tendo em vista que a cadeia de caracteres 53 foi convertida para o valor numrico 53 antes da operao (a varivel b continua armazenando uma varivel do tipo string). Por outro lado, quando utilizamos um valor numrico onde espera-se uma cadeia de caracteres (e.g., numa concatenao), o valor numrico convertido para a cadeia de caracteres correspondente. Se o valor numrico for inteiro, ele escrito numa cadeia de caracteres sem ponto decimal ou expoente. Se o valor contiver parte fracionria, o resultado pode conter ponto decimal e expoente3. Assim, o cdigo
print("resultado: " .. 23)

tem como sada a cadeia de caracteres

resultado: 23.

Existe uma funo pr-definida, tonumber, que faz explicitamente a converso de uma cadeia de caracteres para a forma numrica, se posssvel. Para converter explicitamente um valor numrico numa cadeia de caracteres, existe a funo tostring (seo 10).
Ordem de precedncia dos operadores

Os operadores tm a ordem de precedncia usual. Conforme mencionado, possvel o uso de parnteses para mudar a ordem natural de avaliao de uma expresso. A lista abaixo apresenta os operadores, em ordem decrescente de precedncia:
^ not * + .. < and -(unrio) / > or <= ~= ==

3Mais precisamente, utiliza-se tostring, que por default

usa a funo sprintf com %.16g.

13

6. Controle de fluxo e variveis locais

Lua possui os mecanismos usuais para controle de fluxo. Estes controladores

agrupam diversos comandos em blocos que podem ou no ser executados uma ou mais vezes. Lua tambm permite a declarao de variveis locais. Estas variveis deixam de existir ao final do bloco onde foram declaradas.
Tomadas de deciso com if

O comando de deciso bsico de Lua o if. Sua forma pode ser:

if expr then bloco end

ou
if expr then bloco1... else bloco2... end

ou ainda
if expr1 then bloco1 elseif expr2 then bloco2 ... elseif expr N then bloco N else bloco N+1 end

Na primeira forma, o bloco de comandos representado por bloco executado se a expresso expr produzir um valor diferente de nil. Na segunda forma, bloco2 ser executado se expr produzir o valor nil. Caso contrrio, bloco1 ser executado. A terceira forma ilustra a possibilidade de tomada de deciso entre diversas alternativas usando-se o comando if-then-elseif-then-...-else-end. No cdigo ilustrado, bloco1 executado se expr1 produzir um valor verdadeiro (diferente de nil), bloco2 executado de expr2 for verdadeiro, ..., e bloco n+1 executado se todas as expresses forem falsas (i.e., iguais a nil).

14

Laos iterativos com tomada de deciso no incio (while)

Lua possui duas alternativas para construo de laos iterativos: while e repeat. A

primeira delas permite que a tomada de deciso (se os comandos do lao devem ou no ser executados) seja feita no incio do bloco. Sua forma geral :
while expr do bloco end

Isto , enquanto a expresso expr produzir um valor verdadeiro (diferente de nil), os comandos do bloco so executados. Para exemplificar, considere o cdigo abaixo que calcula o fatorial de um nmero (assumido como inteiro positivo) armazenado na varivel n:
f = 1 i = n while i > 0 do f = f * i i = i 1 end valor do fatorial controle do lao

Ao final da execuo do cdigo acima, f armazena o valor do fatorial de n e i armazena o valor zero (condio de fim de execuo do lao).

Laos iterativos com tomada de deciso no fim (repeat)

A construo de um lao com tomada de deciso no fim pode ser feita atravs do comando repeat. Sua forma geral :
repeat bloco until expr

Nesta construo, o bloco de comandos executado pelo menos uma vez (pois o teste de deciso s ocorre no final do lao) e repetido at se alcanar o valor verdadeiro para a expresso. O mesmo exemplo de clculo de fatorial pode ser escrito:

15

f = 1 valor do fatorial i = 1 controle do lao repeat f = f * i i = i + 1 until i > n

Declarao de variveis locais

Lua permite que se defina explicitamente variveis de escopo local. A declarao de

uma varivel local pode ocorrer em qualquer lugar dentro de um bloco de comandos, e seu escopo termina quando termina o bloco no qual foi declarada. A declarao de uma varivel local com mesmo nome de uma varivel global obscurece temporariamente (i.e., dentro do bloco da declarao local) o acesso varivel global. Quando o programador escrever o nome da varivel, estar se referindo varivel local. Variveis locais podem ser inicializadas na declarao seguindo a sintaxe de atribuies. Para exemplificar, considere o cdigo abaixo:
a = 2 if a > 0 then local b = a a = a + 1 local a = b print(a) end print(a) varivel global assumindo o valor 2 declara-se uma varivel local que recebe o valor de a (2) incrementa a varivel global a de uma unidade declara-se uma varivel local a que recebe o valor de b a refere-se a varivel local, logo imprime-se o valor 2 fim do bloco e do escopo de a e b locais

a refere-se varivel global, logo imprime-se o valor 3

Pode-se ainda declarar e inicializar vrias variveis locais num mesmo comando:
local a, b, c = 2, 5+6, -3

Neste caso, a recebe 2, b recebe 11 e c recebe -3. Variveis locais no inicializadas assumem o valor nil.

16

7. Funes A linguagem Lua trata funes como valores de primeira classe. Isto quer dizer que funes podem ser armazenadas em variveis, podem ser passadas como parmetros para outras funes e podem ser retornadas como resultados de funes. Quando definimos uma funo em Lua, estamos armazenando na varivel global cujo nome corresponde ao nome da funo o cdigo de mquina interno da funo, que pode posteriormente ser executado atravs de chamadas para a funo. Funes em Lua podem ser definidas em qualquer lugar do ambiente global. A forma bsica para definio de funes
function nome ( [lista-de-parmetros] ) bloco de comandos end

onde nome representa a varivel global que armazenar a funo. Pode-se fornecer uma lista de parmetros que so tratados como variveis locais da funo e inicializados pelos valores dos argumentos na chamada da funo. A chamada da funo segue a forma bsica
nome ( [lista-de-argumentos] )

isto , o nome da funo seguido de abre e fecha parnteses, que pode ou no conter uma lista de argumentos. Se nome no for uma varivel que armazena um valor de funo (i.e., do tipo function), Lua reporta um erro de execuo (TAG METHODS). Se presente, a lista de argumentos avaliada antes da chamada da funo. Posteriormente, os valores dos argumentos so ajustados para a atribuio dos parmetros (a regra de ajuste anloga a uma atribuio mltipla onde os parmetros recebem os valores dos argumentos).
Lua passa parmetros por valor. Isto quer dizer que quando se altera o valor de um

parmetro dentro de uma funo, altera-se apenas o valor da varivel local correspondente ao parmetro. O valor da varivel passada como argumento na chamada da funo permanece inalterado. Funes em Lua podem retornar zero, um ou mais valores atravs do comando return. A possibilidade de retorno mltiplo evita a necessidade de passagem de parmetros por referncia. Quando, durante a execuo de uma funo, encontra-se o comando return, a execuo da funo terminada e o controle volta para o ponto imediatamente posterior chamada da funo. O comando return pode vir seguido de uma lista de expresses; sua forma geral

17

return [lista-de-expresses]

Por razes sintticas, o comando return deve sempre ser o ltimo comando de um bloco de comandos. Deste modo, evita-se a ocorrncia de comandos inalcanveis (tendo em vista que comandos aps return nunca sero executados). Se return no for o ltimo comando do bloco, Lua reporta um erro de sintaxe. Os valores retornados por uma funo so ajustados para a atribuio na linha que faz a chamada. Para exemplificar, supe-se uma funo que incrementa os valores de um ponto cartesiano (x, y):
function translada (x, y, dx, dy) return x+dx, y+dy end

Considera-se, agora, que a chamada da funo feita por:

a, b = translada(20, 30, 1, 2)

Assim, a recebe o valor 21 (=20+1) e b recebe o valor 32 (=30+2). Se a chamada fosse

a = translada(20, 30, 1, 2)

ento o segundo valor retornado seria desprezado, e a receberia o valor 21. Por outro lado, a atribuio:
a, b, c = translada(20, 30, 1, 2)

faria a= 21, b = 32 e c = nil. importante notar que uma chamada de funo que retorna mltiplos valores no pode estar no meio de uma lista de expresses. Por razes de ajustes de valores em atribuies mltiplas, se uma funo estiver sendo chamada no meio de uma lista de expresses, s se considera o primeiro valor retornado. Para exemplificar, duas situaes sutilmente diferentes so analisadas; considera-se inicialmente a chamada de funo abaixo:
a, b, c = 10, translada(20, 30, 1, 2)

que faz com que a receba o valor 10, b o valor 21 e c o valor 32. Neste caso, o funcionamento o esperado, tendo em vista que a chamada da funo a ltima expresso numa lista de expresses. No entanto, se o cdigo fosse
a, b, c = translada(20, 30, 1, 2), 10

ento teria-se resultados surpreendentes, j que a chamada da funo est no meio de uma lista de expresses. Conforme mencionado, independentemente do nmero de valores retornados pela funo, considera-se apenas o primeiro (no caso, o valor 21). O valor 32 retornado pela funo perdido durante o ajuste. Assim, teramos como

18

resultado o valor 21 armazenado em a e o valor 10 armazenado em b. A varivel c, ento, receberia o valor nil, pois no se tem outra expresso aps a constante 10. possvel definir funes em Lua que aceitem nmero varivel de argumentos. Para tanto necessrio acrescentar lista de argumentos da definio a indicao ... (trs pontos seguidos). Uma funo definida dessa forma no faz ajuste do nmero de parmetros em relao ao nmero de argumentos. Ao invs disso, quando a funo chamada os argumentos extras so colocados em um parmetro implcito de nome arg. Esse parmetro sempre inicializado como uma tabela, onde o campo n contm o nmero de argumentos extras e os campos 1, 2, ... os valores dos argumentos, sequencialmente. Para exemplificar, duas diferentes definies de funes so apresentadas:
function f(a, b) end function g(a, b, ...) end

Os seguintes mapeamentos de argumentos a parmetros seriam efetuados na chamada dessas funes:

CHAMADA f(3) f(3, 4) f(3, 4, 5) g(3) g(3, 4) g(3, 4, 5, 8) a=3, b=nil a=3, b=4 a=3, b=4 a=3, b=nil, arg={ n=0 } a=3, b=4, arg={ n=0 } a=3, b=4, arg={ 5,8; n=2 } PARMETROS

19

8. Tabelas (vetores associativos) Tabelas em Lua so vetores associativos, isto , vetores que podem ser indexados por valores numricos, por cadeias de caracteres ou por qualquer valor dos demais tipos da linguagem. Vetores s no podem ser indexados pelo valor nil. Esta flexibilidade na indexao de tabelas a base do mecanismo existente em Lua para descrio de objetos.

Criao de tabelas

Uma tabela deve ser explicitamente criada antes de ser usada. A expresso { } cria uma tabela. Assim, o cdigo
t = { }

cria uma tabela vazia e a armazena na varivel de nome t. A partir deste ponto, a varivel t armazena um valor do tipo table e pode ento ser indexada. vlido escrever, por exemplo:
t[1] = 13 t[45] = 56

Observa-se que no h limite para a indexao da tabela. Se necessrio, Lua automaticamente redimensiona a tabela. Alm disso, tambm vlido escrever:
t["nome"] = t[1] + 2

Isto , a tabela t indexada pela valor cadeia de caracateres nome recebe o valor armazenado na tabela t indexada pelo valor 1 (que 13) somado com o valor 2. Isto , t indexado por "nome" vale 15. Tambm seria vlido escrever
t[t] = 5

que significa que a tabela t indexada pelo valor de t (que a prpria tabela) armazena o valor numrico 5. (Parece confuso, mas vlido!) Quando indexamos uma tabela por uma cadeia de caracteres, podemos usar uma notao com ponto (.). Por exemplo, escrever:
t["versao"] = 3.1

equivalente a escrever:

20

t.versao = 3.1

Esta notao mais clara; seu uso recomendado sempre que possvel. Se a cadeia de caracteres for um nome composto, esta simplificao no possvel. Por exemplo:
t["Rio de Janeiro"] = 1994

no tem equivalncia com uso de ponto para indexao. Da mesma forma que armazenamos valores numricos em tabelas, poderamos ter armazenado outros valores. Todas as atribuies abaixo so vlidas para a tabela t:
t[10] = "exemplificando" t[2.34] = 12 t.tabela, t[0] = 3, 12 t[-234] = 0 a = "Lua" t[a] = 5

Esta ltima atribuio merece uma anlise cuidadosa. Considerando que a uma varivel que armazena o valor Lua, a ltima atribuio armazena 5 no campo (ou ndice) Lua da tabela. Escrever t[a] diferente de t.a, que equivalente a t["a"]! Assim, no exemplo, t[a] equivalente a t.Lua. O valor de uma tabela para qualquer ndice cuja indexao ainda no foi inicializada nil. Assim, considerando somente as atribuies acima, o comando
print(t[999])

imprimir o valor nil, pois o campo 999 de t no foi inicializado. possvel armazenarmos outras tabelas em tabelas, criando conjuntos multidimensionais. Por exemplo:
m = { } m[1] = { } m[2] = { } m[1][1] = 1.0 m[2][1] = 0.0

Tambm vlido escrever:

21

s = { } s.dados = { } s.dados.nome = "Linguagem Lua" s.dados.versao = 3.0

Inicializao de tabelas via indexao consecutiva

Lua permite inicializao de tabelas na criao. Esta seo discute a inicializao de

tabelas por indexao. Uma forma possvel para inicializao de tabelas

{ expr1, expr2, ..., exprN }

Isto , escreve-se uma lista de expresses entre as chaves que criam a tabela. Cada expresso listada avaliada e seu valor armazenado no ndice correspondente: o valor da primeira expresso armazenado no ndice 1 da tabela, o valor da segunda expresso no ndice 2, e assim por diante. Portanto, a inicializao abaixo:
t = {23, 45, -7, "Lua", 6+4}

equivalente a
t = { } t[1] = 23 t[2] = 45 t[3] = -7 t[4] = "Lua" t[5] = 6+4

Aps a inicializao, a tabela criada pode armazenar outros valores. Isto , continua sendo possvel armazenar qualquer valor indexado por qualquer valor (exceto nil). Assim, seria possvel, aps a inicializao, ter:
t[67] = 0 t["Lua"] = "exemplo"

Inicializao de tabelas via atribuio de campos

Alm da forma de inicializao mostrada na seo anterior, Lua permite a inicializao de campos da tabela. A forma geral :
{ [exprA] = expr1, [exprB] = expr2, ... }

Isto , na criao de tabelas pode-se inicializar qualquer tipo de campo que uma tabela pode armazenar. Se o ndice do campo da tabela for uma string, o par de valores pode ser escrito simplesmente

22

string1 = expr1

Assim, o comando
t = { nome = "Linguagem Lua", [1] = 3.0, [f(x)] = g(y) }

equivalente a
t = { } t.nome = "Linguagem Lua" t[1] = 3.0 t.[f(x)] = g(y)

Mais uma vez, continua sendo possvel armazenar qualquer valor indexado por qualquer valor (exceto nil). Assim, seria possvel, aps a inicializao, ter:
t[67] = 0 t["Lua"] = "exemplo"

Inicializao mista
Lua permite combinar as duas formas de inicializao mostradas nas sees

anteriores. A forma geral :

tabela = { lista-de-expresses ; lista-de-atribuies-de-campos }

Assim, a lista de expresses de uma inicializao por indexao consecutiva pode vir seguida do caractere ponto e vrgula (;) e da lista de atribuies de campos por nomes. Portanto, escrever:
t = {23, 45, -7 ; nome="Linguagem Lua", versao=3.0, [4]=80 }

equivalente a:
t = { } t[1] = 23 t[2] = 45 t[3] = -7 t.nome = "Linguagem Lua" t.versao = 3.0 t[4] = 80

23

9. Tratamento de erros Todos os erros que podem ser gerados em Lua so "bem comportados" e podem ser controlados pelo programador. Quando ocorre um erro na compilao ou execuo de cdigos Lua, a funo cadastrada como error method executada e a a funo da biblioteca Lua responsvel pela execuo do trecho (lua_dofile, lua_dostring, lua_dobuffer ou lua_callfunction) cancelada, retornando uma condio de erro.
Lua passa para a funo de error method um nico parmetro que a cadeia de

caracteres que descreve o erro ocorrido. A funo default para error method simplesmente imprime essa cadeia de caracteres na sada padro de erro (stderr). possvel mudar a funo de error method atravs da funo seterrormethod (veja seo 10). A biblioteca padro de Lua para funes de entrada e sada usa essa facilidade para redefinir a funo de tratamento de erros de forma a exibir algumas informaes adicionais, como a pilha de chamada de funes de Lua. Para se ter uma descrio completa dos erros de execuo, incluindo a pilha de chamada de funes, deve-se incluir o pragma $debug no cdigo Lua. Este pragma deve ser escrito na primeira coluna de uma linha do mdulo.

24

10. Funes pr-definidas Existem algumas funes pr-definidas que esto sempre disponveis para programas Lua. O conjunto de funes pr-definidas em Lua pequeno, mas prov poderosos recursos de programao. Como ser discutido, estas funes possibilitam escrever funes para gerar cdigos Lua que, se executados, restauram o ambiente de execuo. Isto significa que objetos em Lua podem persistir entre diferentes sesses de execuo.
dofile( filename )

DESCRIO Esta funo recebe como parmetro o nome de um arquivo (filename), compila e executa seu contedo como um mdulo da linguagem Lua. ARGUMENTOS
filename

arquivo a ser executado

RETORNO Retorna os valores retornados pelo mdulo se a execuo for bem sucedida ou nil se ocorrer erro. EXEMPLO
if not dofile("bib.lua") then print("No possvel abrir a biblioteca de funes") end

OBSERVAES Controlar o cdigo de retorno da funo pode ser til para controlar erros que ocorrem em tempo de execuo.
dostring( string [, name ] )

DESCRIO Esta funo recebe como parmetro um valor do tipo string, compila e executa seu contedo como um mdulo da linguagem Lua. ARGUMENTOS
string name

string a ser executada opcional; usado em mensagens de erro.

25

RETORNO Retorna os valores retornados pelo cdigo se a execuo for bem sucedida ou nil se ocorrer erro. EXEMPLO Esse exemplo transfere valores armazenados em variveis da forma botaox (onde x um nmero inteiro) para a tabela botao:
i = 1; botao = {} b = dostring("return botao"..i ) while b do botao[i] = b i = i + 1 b = dostring("return botao"..i ) end

next( table, index )

DESCRIO Fornece um elemento da tabela table o prximo em relao ao elemento de ndice index. Esta funo permite enumerar todos os campos de uma tabela. O primeiro argumento da funo uma varivel que armazena um valor do tipo table; o segundo argumento uma varivel que armazena um dos valores que indexa esta tabela. Este ndice pode ser de qualquer tipo, j que uma tabela pode ser indexada por um valor de qualquer tipo (exceto nil). Quando a funo next chamada passando-se como segundo argumento o valor nil, retorna-se um primeiro ndice da tabela e seu respectivo valor associado. ARGUMENTOS
table index

tabela Lua a ser examinada ndice da tabela considerado como referncia; nil para comear.

RETORNO A funo retorna dois valores: o ndice na tabela correspondente ao prximo elemento e o valor associado a esse ndice. Se no existir o prximo elemento, a funo retorna nil. EXEMPLO O trecho de cdigo abaixo imprime todos os ndices e valores associados de uma dada tabela t:

26

campo,valor = next(t, nil) while campo do print(campo, "=", valor) campo,valor = next(t, campo) end

captura primeiro campo da tabela enquanto existir campo imprime valores captura prximo campo da tabela

OBSERVAES Em Lua, os campos (ndices) de uma tabela no precisam ser criados; eles so incorporados na tabela medida em que so atribudos. Para um campo ainda no atribudo, assume-se o valor nil. Portanto, no h diferena semntica entre campos realmente inexistentes na tabela e campos que armazenam o valor nil. Por isso, a funo next apenas considera campos que armazenam valores diferentes de nil. A ordem em que os ndices aparecem no especificada.
nextvar( name )

DESCRIO Esta funo permite enumerar todas as variveis globais cujo valor seja diferente de nil. A funo recebe um nico parmetro que representa o nome de uma varivel global. No caso de ser passado o valor nil para a funo, retorna-se o nome e o valor de uma primeira varivel global. A funo sempre retorna dois valores: nome da varivel e valor armazenado. O nome retornado por uma chamada da funco pode ser usado para acessar uma prxima varivel global, de modo similar funo next. A ordem que as variveis so retornadas no especificada. ARGUMENTOS
name

nome da varivel a ser pesquisada

EXEMPLO O trecho de cdigo abaixo imprime os nomes e valores de todas as variveis globais:
nome,valor = nextvar(nil) while nome do print(nome, "=", valor) nome,valor = nextvar(nome) end captura primeira varivel global enquanto existir varivel imprime valores captura prxima varivel global

type( value )

DESCRIO Esta funo recebe como parmetro uma expresso e informa o seu tipo. ARGUMENTOS
value

expresso a ser pesquisada

27

RETORNO Retorna uma string que descreve o tipo do valor resultante: "nil", "number", "string", "table", "function", ou "userdata". EXEMPLO O comando abaixo:
t = {} print(type(2.4),type("Alo"),type(t),type(t[1]),type(print))

tem como sada:

number string table nil function

tonumber( e [,base] )

DESCRIO Esta funo recebe um argumento e tenta convert-lo para um valor numrico. ARGUMENTOS
e

expresso a ser transformada em valor numrico

RETORNO Se o argumento j for um valor numrico ou se for uma string para a qual possvel fazer a converso, a funo retorna o valor numrico correspondente. Se o converso no for possvel, retorna-se nil. EXEMPLO O comando:
print(tonumber("34.56 "), tonumber("3.2 X"), tonumber(2))

imprime os valores:
34.56 nil 2

tostring( e )

DESCRIO Esta funo recebe um argumento e o converte para uma string.

28

ARGUMENTOS
e

expresso a ser transformada em string

RETORNO Retorna a string correspondente. EXEMPLO O comando:

print(tostring(3.2), tostring({10,20,30}), tostring(print))

imprime os valores: 3.2 table: 0x324a43 function: 0x63ed21

print( expr1, expr2, ... )

DESCRIO Recebe uma lista de expresses e imprime seus resultados no dispositivo de sada padro. ARGUMENTOS expr1, expr2, expresses a serem impressas RETORNO Nenhum. EXEMPLO
print( 2*3+2 ) print( "valor = ", valor )

OBSERVAES Esta funo no permite sadas formatadas, mas de grande utilidade para consulta de valores, impresso de mensagens de erro e para teste e depurao de programas. Para formatao, use format.
error( msg )

DESCRIO Esta funo gera uma condio de erro de execuo, finalizando a funo chamada de C (lua_dofile, lua_dostring, ...). Esta funo recebe uma cadeia de caracteres para descrever o erro ocorrido.

29

ARGUMENTOS
msg

texto descritor do erro

RETORNO Nenhum. OBSERVAES A funo interrompe a execuo do programa; ela nunca retorna.
call( func, arg [,retmode] )

DESCRIO Chama a funo func com os argumentos contidos na tabela arg, percorrendo sequencialmente os ndices numricos at o ndice arg.n. Se arg.n no for definido, ento a lista de argumentos considerada terminada ao ser encontrado o primeiro elemento de arg com valor nil. ARGUMENTOS
func arg retmode

funo a ser chamada tabela contendo todos os argumentos para a funo opcional; s o valor "pack" admitido

RETORNO Retorna todos os valores que a funo func retornar. Se o argumento retmode tiver recebido o valor "pack", ento o retorno uma tabela contendo os valores resultantes nos ndices inteiros e o nmero total de resultados no ndice n. EXEMPLO Considere as seguintes chamadas:
a a t a = = = = call( call( { x=1 call( sin, {5} ) max, {1,4,5;n=2}) } next,{t,nil;n=2},"pack" ) a = 0.871557 a=4 a={"x",1;n=2}

assert( value [,message] )

DESCRIO Certifica que a o valor value diferente de nil. Gera um erro Lua com a mensagem assertion failed seguido possivelmente de message, se value for igual nil. ARGUMENTOS
value

valor a ser testado

RETORNO Nenhum.

30

EXEMPLO
assert( readfrom(FILE),"cannot open" .. FILE )

31

11. Bibliotecas de funes Existem trs bibliotecas j implementadas provendo funes C que podem ser acessadas de Lua: manipulao de strings, funes matemticas e funes de entrada e sada. Estas bibliotecas so distribudas com a biblioteca bsica da linguagem.
Biblioteca de manipulao de strings

Esta biblioteca prov funes genricas para manipulao de cadeias de caracteres, tais como determinar o nmero de caracteres de uma string e capturar ou localizar uma substring.
strfind( str, pattern [, init [, plain ]] )

DESCRIO Procura um padro dentro de uma cadeia de caracteres. A busca feita na cadeia str, procurando o padro pattern a partir do caracter init (opcional). Se no for especificado o parmetro init, a busca feita na cadeia toda. Caso o parmetro plain (opcional) seja diferente de nil, no utilizado pattern matching, e nesse caso feita uma busca simples de subcadeia ARGUMENTOS
str pattern init plain

cadeia de caracteres na qual ser feita a busca padro procurado opcional; ndice de str para o incio da busca opcional; indica se deve ser usado pattern matching ou no.

RETORNO So retornados os ndices inicial e final da primeira ocorrncia do padro na cadeia str. Caso str no contenha o padro, retorna nil. Se o padro for encontrado e este contiver capturas, retornado um valor a mais para cada captura. EXEMPLO O cdigo
i, f = strfind("Linguagem Lua 3.0", "Lua") print( i, f )

imprime os valores 11 e 13, correspondentes posio da subcadeia Lua na cadeia pesquisada. O cdigo abaixo utiliza capturas para extrair informaes de uma string:

32

data = "13/4/1997" i, f, dia, mes, ano = strfind(data, "(%d*)/(%d*)/(%d*)") print( dia, mes, ano )

Este cdigo imprime os valores 13, 4, e 1997. OBSERVAES Padres operam sobre classes de caracteres, que so conjuntos de caracteres. A tabela abaixo lista as classes que podem ser utilizadas para compor os padres:
x %x . %a %A %d %D %l %L %s %S %u %U %w %W [char-set] [^char-set]

o prprio caracter x, exceto ()%.[*-? (x um caracter no alfanumrico) representa o caracter x qualquer caracter Letras tudo exceto letras Dgitos decimais tudo exceto dgitos letras minsculas tudo exceto letras minsculas caracteres brancos (espaos, tabs, quebras de linha) tudo exceto caracteres brancos letras maisculas tudo exceto letras maisculas caracteres alfanumricos tudo exceto caracteres alfanumricos unio de todos os caracteres de char-set complemento de char-set

Um item de um padro pode ser: uma classe de caracteres, que casa com qualquer caracter da classe; uma classe de caracteres seguida de *, que casa com 0 ou mais repeties dos caracteres da classe. O casamento sempre feito com a sequncia mais longa possvel; uma classe de caracteres seguida de -, que casa com 0 ou mais repeties dos caracteres da classe. Ao contrrio do *, o casamento sempre feito com a sequncia mais curta possvel; uma classe de caracteres seguida de ?, que casa com 0 ou 1 ocorrncia de um caracter da classe;
%n, para n entre 1 e 9; este item casa com a substring igual n-sima string

capturada (ver abaixo);

33

%bxy, onde x e y so dois caracteres diferentes; este item casa com strings que comeam com x e terminam com y, onde x e y so balanceados. Por exemplo, o item %b() casa com expresses com parnteses balanceados.

Um padro uma sequncia de itens de padro. O caracter ^ no incio do padro obriga o casamento no incio da string procurada. Um $ no final do padro obriga o casamento no final da string. Um padro pode conter sub-padres entre parnteses, que descrevem capturas. Quando o casamento feito, as substrings que casam com as capturas so guardados (capturados) para uso futuro. As capturas so numeradas da esquerda para a direita. Por exemplo, no padro "(a*(.)%w(%s*))", a parte da string que casa com a*(.)%w(%s*) armazenada como a primeira captura (nmero 1); o caracter que casou com . capturado com o nmero 2 e a parte %s* tem nmero 3. EXEMPLO O cdigo
function name (arg1,arg2) (function %s*(%a%a*)(%b())) captura as seguintes strings: declaraes de funes Lua ; nome da funo (%a%a*); captura lista de parmteros (%b()).

strlen( str )

DESCRIO Informa o tamanho de uma string. ARGUMENTOS

str

string a ser medida

RETORNO Retorna o nmero de caracteres presentes na cadeia de caracteres. EXEMPLO O cdigo

print(strlen("Linguagem Lua"))

imprime o valor 13.

strsub( str, I [, j ] )

DESCRIO Cria uma cadeia de caracteres que uma subcadeia de str, comeando na posio i e indo at a posio j (inclusive). Se i ou j tiverem valor negativo, eles so considerados relativos ao final de str. Assim, -1 aponta para o ltimo caracter de

34

str e 2 para o penltimo, etc. Se j no for especificado, considerado como sendo equivalente posio do ltimo caracter. Como particularidade, strsub(str,1,j) retorna um prefixo de str com j caracteres; e strsub(str,i) retorna um sufixo de str comeando na posio i.

ARGUMENTOS
str i j

string de onde vai ser extrada a substring posio de incio da substring opcional; posio de trmino da substring

RETORNO Retorna a subcadeia. EXEMPLO O cdigo:

a = "Linguagem Lua" print(strsub(a, 11))

imprime a string Lua.

strlower( str )

DESCRIO Cria uma cpia da cadeia passada como parmetro, onde todas as letras maisculas so trocadas pelas minsculas correspondentes; os demais caracteres permanecem inalterados. ARGUMENTOS
str

string a ser transformada

RETORNO Retorna a string resultante. EXEMPLO O cdigo

print(strlower("Linguagem Lua"))

tem como sada a cadeia linguagem lua.

strupper( str )

DESCRIO Cria uma cpia da cadeia passada como parmetro, onde todas as letras minsculas so trocadas pelas maisculas correspondentes; os demais caracteres permanecem inalterados.

35

ARGUMENTOS
str

string a ser transformada

RETORNO Retorna a cadeia resultante. EXEMPLO O cdigo

print(strupper("Linguagem Lua"))

tem como sada a cadeia LINGUAGEM LUA.

strrep( str, n )

DESCRIO Cria uma string que a concatenao de n cpias da string str. ARGUMENTOS
str

string a ser replicada

RETORNO Retorna a string criada. EXEMPLO O cdigo

print(strrep( "0123456789", 2 ))

tem como sada

01234567890123456789

ascii( str [, I] )

DESCRIO Informa o cdigo ASCII do caracter str[i]. ARGUMENTOS

str i

string a ser consultada opcional; posio do caracter na string str

RETORNO Retorna o cdigo correspondente. EXEMPLO O cdigo

36

print(ascii("abc",2))

tem como sada 42.

format( formatstring, exp1, exp2, )

DESCRIO Cria uma string com expresses exp1, exp2 etc. formatadas de acordo com formatstring. Cada expresso deve ter um cdigo embutido em formatstring, que espeficica como a formatao feita. Os cdigos consistem do caracter % seguido de uma letra que denota o tipo da expresso sendo formatada. ARGUMENTOS
formatstring formato a ser usado exp1, exp2, ... expresses a serem formatadas

RETORNO Retorna uma string no formato formatstring, com os cdigos substitudos pelas expresses correspondentes. EXEMPLO O cdigo abaixo:
nome = "Carla" id = 123 cmd = format( "insert into tabela (nome, id) values (%s, %d)" , nome, id )

cria uma string com um comando SQL para insero dos valores da variveis nome e id em uma tabela. J o cdigo abaixo:
print( format( "%c", 65 ) )

mostra como a funo pode ser usada para converter um cdigo ASCII nmerico no caracter correspondente; nesse caso resultando na impresso do caracter A. O exemplo abaixo mostra o uso de modificadores:
a = 123.456 print( format( "%+010.2f", a ) )

imprime +000123.46. OBSERVAES A tabela abaixo lista os tipos aceitos no formato. Os tipos %s e %q aceitam como valor uma string, enquanto que os outros aceitam um nmero.
%s %q %c

String string com delimitadores, num formato que possa ser lido por Lua caracter

37

%d %i %u %o %x %X %f %e %g %E %%

inteiro com sinal igual a %d inteiro sem sinal inteiro octal hexadecimal usando letras minsculas (abcdef) hexadecimal usando letras maisculas (ABCDEF) real no formato [-]ddd.ddd real no formato [-]d.ddd e[+/-]ddd real na forma %f ou %e igual a %e, usando o caracter E para o expoente no lugar de e caracter %

A formatao de cada um dos tipos pode ser alterada incluindo-se modificadores entre os dois caracteres. Um nmero define o tamanho mnimo que o campo ocupa (ex: %10d). Um nmero seguido de um ponto define a preciso do campo (ex: %.2f). Um sinal de - aps o % significa que o campo deve ser alinhado pela esquerda, dentro do tamanho do campo. Um sinal de + faz com que seja mostrado este sinal caso o valor correspondente seja positivo. O caracter 0 faz com que o nmero seja preenchido com zeros esquerda para completar o tamanho mnimo.
gsub( str, pattern, repl [, n ] )

DESCRIO Procura e substitui padres em uma cadeia de caracteres. O padro pattern procurado na string str. Cada padro encontrado substitudo por repl, que pode ser uma string ou uma funo. Caso repl seja uma funo, o padro encontrado substitudo pelo resultado da execuo da funo repl. As substituies so feitas para cada ocorrncia do padro pattern, a no ser que seja especificado o parmetro n, que define o nmero mximo de substituies a serem feitas. Se o padro especifica capturas, estas podem ser usadas na string repl na forma %1, %2 etc; se repl for uma funo, as capturas so passadas como parmetro para a funo. A descrio do padro a mesma utilizada pela funo strfind. ARGUMENTOS str string onde ser feita a busca pattern padro a ser procurado e substitudo repl string para substituir cada padro encontrado (ou funo) table opcional; parmetro a ser passado a repl quando este uma funo n opcional; nmero mximo de substituies a serem feitas RETORNO Retorna a string str com todas as substituies feitas. Em particular, se o padro no for encontrado, o resultado ser a prpria string str. EXEMPLO O cdigo

38

print( gsub( "Linguagem Lua 3.0", " ", "+" ) )

imprime Linguagem+Lua+3.0. O cdigo

texto = " Linguagem print( gsub( texto, " Lua *", " " ) ) 3.0 "

substitui toda sequncia de um ou mais brancos por um nico branco, imprimindo "Linguagem Lua 3.0 ". Capturas tambm podem ser utilizadas com a funo gsub:
lista = [[ arq.txt texto.txt r.txt ]] print( gsub( lista, "(.*)%.txt\n", "move %1.txt %1.bak\n" ))

imprime:
move arq.txt arq.bak move texto.txt texto.bak move r.txt r.bak

Biblioteca de funes matemticas

Existem implementadas funes para retornar o valor mximo ou mnimo de uma srie de expresses. As funes recebem uma lista varivel de parmetros. A forma geral das funes :
min( expr1, expr2, ..., exprN) max( expr1, expr2, ..., exprN)

Assim, o cdigo abaixo:

print(min(23, 5, 123, 3)) print(max(23, 5, 123, 3))

imprime os valores 3 e 123. Existem ainda funes que implementam as funcionalidades de funes homnimas da biblioteca padro da linguagem C. So elas:

39

log(value) log10(value) cos(angle) sin(angle) tan (angle) acos(value) asin(value) atan(value) atan2(y,x) deg(angle) rad(angle) abs(value) sqrt(value) ceil(value) floor(value) mod(value,div)

logaritmo de value na base e logaritmo de value da base 10 cosseno de angle (especificado em graus) seno de angle (especificado em graus) tangente de angle (especificado em graus) arco cosseno, em graus, de value arco seno, em graus, de value arco tangente, em graus, de value arco tangente, em graus, de y/x converte angle (especificado em radianos) para graus converte angle (especificado em graus) para radianos valor absoluto de value raiz quadrada de value inteiro imediatamente inferior a value inteiro imediatamente superior a value resto da diviso inteira de value por div

Biblioteca de funes de entrada e sada

Esta biblioteca implementa funes adicionais para execuo de operaes de entrada e sada. Todas as operaes de entrada e sada desta biblioteca so feitas em dois arquivos correntes, um de entrada (_INPUT) e um de sada (_OUTPUT). Os dispositivos padres da linguagem C: stdin, stdout e stderr esto disponveis atravs das variveis globais _STDIN, _STDOUT e _STDERR. Inicialmente, _INPUT tem o mesmo valor de _STDIN e _OUTPUT tem o mesmo valor que _STDOUT.
readfrom( filename )

DESCRIO Abre ou fecha um arquivo para leitura. Se o parmetro for uma string, a funo abre o arquivo nomeado filename, colocando-o como arquivo de entrada corrente, e retorna uma referncia para o arquivo aberto. Se a funo for chamada sem parmetros, o arquivo de entrada corrente fechado e a entrada padro restaurada como arquivo de entrada corrente. ARGUMENTOS
filename

nome do arquivo a ser aberto

RETORNO Retorna uma referncia para o arquivo aberto (userdata com o FILE* de C). Em caso de erro, retorna nil e uma string descrevendo o erro.

40

EXEMPLO
readfrom( "c:\\txt\\b.txt" )

writeto( [filename ])

DESCRIO Abre ou fecha um arquivo para escrita. Se o parmetro for uma string, a funo cria um arquivo nomeado filename, colocando-o como arquivo de sada corrente, e retorna uma referncia para o arquivo aberto (caso j exista um arquivo com este nome, o seu contedo perdido). Se a funo for chamada sem parmetros, o arquivo de sada corrente fechado e a sada padro definida novamente como arquivo de sada corrente. ARGUMENTOS
filename

nome do arquivo a ser aberto

RETORNO Retorna uma referncia para o arquivo aberto (userdata com o FILE* de C). Em caso de erro, retorna nil e uma string descrevendo o erro. EXEMPLO O cdigo abaixo:
if writeto( "a.txt") then write( "contedo do arquivo" ) writeto() end

cria o arquivo a.txt, escrevendo a string contedo do arquivo nele.

appendto( [filename] )

DESCRIO Abre um arquivo para escrita nomeado filename e o define como arquivo de sada corrente. Ao contrrio da funo writeto, caso j exista um arquivo com este nome o seu contedo no perdido; novas escritas so acrescentadas aos dados j existentes. Quando chamada sem parmetros, tem o mesmo comportamento da funo writeto: fecha o arquivo de sada corrente e restaura a sada padro como corrente. ARGUMENTOS
filename

nome do arquivo a ser aberto

RETORNO Retorna uma referncia para o arquivo aberto (userdata com o FILE* de C). Em caso de erro, retorna nil e uma string descrevendo o erro.

41

EXEMPLO O cdigo
if appendto( "a.txt") then write( "contedo do arquivo" ) appendto() end

acrescenta a string contedo do arquivo no arquivo a.txt.

read( [readpattern] )

DESCRIO L uma string do arquivo de entrada corrente (_INPUT) de acordo com o padro readpattern. O arquivo lido at que o padro termine ou falhe. A funo retorna os caracteres lidos, mesmo que o padro no tenha sido completamente lido. Quando chamada sem parmetros, usado o padro [^\n]*{\n}, que l uma linha do arquivo. A descrio do padro a mesma utilizada pela funo strfind (mas com comportamento um pouco diferente, ver observaes). ARGUMENTOS
readpattern

padro a ser lido

RETORNO Retorna uma string com o contedo do arquivo que casou com o padro readpattern (mesmo parcialmente) ou nil se os dados do arquivo no casaram com nada do padro (ou se o arquivo chegou ao fim). EXEMPLO O codigo
data = {} i = 1 readfrom( "datas.txt" ) repeat data[i] = read( "%d/%d/%d{\n}" ) i = i + 1 until data == nil readfrom()

l todas as datas contidas no arquivo datas.txt, colocando-as na tabela data. OBSERVAES O padro pode conter sub-padres entre chaves, que definem skips. Os skips so lidos do arquivo mas no so includos na string resultante. O comportamento dos padres usados nesta funo diferente do pattern matching regular, onde um * expande para o maior comprimento tal que o resto do padro no falhe. Nesta funo, uma classe de caracteres seguida de * l o arquivo at encontrar um caracter que no pertence classe, ou at final do arquivo.

42

write( value1, value2, ...)

DESCRIO Recebe uma lista de valores e os escreve no arquivo de sada corrente (_OUTPUT). Os valores devem ser nmeros ou strings. Diferentemente da funo print, no gerada uma quebra de linha aps cada valor escrito. ARGUMENTOS
value1, value2,

valores a serem escritos

RETORNO Nenhum. EXEMPLO

write( a = , a )

remove( filename )

DESCRIO Apaga o arquivo nomeado filename. ARGUMENTOS

filename

path fsico do arquivo a ser apagado.

RETORNO Se a funo no conseguir apagar o arquivo, ela retorna nil e uma string descrevendo o erro. EXEMPLO O cdigo
a, error = remove( "c:\doc\arq.txt" ) if not a then print( error ) end

tenta apagar o arquivo c:\doc\arq.txt. Em caso de erro, impressa uma mensagem explicando a causa.
rename( name1, name2 )

DESCRIO Renomeia o arquivo nomeado name1 para name2. ARGUMENTOS

name1 name2

nome do arquivo a ser renomeado novo nome do arquivo

43

RETORNO Se a funo no conseguir renomear o arquivo, ela retorna nil e uma string descrevendo o erro. EXEMPLO O cdigo
a, error = rename( "arq.txt", "arquivo.txt" ) if not a then print( error ) end

tenta renomear o arquivo arq.txt para arquivo.txt. Em caso de erro, impressa uma mensagem explicando a causa.
tmpname( )

DESCRIO Obtem um nome de arquivo que pode ser usado para criar um arquivo temporrio. O arquivo precisa ser explicitamente apagado quando no for mais necessrio. ARGUMENTOS Nenhum. RETORNO Retorna uma string com o nome do arquivo. EXEMPLO O cdigo
filename = tmpname() writeto( filename )

cria um arquivo temporrio para escrita.

date( [format] )

DESCRIO Consulta a data atual, retornando-a formatada de acordo com o parmetro format (opcional). O formato uma string com cdigos na forma %c, que especificam os componentes da data (ms, dia, ano, hora etc.). A funco retorna a string format com os cdigos substitudos pelos valores correspondentes data no momento da chamada. O formato usado quando o parmetro no especificado dependente do sistema. ARGUMENTOS
format

opcional; descrio de como a data deve ser formatada

44

RETORNO Uma string com a data atual. EXEMPLO O cdigo

print( date( "hoje dia %d do ms %B" ) )

imprime a string hoje dia 14 do ms Agosto (considerando a execuo no dia 14/8 em um sistema que utiliza a lngua portuguesa). OBSERVAES A tabela abaixo lista os cdigos aceitos no formato:
%a %A %b %B %c %d %H %I %j %m %M %P %S %U %w %W %x %X %y %Y %z %%

nome do dia da semana, abreviado nome do dia da semana, completo nome do ms, abreviado nome do ms, completo data e hora, no formato usado pelo sistema dia do ms, de 01 a 31 hora, de 00 a 23 hora, de 01 a 12 dia do ano, de 001 a 366 nmero do ms, de 01 a 12 minuto, de 00 a 59 indicao am/pm segundo, de 00 a 60 semana do ano (considerando domingo como o primeiro dia da semana),do dia da semana, de 0 a 6 (0 domingo) nmero de 00 a 53 semana do ano (considerando segunda-feira como o primeiro dia da semana), de 00 a usado pelo sistema data no formato 53 hora no formato usado pelo sistema ano sem o sculo, de 00 a 99 ano (completo) com o sculo time zone caracter %

exit( [code] )

DESCRIO Termina a execuo do programa, retornando code a quem o executou. Caso o parmetro code no seja especificado, usado o valor 1. ARGUMENTOS
code

opcional; o cdigo a ser retornado

RETORNO Esta funo no retorna.

45

EXEMPLO O cdigo
if termina_programa then exit() end

termina a execuo do programa caso a varivel termina_programa contenha um valor diferente de nil..
getenv( varname )

DESCRIO Consulta o valor da varivel de ambiente nomeada varname. ARGUMENTOS

varname

nome da varivel a ser consultada.

RETORNO Retorna uma string com o valor da varivel varname, ou nil se esta no estiver definida. EXEMPLO O cdigo
print( getenv( "REMOTE_HOST" ) )

imprime o valor da varivel de ambiente REMOTE_HOST.

execute( command )

DESCRIO Executa o comando command no sistema operacional. ARGUMENTOS

command

comando a ser executado

RETORNO O valor de retorno desta funo dependente do sistema operacional. Normalmente um valor retornado pelo comando executado. EXEMPLO O cdigo
execute( "mkdir c:\data" )

executa um comando no sistema operacional para criar o diretrio c:\data.

46

Apndice. Relevncia de Lua Um dos aspectos mais marcantes de Lua sua dualidade acadmico-industrial. No aspecto industrial, Lua vem sendo usada em dezenas de produtos, desenvolvidos tanto na PUC-Rio quanto fora, inclusive no exterior. No aspecto acadmico, Lua deu origem e influenciou diversos trabalhos, refletidos em dezenas de dissertaes, teses, e publicaes.

Relevncia Tecnolgica
Lua vem sendo disponibilizada na Internet desde fevereiro de 1994. Esse fato, aliado qualidade da linguagem, vem tornando Lua uma linguagem amplamente utilizada

em diversos tipos de aplicao, tanto no Brasil quanto no exterior. Abaixo relatamos alguns usos de Lua em produtos tecnolgicos. Essa lista est longe de ser exaustiva, e procura apenas exemplificar a diversidade de projetos industriais em que Lua vem sendo utilizada. importante frizar que, devido distribuio pela Internet, os prprios autores no tem controle do nmero total de usurios ou produtos/prottipos que utilizam a linguagem.
TeCGraf

O TeCGraf uma parceria entre a PUC-Rio e o Centro de Pesquisas da PETROBRS (CENPES) com o objetivo de desenvolver, implantar e manter software de computao grfica e de interface com o usurio para aplicaes tcnicocientficas. Como a linguagem Lua foi desenvolvida no TeCGraf, bastante natural que o grupo tenha adotado Lua em diversos projetos. Atualmente, mais de vinte pessoas programam regularmente em Lua no TeCGraf, e em torno de mais dez pessoas usam Lua eventualmente. No total, os diversos sistemas produzidos no TeCGraf com tecnologia Lua incluem mais de cem mil linhas de cdigo Lua, em dezenas de produtos finais. O artigo da Software: Practice & Experience tambm descreve algumas aplicae de Lua no TeCGraf. (Maiores informaes sobre o TeCGraf e seus produtos podem ser obtidas em http://www.tecgraf.pucrio.br/publico/prodtec.html.)
Sistema RPA@PUC

O RPA@PUC (Rede de Perfis Acadmicos da PUC-Rio) um sistema Intranet desenvolvido pela Vice-Reitoria Acadmica da PUC-Rio, para acompanhamento da produo acadmica do corpo docente da Universidade. Para suportar mais de cinquenta diferentes tipos de produo (Artigos de Peridicos, Captulos de

47

Livros, Resenhas, Tradues e Verses, Material Didtico e Instrucional, Participao em Bancas, etc.) o sistema utiliza tabelas Lua para descrio abstrata de cada tipo de item. Baseados nessas tabelas, programas escritos em Lua so acionados, atravs do protocolo CGI, para gerar dinamicamente formulrios, relatrios, crtica de dados, e outros documentos WWW. Com isso, a incluso ou alterao de um tipo de produo implica apenas em modificaes na descrio abstrata de itens, sem envolver nenhum tipo de programao. Atualmente, o sistema est sendo usado regularmente por aproximadamente cento e cinquenta docentes e funcionrios de oito Departamentos da PUC-Rio, e em breve dever estar sendo usado por toda a Universidade. (Outras informaes sobre o projeto RPA@PUC podem ser obtidas em http://www.inf.puc-rio.br/~info-rpa/projeto/). Um sistema semelhante est sendo usado para manuteno do site do PESC (Programa de Engenharia de Sistemas e Computao) da COPPE/UFRJ (maiores informaes em http://www.cos.ufrj.br/equipe/webmaster.html).
Medialab

A Medialab, empresa responsvel pelos sites brasileiros na Internet de empresas como Shell e Microsoft, tem usado Lua na construo de diversas pginas dinmicas (protocolo CGI). Ao todo, mais de dez sites j esto em funcionamento com partes dinmicas escritas em Lua, entre eles o sistema de busca de endereos e telefones da Volkswagen do Brasil (http://www.volkswagen.com.br/indbusca.htm) e o sistema de busca do Guia de Restaurantes Danusia Brbara (http://www.brazilweb.com/rio/).4
Non-Linear Control Consultants Ltd

O uso de Lua relatado abaixo de Mark Ian Barlow, que trabalha na empresa NonLinear Control Consultants Ltd., na Inglaterra. Em uma mensagem, ele relata seu primeiro contato com a linguagem; aparentemente, ele soube de Lua atravs do artigo na Dr. Dobbs:

Os URLs fornecidos no so de pginas criadas com Lua, mas sim pginas estticas que acessam as pginas dinmicas criadas com a linguagem. O uso de Lua pode ser conferido, se necessrio, vendo-se as fontes dessas pginas, onde as aes de botes referem-se a roteiros Lua (terminao .lua via programa CGILua). Maiores informaes sobre a biblioteca CGILua podem ser obtidas em http://www.tecgraf.pucrio.br/manuais/cgilua.
4

48

From Mark@nlcc.demon.co.uk Mon Jan 13 12:59:13 1997 Date: Mon, 13 Jan 1997 01:24:47 GMT From: Mark@nlcc.demon.co.uk (Mark Ian Barlow) Reply-To: Mark@nlcc.demon.co.uk Message-Id: !532@nlcc.demon.co.uk? To: lua@icad.puc-rio.br Subject: Thanks! Hi, For some time now I've been looking for a portable, compact interpreted or incrementally compiled language to use in various robotic applications. [] I think lua is going to be just what I need! Writing to hardware is of course simple with CFunctions, but the debug interface (omitted from almost all the embedded languages I've seen before) allows me to arrange for incoming data to appear "magically" in reserved global variables. [] Thanks again for so accurately spotting the need for lua. Is there a mailing list for it, and have you heard of anyone else considering using it as a front-end for operating custom hardware?

Uma segunda mensagem, a pedido dos autores, relata seu uso atual:
From Mark@nlcc.demon.co.uk Sat Apr 5 09:56:02 1997 From: Mark@nlcc.demon.co.uk (Mark Ian Barlow) To: lhf@server02.lncc.br Subject: Re: applications that use Lua I'm using Lua to sequence high-level commands to robots, connected to the host either via a serial line or transputer link; perhaps in future via USB or FireWire. Lua is particularly valuable here because the debugger hooks give me a means to make external asynchronous events (eg: touchsensors) look like atomic actions as far as the Lua program is concerned, and allow users to assign call-back functions to them. Essentially the robot is a "manipulation server" and the Lua program it's client. The second major advantage is the portability; I can easily compile a stripped-down Lua client for an embedded processor on the robot's motherboard. The user can then download their final debugged application into non-volatile memory, disconnect the host and leave the robot to get on with the job.

Relevncia Acadmica

Apesar de sua motivao tecnolgica, Lua tem tido uma grande relevncia acadmica desde o incio de seu projeto. As sub-reas da computao nas quais o trabalho com a linguagem Lua se mostrou mais relevante foram Linguagens de Programao e Engenharia de Software. Na linha de Linguagens, Lua oferece diversos mecanismos inovadores; porm, o mais importante sua economia de conceitos, que a torna significativamente mais simples e menor que outras linguagens com recursos semelhantes. Entre outras

49

estruturas que contribuem para isso, podemos destacar o mecanismo de tabelas e sua identificao com o conceito de objetos, e o mecanismo de fallbacks (tag method). Na linha de Engenharia de Software, o principal impacto de Lua foi promover o mtodo bottom-up de desenvolvimento, com uso intensivo de componentes. O uso de Lua como glue-language permite que partes significativas de um sistema possam ser desenvolvidas como bibliotecas, com um pequeno roteiro em Lua definindo a arquitetura final de uma aplicao.
Publicaes

Uma das maneiras de mostrar a relevncia acadmica de Lua atravs das publicaes geradas em torno da linguagem. Abaixo, apresentamos a lista dessas publicaes. Essa lista dividida em duas partes: a primeira contm artigos diretamente relacionados com a linguagem. A segunda contm trabalhos baseados em Lua. Vale frizar que os trabalhos baseados em Lua, de maneira geral, no s utilizaram a linguagem em sua implementao, mas tambm sofreram influncia de Lua em suas arquiteturas, sendo desenvolvidos segundo a linha bottom-up promovida pela linguagem. Trabalhos Sobre Lua R. Ierusalimschy, L. H. de Figueiredo, and W. Celes. Lua an extensible extension language. Software: Practice and Experience, 26(6):635652, 1996. Luiz Henrique de Figueiredo, Roberto Ierusalimschy, and Waldemar Celes. Lua: An extensible, portable embedded language. Dr. Dobbs Journal, 21(12):2633, December 1996. Toms G. Gorham and Roberto Ierusalimschy. Um sistema de depurao reflexivo para uma linguagem de extenso. I Simpsio Brasileiro de Linguagens de Programao, pginas 103114, Belo Horizonte, setembro 1996. Noemi Rodriguez, Cristina Ururahy, Roberto Ierusalimschy, and Renato Cerqueira. The use of interpreted languages for implementing parallel algorithms on distributed systems. In L. Boug, P. Fraigniaud, A. Mignotte, and Y. Robert, editors, Euro-Par96 Parallel Processing Second International EuroPar Conference, pginas 597600, Volume I, Lyon, France, August 1996. Springer-Verlag. (LNCS 1123). Toms Guisasola Gorham. Um sistema de depurao para a linguagem de extenso Lua. Dissertao de Mestrado, Dep. Informtica, PUC-Rio, maro 1996. L. H. de Figueiredo, R. Ierusalimschy, and W. Celes. The design and implementation of a language for extending applications. XXI Semish, pginas 273284, Caxambu, 1994.

50

Roberto Ierusalimschy, Waldemar Celes Filho, Luiz Henrique de Figueiredo, Roberto Murilo de Sousa. Lua: uma linguagem para customizao de aplicaes. Caderno de Ferramentas do VII Simpsio Brasileiro de Engenharia de Software, pgina 55, 1993.

Trabalhos Baseados em Lua Andr Oliveira Costa. TkVIX um toolkit para construo de interfaces grficas em Lua. Dissertao de Mestrado, Dep. Informtica, PUC-Rio, abril 1997. Paulo Henrique Mascarenhas SantAnna. Modelos de extenso de agentes para gerenciamento de redes. Dissertao de Mestrado, Dep. Informtica, PUC-Rio, abril 1997. R. O. Prates, C. S. de Souza, A. C. B. Garcia. A Semiotic Framework for MultiUser Interfaces. ACM SIGCHI Bulletin 29(2):2839, 1997. Nick Lehtola. Ambiente para o desenvolvimento de sistemas CAD integrado em edificaes de ao. Tese de doutorado, Dep. Engenharia Civil, PUC-Rio, Abril 1996. Andr Luiz Clnio dos Santos. VIX um framework para suporte a objetos visuais interativos. Dissertao de Mestrado, Dep. Informtica, PUC-Rio, dezembro 1996. Neil Armstrong Rezende. GLB: Uma ferramenta para manipulao de objetos grficos procedurais. Dissertao de Mestrado, Dep. Informtica, PUC-Rio, maro 1996. Carlos Roberto Serra Pinto Cassino. Uma ferramenta para programao literria modular. Dissertao de Mestrado, Dep. Informtica, PUC-Rio, agosto 1996. Waldemar Celes Filho. Modelagem configurvel de subdivises planares hierrquicas. Tese de doutorado, Dep. Informtica, PUC-Rio, julho 1995. Marcelo Tlio Monteiro de Carvalho. Uma estratgia para o desenvolvimento de aplicaes configurveis em mecnica computacional. Tese de doutorado, Dep. Engenharia Civil, PUC-Rio, junho 1995. A. Carregal, R. Ierusalimschy. Tche a visual environment for the Lua language. VIII Simpsio Brasileiro de Computao Grfica, pginas 227232, So Carlos, 1995. R. Cerqueira, N. Rodriguez, R. Ierusalimschy. Uma experincia em programao distribuda dirigida por eventos. PANEL95 XXI Conferncia Latino Americana de Informtica, pginas 225236, 1995.

51

Waldemar Celes Filho, Luiz Henrique de Figueiredo, Marcelo Gattass. EDG: uma ferramenta para criao de interfaces grficas interativas. VIII Simpsio Brasileiro de Computao Grfica, pginas 241248, So Carlos, 1995. M. T. de Carvalho, L. F. Martha. Uma arquitetura para configurao de modeladores geomtricos: aplicao a mecnica computacional. PANEL95 XXI Conferncia Latino Americana de Informtica, pginas 123134, 1995. Neil Armstrong Rezende, Waldemar Celes Filho, Marcelo Gattass, nio E. Ramos Russo. PRE-GO: Um editor de objetos grficos procedurais. VIII Simpsio Brasileiro de Computao Grfica, pginas 309310, So Carlos, 1995. Siome Klein Goldenstein, Paulo Cezar Pinto Carvalho, Luiz Henrique de Figueiredo. IG: um sistema de construes geomtricas com vnculos. VIII Simpsio Brasileiro de Computao Grfica, pginas 311312, So Carlos, 1995. Andr Filipe Lessa Carregal. Tche: Um ambiente visual Lua. Dissertao de Mestrado, Dep. Informtica, PUC-Rio, maro 1995. Eduardo Setton Sampaio da Silveira. Um sistema de modelagem bidimensional configurvel para simulao adaptativa em mecnica computacional. Dissertao de Mestrado, Dep. Engenharia Civil, PUC-Rio, agosto 1995.

Lua na Internet
Lua vem sendo disponibilizada na Internet desde fevereiro de 1994. (sua home-page pode ser acessada em http://www.inf.puc-rio.br/~roberto/lua.html). Aps a publicao de um artigo de divulgao na Dr. Dobbs, no final de 1996, o interesse externo pela linguagem tem crescido constantemente. O pacote est disponvel em quatro locais, no Brasil, Canad, Alemanha e Grcia, sendo os dois ltimos mantidos por grupos totalmente independentes.

Atualmente, a linguagem conta com uma lista de discusses (lua-l@tecgraf.pucrio.br) com mais de setenta participantes, sendo a maioria deles de fora do pas (a lista de participantes pode ser obtida enviando-se review lua-l para listproc@tecgraf.puc-rio.br). Vrias colees de linguagens e/ou ferramentas na Internet j incluem Lua. Entre outras, citamos as seguintes:
http://www.KachinaTech.COM/~hjjou/new-SAL/F/1/LUA.html. Pgina mantida

pela SAL: SAL (Scientific Applications on Linux) is a collection of information and links of software that scientists and engineers will be interested in. The broad coverage on Linux applications will also benefit the whole Linux/Unix community.
http://www.idiom.com/free-compilers/TOOL/lua-1.html. Parte do Catalog

of Free Compilers and Interpreters: This list is primarily aimed at developers

52

rather than researchers, and consists mainly of citations for production quality systems. Abaixo listamos alguns comentrios sobre Lua que circularam pela rede. Alguns foram mandados diretamente para os autores, outros apareceram em grupos de discusso (newsgroups) sobre linguagens. interessante observar a diversidade das instituies, atravs dos endereos dos remetentes. From: W.Boeke, Lucent Technologies, the Netherlands
From wboeke@hzsda01.nl.lucent.com Thu Jul 18 04:31:22 1996 After the article in 'Software, P.&E.' you must have had a lot of responses. Everyone with some knowledge of computer languages will have been struck by the original concepts of the language. []

From: "Francis L.Burton'' !gpaa29@udcf.gla.ac.uk?

From udcf.gla.ac.uk!gpaa29 Fri Jan 26 14:20:34 1996 [] Lua is a splendid piece of software, imho -- very clean language design, powerful through its reflexivity, nice API. The documentation is a pleasure to read. Would that all software were as neat as Lua! [] Frankly, I was amazed and delighted. []

From: Joshua Jensen !joshj@doc.sunrem.com?

[] Congratulations on Lua. It was exactly what I was looking for, and I've been using it as my primary script language for a month and a half now. It's powerful, small, and very easy to use (and expand upon). [] Good luck with it. I'd recommend the language to anyone.

From: ''Rodney A. Ludwig''!rludwig@rrnet.com?

[] I have been using interpreters in my code since the early 80s for testing and prototyping and to add a macro language [] so far this looks like the best I have seen and I have tried most everything around during that time. []

From: fburton@nyx10.cs.du.edu (Francis Burton)

53

Article: 8741 of comp.compilers Message-ID: !96-11-066@comp.compilers? Organization: University of Denver, Math/CS Dept. [] If you really want to learn about elegance and power in the design of little languages, take a look at the papers published about Lua (metapage at http://csg.uwaterloo.ca/~lhf/lua/) and study the source code. Neat!

From: Bret Mogilefsky !mogul@lucasarts.com?

After reading the Dr. Dobbs article on Lua I was very eager to check it out, and so far it has exceeded my expectations in every way! It's elegance and simplicity astound me. Congratulations on developing such a well-thought out language. []

Newsgroups: comp.lang.ml
Message Id: !5p6bbi$8cd$1@goldenapple.srv.cs.cmu.edu? [] I'm not so happy with Tcl as language design, and for C I think Lua does a better job than Tcl. [] Norman Ramsey -- moderator, comp.programming.literate http://www.cs.virginia.edu/~nr

From: jack@cwi.nl (Jack Jansen)

Message-Id: !jack.860671284@news.cwi.nl? Newsgroups: comp.lang.python [] From a glance at http://csg.uwaterloo.ca/~lhf/lua/home.html it looks like a pretty decent and small language, "Tcl done right" is what immedeately came to mind []

From: jamesl@netcom.com (James Logajan)

54

Message-Id: !jameslE8EL5A.vF@netcom.com? Newsgroups: comp.lang.scheme, comp.lang.scheme.scsh, comp.lang.lisp,comp.lang.tcl,comp.lang.functional,comp.lang. c++,comp.lang.perl.misc, comp.lang.python,comp.lang.eiffel John Ousterhout (ouster@tcl.eng.sun.com) wrote: "Every single programmer who ever wrote a program in Tcl, Perl, C++, Visual Basic, or even C could have chosen Lisp, Scheme, or Smalltalk. But they didn't." Others have responded to this point adequately; however, I just happen to be working on a product that is going to require a scripting or extension language. We get to pick our own language (for once). Our short list includes: Lua Python Perl Tcl I have not used any of these before, so have "fresh eyes" on our team. We need a language that is easy for beginners to pick up, that is not too slow, handles string processing well, has a small memory footprint, and is of course extensible. OOP support was considered important, but not vital. So far, Lua is winning, with Python still in the running because of its stronger OO support. Tcl is horribly slow with no particular feature that compensates for its sluggishness. Perl seems too syntactically unruly for people to get a good grip on how best to compose their work but has about the same speed as Python. Lua is about 1/10 the size of the others (70k versus 1000k for all the others on a Sparc) and is several times faster than Python and Perl. Tcl is an order of magnitude (10, not 2!) slower than Python/Perl. It is too bad that Lua doesn't have its own newsgroup (yet?). I was pleasantly surprised by the small size, fast speed, simple syntax, and powerful semantics of the language.

55