Download - Linguagem Lua
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 1/38
1
FAESAFUNDAÇÃO DE ASSISTÊNCIA E EDUCAÇÃO
FACULDADES INTEGRADAS ESPÍRITO-SANTANSESUNIDADE DE COMPUTAÇÃO E SISTEMAS
GUTHIERRY FERREIRA ALMEIDALEON PEDROSA DE MEIRELLES
PAULO HENRIQUE RODRIGUES ORIND
LINGUAGEM DE PROGRAMAÇÃO LUA
VITÓRIA/ES2010
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 2/38
2
GUTHIERRY FERREIRA ALMEIDALEON PEDROSA DE MEIRELLES
PAULO HENRIQUE RODRIGUES ORIND
LINGUAGEM DE PROGRAMAÇÃO LUA
VITÓRIA/ES2010
Trabalho acadêmicoapresentado ao Curso deCiência da Computação,FAESA, como parte das
exigências da disciplina deLinguagem de Programação Isob orientação da professoraCinthia C. L .Caliari.
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 3/38
3
SUMÁRIO
1. Linguagem Lua ............................................................................................... 51.1. Introdução................................................................................................. 5
1.2. História ..................................................................................................... 61.3. Importância ............................................................................................... 71.4. Aplicações ............................................................................................... 71.5. Características Principais ......................................................................... 10
1.5.1. Domínio de programação ................................................................ 101.5.2. Paradigma ....................................................................................... 101.5.3. Sintaxe ............................................................................................ 10
1.6. Diferenciais ............................................................................................... 111.6.1. Portabilidade ................................................................................... 11
1.6.2. Simplicidade .................................................................................... 111.6.3. Pequeno Tamanho .......................................................................... 111.6.4. Acoplabilidade ................................................................................. 111.6.5. Eficiência ......................................................................................... 12
1.7. Valores e Tipos ......................................................................................... 121.7.1. Variáveis Locais .............................................................................. 121.7.2. Tipos ............................................................................................... 13
1.7.2.1. Nil ......................................................................................... 131.7.2.2. Boolean ................................................................................ 141.7.2.3. Number ................................................................................. 141.7.2.4. String .................................................................................... 15
1.7.2.4.1. Concatenação ............................................................ 151.7.2.5. Table ..................................................................................... 16
1.7.2.5.1. Inicialização de tabelas .............................................. 181.7.2.5.1.1. Via indexação consecutiva .............................. 181.7.2.5.1.2. Via atribuição de campos ................................ 191.7.2.5.1.3. Inicialização mista ........................................... 19
1.7.2.6. Function ................................................................................ 211.7.2.6.1. Declarando e chamando uma função ........................ 21
1.7.2.6.2. Número varável de parâmetros .................................. 221.7.2.6.3. Retorno de um único valor ......................................... 23
1.7.2.7. Userdata ............................................................................... 231.7.2.8. Thread .................................................................................. 24
1.7.2.8.1. Co-rotinas................................................................... 251.7.3. Coerção ........................................................................................... 25
1.8. Expressões e Atribuições ......................................................................... 261.8.1. Operadores ..................................................................................... 26
1.8.1.1. Aritméticos ............................................................................ 26
1.8.1.2. Relacionais ........................................................................... 261.8.1.3. Lógicos ................................................................................. 271.8.1.4. Operador de concatenação .................................................. 27
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 4/38
4
1.8.1.5. Precedência de operadores .................................................. 271.8.2. Estruturas de controle ..................................................................... 27
1.8.2.1. If............................................................................................ 271.8.2.2. While ..................................................................................... 281.8.2.3. Repeat .................................................................................. 281.8.2.4. For ........................................................................................ 28
1.8.2.4.1. For numérico .............................................................. 281.8.2.4.2. For genérico ............................................................... 29
1.8.2.5. Break e return ....................................................................... 291.9. Biblioteca padrão Lua ............................................................................... 301.10. Programar em Lua .......................................................................... 311.11. Conclusão ....................................................................................... 331.12. Anexos ............................................................................................ 34
1.12.1. Anexo I ................................................................................. 341.12.2. Anexo II ................................................................................ 341.12.3. Anexo III ............................................................................... 351.12.4. Anexo IV ............................................................................... 36
1.13. Referências .......................................................................... 37
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 5/38
5
LINGUAGEM DE PROGRAMAÇÃO LUA
1.1 INTRODUÇÃO
Única linguagem de aceitação mundial desenvolvida fora do eixo EUA – Europa – Japão, Lua, foi criada em 1993 no Brasil e se destaca pelo poder, simplicidade e
rapidez.
Lua foi projetada para estender aplicações, é totalmente tipada dinamicamente, é
interpretada e tem gerenciamento automático de memória com coletor de lixo
incremental. Essas e outras características fazem dela uma linguagem ideal para
configuração e automação (Scripting).
Por também ser de licença permissiva, a linguagem tornou-se popular entre os
desenvolvedores de todo o planeta, passando a fazer parte rapidamente da lista das
30 linguagens mais utilizadas no mundo, além da presença em empresas
importantes como o Incor, Intel, Microsoft e NASA, por exemplo.
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 6/38
6
1.2 HISTÓRIA
Em 1992, em um projeto entre a PUC-Rio (Pontifícia Universidade Católica do Rio
de Janeiro) e a Petrobras, surgiu o TeCGraf (Grupo de Tecnologia em ComputaçãoGráfica), a princípio baseava-se na construção de interfaces gráficas para
programas de simulação. Para tal era utilizada DEL (Linguagem para Especificação
de Diálogos), que apresentava algumas limitações. Um ano depois, em novo projeto
com a Petrobras foi criado o PGM (Programa Gráfico Mestre), utilizado para
visualização de perfis geológicos. A linguagem SOL (Simple Object Language)
estava sendo utilizada, mas também se limitava.
Como DEL e SOL tinham bastantes problemas em comum, Roberto Ierusalimschy(PGM), Luiz Henrique Figueiredo (DEL) e Waldemar Celes (PGM) se reuniram para
encontrar uma solução, precisavam de uma linguagem de configuração genérica,
completa, facilmente acoplável, portátil, de boa sintaxe e que fosse simples, e neste
mesmo ano, 1993, a solução: Lua. O nome, segundo Ricardo, seria uma sugestão
de um amigo, já que eles estavam abandonando o projeto de SOL.
A primeira versão de Lua (1.0), a posteriori , data de julho de 1993, mas a primeira
versão pública (1.1) só veio em julho de 1994 era mais eficiente. Distribuída
publicamente pela internet, Lua era de licença livre para uso acadêmico e restritiva
para uso comercial, foi quando começaram os problemas com a concorrência (Perl,
Python,...). Lua 2 (Lua 2.1, de fevereiro de 1995 a Lua 2.5 de novembro de 1996) foi
a primeira versão com licença “free software”, nesta versão foi criado um formato
simplificado para tabelas, que está em uso até hoje. Em 1995 foi criada uma
homepage para a linguagem, em 1996 publicado artigos na “Software: Pratice &
Experience” e na “Dr. Dobb‟s”, artigos estes importantíssimos para divulgação da
linguagem e em 1997 Lua é premiada com o prêmio COMPAQ, ano em que iniciava-
se as versões 3 (Lua 3.0 de julho de 1997 a Lua 3.2 de julho de 1999). Em 1998 foi
criada a logomarca da linguagem (FIGURA 1). Lua 4.0 veio em novembro de 2000,
com comandos “for” e “break” e com código escrito em “clean C” – interseção entre
as linguagens C e C++ -, além de maior eficiência. Em Lua 5 houve a implantação
de co-rotinas e de um “for” genérico (via geradores), melhoria da visibilidade léxica,
maior facilidades para módulos, além da implementação de uma máquina virtual viaregistradores e novo algoritmo para tabelas.
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 7/38
7
FIGURA 1 – Logomarca da Linguagem Lua
Hoje, na versão 5.1 (versão beta 5.2 lançada recentemente), Lua é conhecida
mundialmente no universo dos games. Uma pesquisa do site gamedev.net de
setembro de 2003 revelou que dos 72% dos jogos que utilizam uma linguagem de
script, 20% utilizam Lua (com 7% ficou Python, segunda colocada). A sua primeira
aparição nesta indústria de que se tem notícia foi no game “Grim Fandango” da
“Lucas Arts” (ANEXO I), logo após publicação do artigo na “Dr. Dobb‟s”, está
também em “FarCry”, “World of WarCraft”, “The Sims 2”, “Baldur‟s Gate” e “Amped”.
Mas não foi só em jogos que Lua se destacou, empresas como Adobe, NASA, Intel,
já a utilizaram.
Outra pesquisa (ANEXO III) de novembro de 2010 da TIOBE Software aponta alinguagem brasileira entre as 30 linguagens de programação mais utilizadas do
mundo, a frente da Fortran, da COBOL, da Visual Basic.NET, da Haskell, JavaFX
Script e da Prolog, por exemplo.
1.3 IMPORTÂNCIA
Lua tem importância global. Além de várias aplicações no mundo inteiro, em 2007 oseu projeto e evolução foram apresentados na HOPL III, 3ª Conferência da ACM
sobre a História das Linguagens de Programação (ANEXO IV) tal conferência só
acontece uma vez a cada 15 anos e há apresentação de poucas linguagens por vez.
“A escolha de Lua para a HOPL III é um importante reconhecimento do seu impacto
mundial.”, diz o site da linguagem.
1.4 APLICAÇÕES
Como já dito, Lua teve grande aceitação em jogos, são os principais:
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 8/38
8
“Grim Fandango” - LucasArts;
“World WarCraft” - Blizzard;
“Sonic, the Hedgehdg” – SEGA;
“FarCry” – UBISOFT;
“The Sims2” – EA;
“Sim City 4” – EA;
“Warhammer Online – Age of Reckoning” – EA;
“Supreme Commander” – THQ;
“Heroes V” – UBISOFT;
“Spell Force” –Solo Out;
“S.T.A.L.K.E.R. – Shadow of Chernobyl” – THQ;
“CRYSIS – EA”;
“Dawn of War” – Relic;
“NFL Fever 2004” – XSN Sports;
“The Witcher” – Atari;
“Amped – Freestyle Showboarding” – Microsoft;
“Hulk – The Incredible” – SEGA;
“Destroy all Humans!” – THQ;
“Psychonauts” – MAJEACO;
“MDK 2” - Interplay;
“Escape from Monkey Island” – Lucas Arts (Neste jogo Lua recebeu uma
homenagem (ANEXO II));
“Baldur‟s Gate” - BioWare;
“Impossible Creatures” – Relic, Microsoft Game Studios; “HomeWorld 2” – Relic”;
“Links 2004” – XSN Sports;
“Amped 3” – 2K Sports;
“Soul Ride” - Slingshot;
“Diner Dash 2 – Restaurant Rescue” – PlayFirst;
“Top Spin 2” – 2K Sports;
“NHL Rivals 2004” – XSN Sports; “Grand Theft Auto” – Rockstar Games.
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 9/38
9
No mercado de softwares em geral:
“Ginga NCL” – middleware padrão brasileiro para TV Digital;
“Wireshark” – analisador de protocolos; “Snort” – detecção de “intrusos” e proteção do sistema;
“Adobe Lightroom” – gerenciador e organizador de imagens;
“nmap” – rastreador de redes para segurança;
“Eyeon‟s Digital Fusion” – pós-produção de filmes;
“INPE” – biblioteca GIS;
“Olivetty” – firmware para impressoras;
“Omnitronix” – monitoramento remoto; “RealTimeLogic” – servidores Web;
“APT-RPM”, Conectiva – padrão para distribuições RPM;
“Publique!” – gerenciador de conteúdo para web;
“Sputnik” – wiki extensível disponível como software livre.
Empresas diversas e importantes também aderiram à linguagem, empregando-a em
aplicações das mais variadas:
Hands: uso no desenvolvimento de navegadores de conteúdo para micros de
bolso;
Incor (Instituto do Coração em São Paulo): utilizada no servidor do sistema
que monitora pacientes na UTI via Web;
CPC 4400: placa de switch para rede Ethernet, a linguagem foi usada na
criação de sua interface;
Intel: empregada na ferramenta interna para layout de chips (processadores); Robô Crazy Ivan: Lua é um dos componentes do seu cérebro, responsável,
segundo fabricantes do robô, pela parte lógica. Ivan ganhou o concurso de
inteligência artificial da RoboCup 2000, concurso de robôs realizado na
Dinamarca;
AXAF (Advanced X-ray Astrophysics Facility): terceiro dos grandes
observatórios espaciais lançados pela NASA, tem a tarefa de simular em
imagens os sinais recebidos do espaço, Lua é uma das linguagens utilizadaspara tal;
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 10/38
10
NASA: Lua foi a linguagem usada no controle dos níveis de concentração de
gases perigosos na preparação para o lançamento de ônibus espacial.
Petrobras: principal usuária, utilizando principalmente em visualizações de
perfis geológicos.
1.5 CARACTERÍSTICAS PRINCIPAIS
1.5.1 Domínio de Programação
Lua é uma linguagem de scripting, ou de extensão. Linguagens com este domínio
tem a finalidade de estender funcionalidades de aplicações. Seu uso pode ser tanto
como ferramentas de configuração e instalação em sistemas operacionais, como no
Linux (tomsrtbt) que utiliza Lua, quanto nos games, no caso de Lua, em “Baldur‟s
Gate” em que é utilizada em comandos de debug mapeados e prompt para debug
em tempo real, no “ImpossibleCreatures” em Controle de IA, aparência de efeitos e
de outros elementos gráficos e também debug em tempo real, por exemplo.
1.5.2 Paradigma
Lua é de paradigma imperativo, que lhe dá eficiência, paradigma bem estabelecido e
eficiência. Mas oferece suporte para abstração de dados, para programação
Orientada a Objetos.
1.5.3 Sintaxe
Escrita na interseção das linguagens C e C++, Lua é de sintaxe convencional:
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 11/38
11
FIGURA 2 – Função fatorial em Lua
1.6 DIFERENCIAIS
1.6.1 Portabilidade
Lua roda em praticamente todas as plataformas, como por exemplo: Windows,
WindowsCE, Unix, Mac OS, Symbian, Palm, BREW, PSII, Linux, Xbox e até mesmo
em supercomputadores Cray, entre outras, pois foi escrita em ANSI C ∩ ANSI C++,
evitando “#ifdefs” e pontos obscuros do padrão.
1.6.2 Simplicidade
A linguagem Lua possui apenas um único tipo de estrutura de dados, as tabelas e
um único tipo numérico, o number (tipicamente double), além disso, utiliza de
mecanismos ao invés de políticas, como a exemplo a orientação a objetos.
1.6.3 Pequeno tamanho
Sua distribuição completa cabe confortavelmente em um disquete.
Apesar de grandes recursos, incluir Lua numa aplicação não aumenta em quase
nada o seu tamanho, pois o pacote com sua versão atual, contendo o código-fonte,
a documentação e exemplos, ocupa cerca de 212K comprimido e 860K
descompactado. Com interface bem definida, o núcleo tem menos de 100K e
apresenta bibliotecas independentes, ou seja, removíveis.
1.6.4 Acoplabilidade
Lua é uma biblioteca em C, é rápida e pequena, pode ser facilmente embutida a
aplicações. Apresenta API simples e bem definida, com operações primitivas e
modelo de pilha. É possível estender programas, não só em C e C++, quanto em
Java, Fortran, C#, Ada e até mesmo em outras linguagens de script, como Perl e
Ruby.
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 12/38
12
1.6.5 Eficiência
As execuções de programas independentes mostram Lua entre as mais rápidas das
linguagens interpretadas com tipagem dinâmica. Porções substanciais de aplicações
grandes são escritas em Lua.
Para um arquivo com 100K, Lua o trata em 1,2 segundos, Perl em 5,3, e Python em
16,8 segundos, já um arquivo com 1M, Lua o trata em 12 segundos, enquanto Perl e
Python derrubam a máquina (“trash”).
1.7 VALORES E TIPOS
Em Lua, as variáveis globais não precisam ser declaradas, ou seja, ao se escrever o
comando:
a = 1.5
significa que a variável a é global. Outra característica fundamental é que nalinguagem as variáveis não tem tipo associado, estes estão aos dados armazenados
nela. A variável a citada anteriormente adquiriu um tipo numérico e ao fazer
posteriormente:
a = "Lua"
ela passa a armazenar uma string.
1.7.1 Variáveis Locais
A definição de escopo local de uma variável pode ocorrer em qualquer lugar dentro
de um bloco de comandos, e seu escopo termina quando o bloco em que foi
declarada também termina. Declarar uma variável local com mesmo nome de uma
global obscurece temporariamente o acesso à variável global. Como exemplo, segue
o código abaixo:
a = 2 –- cria variável global a
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 13/38
13
if a > 0 thenlocal b = a –- cria variável local ba = a + 1 –- incrementa a variável global alocal a = b –- cria variável local a
print(a)end
print(a)
Em Lua os comentários são feitos utilizando dois hifens seguidos (--).
No primeiro print, imprime-se o valor 2, pois se refere a variável local a, no
segundo, por já estar fora do escopo de a e b (locais), delimitado pelo end, o valor a
ser impresso será o 3, pois a variável a referida é global.
É possível ainda declarar e inicializar várias variáveis locais em um mesmo
comando:
local a, b, c = 2, 5+6, -3
Neste caso, a recebe o valor 2, b recebe 11 e c recebe -3. As variáveis locais que
não forem inicializadas assumem valor nil.
1.7.2 Tipos
Existem oito tipos de dados em Lua:
Nil;
Boolean;
Number;
String;
Table;
Function;
Userdata;
Thread.
1.7.2.1 Nil
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 14/38
14
Representa o valor indefinido. Todas as variáveis que ainda não foram inicializadas
assumem o valor nil. Portanto no código:
a = b
sem que haja qualquer atribuição à variável b, b passa a assumir o conteúdo de
valor nil, o que significa que a passa a armazenar nil também, independentemente
do valor anteriormente armazenado em a. A palavra reservada nil pode ser
utilizada na programação para expressar o valor do tipo nil. Com isso:
a = nil
atribuindo o valor nil à variável a (a partir deste ponto, é como se a variável a ainda
não tivesse sido atribuída).
Também há como testar se uma variável foi ou não inicializada, comparando seu
valor com nil:
a == nil.
O nil também é interpretado como falso numa expressão booleana.
1.7.2.2 Boolean
Valor booleano, podendo ser falso (false) ou verdadeiro (true). Uma expressão
será considerada falsa caso seja igual à nil, como dito anteriormente, ou
verdadeira caso contrário, inclusive quando igual a 0.
1.7.2.3 Number
Lua não faz distinção entre valores numéricos com valores inteiros e reais, há um
tipo para representá-los, o number, que é ponto flutuante por padrão, podendo
representar um número inteiro de até 32 bits. Podendo ser feito:
a = 4b = 4.0
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 15/38
15
c = 0.4e1
d = 40e-1
armazenando o valor numérico quatro nas variáveis a, b, c e d.
1.7.2.4 String
Representa uma cadeia de caracteres, podendo ser delimitada por aspas duplas
("..."), aspas simples ('...'), ou duplos colchetes ([[...]]). Se uma cadeia começa
com aspas simples, ela deve terminar com aspas simples, do mesmo para as
duplas. Os duplos colchetes são utilizados para cadeias que se estendem por várias
linhas.
Esse tipo é imutável em Lua, toda vez que a cadeia é alterada, na verdade, cria-se
uma nova.
Dentro de uma string são interpretadas as sequências de escape:
\n new line\t Tab\r carriage return\v vertical tab\f form feed
\xxx caracter com código decimal xxx\a bell\b backspace\" aspas duplas (“) \' aspas simples („) \\ barra invertida (\)
No entanto, ao delimitar uma cadeia de caracteres com aspas duplas, por exemplo,
pode-se utilizar de aspas simples no seu conteúdo sem que haja a necessidade detratá-la como sequência de escape. Assim, são válidas e equivalentes as seguintes
atribuições:
s = "olho d'agua"
s = 'olho d\'agua'
1.7.2.4.1 Concatenação
Para concatenar duas strings, utiliza-se do operador de concatenação (..), como noexemplo abaixo:
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 16/38
16
a = "seg" .. "unda"b = "feira"print (a .. "-" .. b) -- imprime segunda-feira
Seja t uma tabela Lua que representa um array onde os elementos são cadeias decaracteres. O objetivo é escrever um programa que cria uma cadeia com todos os
elementos de t separados por vírgulas e depois imprime a string resultante. Uma
maneira simples de escrever está ilustrada abaixo:
local s = ""for i, v in ipairs (t) do
s = s .. v .. ","end
print (string.sub (s, 1, #s - 1))
Caso t tenha poucos elementos, o desempenho desse programa será satisfatório.
Caso contrário, a execução do programa iria demorar mais do que o esperado.
Como em Lua cada cadeia de caracteres é única, a criação de várias novas cadeias
é um pouco custoso, de forma que é possível evitá-la com uma solução mais
eficiente, através da função table.concat, para concatenar várias cadeias,
recebendo uma tabela como primeiro parâmetro e uma string como segundo, que
será usada como separador dos elementos da tabela. A mesma tarefa do programaanterior pode realizada neste que segue abaixo:
local s = table.concat (t, ",")print (s)
1.7.2.5 Table
As tabelas (table) são a única forma de estruturação de dados em Lua, representamum vetor associativo, implementado internamente com o uso de uma eficiente
combinação de array e hash (tabela de dispersão). Com as tabelas podem-se
representar vetores, listas, filas, tabelas de símbolos, conjuntos, grafos, registros e
hash. Uma variável do tipo table pode ser indexada por valores de qualquer tipo,
com exceção do tipo nil.
Uma tabela deve ser explicitamente criada antes de ser usada, a criação é feita pela
expressão {}. Assim, o código: t = { }, cria uma tabela vazia e armazena na
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 17/38
17
variável de nome t. Daí, a variável t armazena um valor do tipo table e pode então
ser indexada. É válido escrever, por exemplo:
t[1] = 13t[45] = 56
Não há limite para a indexação da tabela. Se necessário, Lua redimensiona a tabela
automaticamente. Além disso, também é valido escrever:
t["nome"] = t[1] + 2
Ou seja, a tabela t indexada pelo valor string 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.
Lua oferece uma sintaxe simplificada quando o índice é uma string simples (desde
que a string não seja uma palavra reservada da sintaxe da linguagem). Assim, a
atribuição anterior t["nome"] = t[1]+2 pode ser escrita por t.nome = t[1]+2.
Como dito, esta notação é para string simples, portanto não é possível fazer o
mesmo no exemplo abaixo, por se tratar de uma string composta:
t[“Rio de Janeiro"] = 1994
Também é válido escrever:
t[t] = 5
que significa que a tabela t indexada pelo valor t (própria tabela) armazena o valor
numérico 5.
As atribuições abaixo também são válidas para a tabela t:
t[10] = "exemplificando"t[2.34] = 12t.tabela, t[0] = 3, 12t[-234] = 0a = "Lua"t[a] = 5
Quanto à última atribuição é necessária uma análise minuciosa. A variável a
armazena o valor Lua, a última atribuição armazena 5 no índice Lua da tabela.
Escrever t[a] é diferente de t.a, que é equivalente a t["a"]. Assim, no
exemplo, t[a] corresponde a t.Lua.
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 18/38
18
Se o valor de uma tabela para qualquer índice cuja indexação ainda não foi
inicializada recebe nil. Portanto, considerando apenas as atribuições anteriormente
exemplificadas, o código: print (t[999]) imprimirá o valor nil, pois o campo
999 de t não foi inicializado.
Há a possibilidade do armazenamento de tabelas em outras tabelas, criando
conjuntos multidimensionais, como no exemplo:
m = { }m[1] = { }m[2] = { }m[1][1] = 1.0
m[2][1] = 0.0 Assim, também é válido:
s = { }s.dados = { }s.dados.nome = "Linguagem Lua"s.dados.versao = 3.0
1.7.2.5.1 Inicialização de tabelas
1.7.2.5.1.1 Via indexação consecutiva
Lua permite a inicialização de tabelas na criação.
Uma forma possível para inicialização de tabelas é
{expr1, expr2, ..., exprN}
Isto é, escreve-se uma lista de expressões entre as chaves que criam a tabela. Cada
expressão listada é avaliada e seu valor armazenado no índice correspondente: o
valor da primeira expressão é armazenado no índice 1 da tabela, o valor da segunda
expressão no índice 2, e assim por diante. Portanto: t = {23, 45, -7, "Lua",
6+4} é equivalente à:
t = { }t[1] = 23t[2] = 45
t[3] = -7t[4] = "Lua"t[5] = 6+4
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 19/38
19
1.7.2.5.1.2 Via atribuição de campos
Lua permite também a inicialização de campos da tabela, sua forma geral é:
{ [exprA ] = expr1, [exprB] = expr2, ... }
Ou seja, na criação de tabelas a inicialização de qualquer tipo de campo (que a
tabela pode armazenar) é possível. Assim:
t = { nome = "Linguagem Lua", [1] = 3.0, [f(x)] = g(y) }
equivale a
t = { }t.nome = "Linguagem Lua"t[1] = 3.0t.[f(x)] = g(y)
1.7.2.5.1.3 Inicialização mista
Há a possibilidade de combinação das duas maneiras de inicialização mostradas
anteriormente. A forma geral é:
tabela = {lista-de-expressões; lista-de-atribuições-de-campos}
Dessa forma, a lista de expressões de uma inicialização por indexação pode vir
seguida do ponto e vírgula (;) enquanto a lista de atribuições de campos por nomes.
Escrever:
t = {23, 45, -7 ; nome="Linguagem Lua",versao=3.0,[4]=80}
equivale a:
t = { }t[1] = 23t[2] = 45t[3] = -7t.nome = "Linguagem Lua"t.versao = 3.0
t[4] = 8
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 20/38
20
Se uma tabela estiver sendo utilizada como um array, é possível saber o número de
elementos do array usando o operador de tamanho #. Este operador retorna um
índice n do array desde que o valor da posição n do array seja diferente de nil e
que o valor na posição n+1 seja nil. Podendo apresentar falhas quando trabalhado
com um array que contém valores nil.
O funcionamento do # pode assim ser exemplificado:
local t = {"a", "b", "c"}print (#t) –-valor impresso: 3table.insert (t, "d")print (#t) --valor impresso: 4t [6] = "8"-- Tem-se um valor nil no meio do array (t[5]). O operador de--tamanho não tem um comportamento bem definido neste caso 11print (#t) -- ??t [5] = "e"-- Agora o array não tem "buracos" e o operador # retorna o-- valor esperadoprint (#t) --> 6
Duas funções de iteração sobre os elementos armazenados na tabela são
oferecidas na biblioteca padrão de Lua.
Ipairs
Itera sobre os índices numéricos armazenados na tabela. Assim,
for i,v in ipairs(t) do...end
itera sobre os pares (1,t[1]),(2,t[2]),…, até que o primeiro índice com valor
associado igual anil
seja encontrado.
Pairs
Permite iterar sobre todos os pares armazenados na tabela, independente do tipo
associado ao índice:
for k,v in pairs(t) do … end
Onde, a ordem dos pares k, v são reportados é indefinida.
Lua permite a especificação de um “construtor” na criação de tabelas. Por exemplo,
um ponto 3D, dado pelas suas coordenadas. Em Lua, pode-se escrever:
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 21/38
21
local p = Point{x=3.0,y=1.3,z=3.2}
Esse código é equivalente a:
local p = Point({x=3.0,y=1.3,z=3.2})
A tabela foi criada, chamou a função Point passando a nova tabela como parâmetro.
Essa função pode ser o construtor do objeto sendo criado. Usando a função, pode-
se, por exemplo, validar e inicializar campos do objeto, desta forma:
function Point (self)self.x = tonumber(self.x) or 0.0self.x = tonumber(self.y) or 0.0self.x = tonumber(self.z) or 0.0return self
end
Dessa forma, se ao criar o objeto os valores de suas coordenadas não tiverem sido
especificados, então a função os inicializa com zero.
1.7.2.6 Function
Function são as funções da linguagem, que em Lua são tratadas como valores de
primeira classe, o que significa que é possível armazená-las em variáveis (globais
ou locais) ou em campo de tabela, passa-las como parâmetro para outras funções.
1.7.2.6.1 Declarando e chamando uma função
A declaração da função pode ser da seguinte forma:
function nomedafuncão (arg_1, arg_2, ..., arg_n)corpoDaFuncão
end
Onde as variáveis arg_N indicam os parâmetros da função. Em Lua, uma função
pode ter desde nenhum até centenas de parâmetros. Assim, uma função pode
retornar vários valores ou nenhum.
Como exemplo a função f, que recebe dois parâmetros e retorna a soma e o
produto deles:
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 22/38
22
function f (a, b)local x = a or 1 -- x recebe o valor padrão 1 quando a é-- um valor falsolocal y = b or 1 -- y recebe o valor padrão 1 quando b é
-- um valor falsoreturn x + y, x * y
end
Mesmo possuindo dois parâmetros, é possível chamar a função f com quantidade
diferente de parâmetros. Se f for chamada com mais parâmetros do que o
esperado, os valores excedentes serão descartados, caso o valor de parâmetros
sejam menores, os valores dos parâmetros não fornecidos será nil. Pode-se
perceber tal comportamento no exemplo abaixo:
s, p = f (3, 4)-- a é 3 e b é 4print (s, p) -- imprime 7 12s, p = f (2) -- b é nil e y é inicializado com 1print (s, p) -- imprime 3 2s, p = f (2, 5, 8) -- 8 é descartadoprint (s, p) -- imprime 7 10print (f ()) -- imprime 2 1
1.7.2.6.2 Número variável de parâmetros
As funções com número variável de parâmetros são declaradas utilizando três
pontos (...) . Para acessar os parâmetros que foram chamados, usa-se a notação
{...}, para criação de um array onde o primeiro parâmetro da função está na
posição 1, o segundo na 2 e assim sucessivamente. A seguir, o exemplo mostra
uma função que recebe strings e imprime aquelas com tamanho maior do que 3.
FIGURA 3 – Função com número variável de parâmetros
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 23/38
23
1.7.2.6.3 Retorno de um único valor
Como dito anteriormente, em Lua pode-se retornar nenhum, apenas um ou múltiplos
valores. Porém, nem sempre é possível obter todos os valores retornados por uma
função.
Quando se avalia uma lista de expressões, somente será obtido o primeiro valor de
retorno de cada membro da lista, com exceção da última expressão, que pode
retornar múltiplos valores normalmente. O uso abaixo da função f definida
anteriormente ilustra este caso:
a, b, c, d = f (1, 2), f (3, 4), f (5, 6)print (a, b, c, d) -- imprime 3 7 11 30
Notou-se que a chamada f(1,2) retornou apenas o valor 3, o mesmo aconteceu
para f(3,4), que retornou o valor 7. Já a chamada f(5,6), por ser a última
expressão da lista de expressão, retornou dois valores, 11 e 30.
Às vezes, faz-se necessário que uma chamada de função retorne somente um valor,
não importando se a chamada de função faz parte de uma lista de expressões ou
não. Nesse caso, deve-se colocar parênteses ao redor da chamada de função,
limitando o número de valores de retorno da função a no máximo 1, como no
exemplo a seguir:
a, b = f (5, 10)print (a, b) -- imprime 15 50a, b = (f (5, 10))
print (a, b) -- imprime 15 nila, b, c = f (1, 2), (f (3, 4))print (a, b, c) -- imprime 3 7 nil
1.7.2.7 Userdata
Este tipo é um dado do host, representado por um ponteiro void*. São utilizados
para armazenar dados C em variáveis Lua. A criação e alteração do userdata só
pode ser feita por meio da API de Lua em C.
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 24/38
24
Um objeto do tipo userdata , da mesma forma que uma tabela, somente éigual a ele mesmo. Para ilustrar o uso de userdata , vamos definir em C umaestrutura que irá representar um buffer circular.
typedef struct CircBuffer {
int start, end;int n, size;int array [1];} CircBuffer;
As variáveis start e end guardam, respectivamente, as posições de início efim do buffer. A variável n irá armazenar o número de elementos atualmenteno buffer, ao passo que size representa o número máximo de elementosque o buffer pode armazenar. A variável array representa o buffer e seráinicializada com um tamanho adequado quando o buffer for criado.Inicialmente array possui tamanho 1, uma vez que não é possível criar umarray com tamanho 0 em C 89.
O trecho de código a seguir mostra a função que cria um novo buffercircular:
01 static int buffernew (lua_State *L) {02 int n;03 size_t bsize;04 CircBuffer *cb;0506 n = luaL_checkinteger (L, 1);07 luaL_argcheck (L, n >= 1, 1, "invalid buffer size");08 bsize = sizeof (CircBuffer) + (n - 1) * sizeof (int);09 cb = (CircBuffer *) lua_newuserdata (L, bsize);10
11 cb->size = n;12 cb->start = 0;13 cb->end = 0;14 cb->n = 0;1516 return 1;17 }
A função luaL_argcheck é útil para gerar mensagens de erro sobre algumargumento da função. O segundo parâmetro de luaL_argcheck é a condiçãoa ser testada, o terceiro parâmetro indica qual argumento está sendotestado e o último parâmetro especifica uma parte da mensagem de erro.Assumindo que buffer.new seja a função Lua equivalente para buffernew ,
no caso da chamada a seguir:
buffer.new (0)
teríamos a seguinte mensagem de erro:
stdin:1: bad argument #1 to 'new' (invalid buffer size)
(Lua – Conceitos Básicos e API C. LabLua, Agosto de 2008. Capítulo 9,páginas 56 e 57).
1.7.2.8 Thread
Os valores do tipo thread representam fluxos de execução independentes. São
utilizados em co-rotinas de Lua.
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 25/38
25
1.7.2.8.1 Co-rotinas
Co-rotinas são um poderoso mecanismo de programação para jogos. Uma
co-rotina é semelhante a um thread num sistema de multithreading , nosentido de que temos uma linha de execução com seu próprio ambientelocal (pilha de execução) compartilhando o ambiente global com outras co-rotinas. A grande diferença entre uma co-rotina e uma função é que aexecução de uma co-rotina pode ser suspensa e retomada posteriormente(no ponto em que foi suspensa). A diferença entre co-rotinas e threads éque, conceitualmente, diferentes threads executam simultaneamente,enquanto que num sistema com co-rotinas, apenas uma co-rotina executapor vez.As funções que manipulam co-rotinas estão agrupadas na tabelacoroutine. Criamos uma co-rotina passando uma função (em geral,anômina) para a função de criação, que retorna um valor do tipo thread:
local c = coroutine.create(function () ... end)print(type(c)) --> "thread"
(A Linguagem Lua e suas Aplicações em Jogos. Celes, Waldemar;Figueiredo, Luiz Henrique de; Ierusalimschy, Roberto. 2004 – Página: 11,tópico: 3.8).
1.7.3 Coerção
Lua possui alguns mecanismos de conversão automática de tipos. Qualquer
operação aplicada sobre uma string há uma tentativa de conversão dela em um
valor numérico correspondente. Ou seja, se a string contém um valor numérico,
então este valor é assumido na operação aritmética. Quando esta conversão não for
possível, um erro é reportado pela linguagem. Portando, o código:
b = "53"c = 2 + b
resulta no armazenamento do valor numérico 55 na variável c.
Já quando se utiliza um valor numérico onde deveria conter uma string, por exemplo,uma concatenação, este valor é convertido para uma cadeia de caracteres. Assim, o
código:
print("resultado: " .. 23)
tem como saída uma string:
resultado: 23.
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 26/38
26
Existem funções pré-definidas para as conversões anteriores sejam feitas
explicitamente, o tonumber para conversão de string para forma numérica e
tostring para converter um valor numérico para uma cadeia de caracteres.
1.8 EXPRESSÕES E ATRIBUIÇÃO
1.8.1 Operadores
Os operadores oferecidos por Lua são basicamente os aritméticos, relacionais e
lógicos usuais, comumente encontrados em outras linguagens. Lua também alguns
operadores especiais, como para concatenação de strings.
1.8.1.1 Aritméticos
Os operadores aritméticos presentes em Lua são:
Unários:- Negação
Binários+ Adição- Subtração* Multiplicação/ Divisão^ Exponenciação
Para precedência de operadores pode-se utilizar dos parênteses.
Os operadores aritméticos só poderão ser aplicados sobre valores do tipo numberou string, se este estiver convertida para número através de coerção.
1.8.1.2 Relacionais
Os operadores relacionais resultam em um valor booleano e incluem:
> Maior que
< Menor que>= Maior ou igual que<= Menor ou igual que== Igualdade
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 27/38
27
~= Diferença
Os operadores >, <, >=, <= são aplicáveis apenas a dados do tipo number ou string.
1.8.1.3 Lógicos
Combinam valores booleanos e são dados por:
and Conjunção (e)or Disjunção (ou)
not Negação
As conjunções ou disjunções múltiplas são avaliadas da esquerda para direita.
1.8.1.4 Operador de concatenação
Como dito acima e anteriormente no tópico “String”, Lua tem um operador para
concatenação de cadeias de caracteres, o qual é representado por dois pontos
seguidos (..). Quando aplicado a dois valores do tipo string, este retorna uma
terceira string que correspondente a união das outras cadeias originais.
1.8.1.5 Precedência dos operadores
A precedência dos operadores é usual. Como dito anteriormente, o uso dos
parênteses é permitido, para alterar a ordem de precedência natural. A ordem de
precedência de operadores está listada abaixo em ordem decrescente:
^not -(unário)* /+ -..
< > <= ~= ==and or
1.8.2 Estruturas de Controle
1.8.2.1 If
O if é a estrutura de controle básica de Lua. Caso a condição do if seja verdaira, o
comando do then é executado, caso contrário, a parte else é executada. A seguir um
exemplo de uso do if.
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 28/38
28
local x = 44if x > 30 then
print ("maior que 30")elseif x > 20 then
print ("maior que 20")elseif x > 10 then
print ("maior que 10")else
print ("que x pequeno")end
1.8.2.2 While
O while é uma das estruturas de repetição presentes na linguagem Lua. Caso a
condição do laço seja verdadeira, o bloco é executado e a condição avaliada
novamente, o laço só termina quando a condição não é satisfeita. O uso do while
está ilustrado abaixo:
local i = 0while i < 10 do
print (i)i = i + 1
end
1.8.2.3 RepeatDiferente do while, pois a tomada de decisão é no fim, o repeat pode ser assim
expressado:
f = 1 -- valor do fatorial i = 1 -- controle do laço repeatf = f * ii = i + 1until i > n peat
Onde o bloco é executado pelo menos uma vez, até o valor verdadeiro da expressão
seja encontrado.
1.8.2.4 For
Em Lua existem dois tipos de for: o numérico e o genérico.
1.8.2.4.1 For numérico
A sintaxe do for numérico é a seguinte:
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 29/38
29
for var=exp1, exp2, exp3 docorpo_do_la_co
end
Onde exp1 é o valor inicial de var e o corpo do laço será executado enquanto var
for menor ou igual a exp2, no caso do passo positivo, e maior igual a exp2, caso o
passo seja negativo. A expressão exp3 representa o passo do laço. Quando o
passo não é especificado, ele assume o valor 1. Um exemplo abaixo:
for i=1, 10 do print (i) end
for i=10, 1, -1 do print (i) end
A variável var é visível apenas dentro do laço e não deve ser alterada.
1.8.2.4.2 For genérico
O for genérico é usado para percorrer valores retornados por uma função iteradora.
O principais iteradores fornecidos por Lua são o pairs , para percorrer as chaves da
tabela, ipairs para percorrer os índices de um array (citados anteriormente) e io.lines ,
para percorrer as linhas de um arquivo.Um exemplo: seja a um array, é possível imprimir todos os seus valores com uso de
um for genérico:
for i, v in ipairs (a) do -- i guarda o índice, v o valorprint (v)
end
1.8.2.5 Break e return
São comandos utilizados para sair de um bloco de programa. O break é mais
utilizado em laços, pois permite encerrar a execução do laço.
O return permite retornar valores de uma função ou terminar a execução de uma.
Em Lua, este comando pode receber múltiplos argumentos, retornando mais de um
valor.
Os comandos return ou break devem são restritos ao uso no final do bloco, portanto
o código que segue não compilará por esse motivo:
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 30/38
30
i = 5while i < 10 do
break -- Erro! break deve ser o último comando do bloco
i = i + 1 --Atribuição é o último comando do bloco "while"end
As soluções para correção possíveis são a reordenação do código ou o uso de um
novo bloco do-end ao redor do comando, como abaixo:
i = 5while i < 10 do
dobreak -- Ok! break agora é o último comando do bloco
endi = i + 1 -- Atribuição é o último comando do bloco "while"end
1.9 Biblioteca padrão Lua
Junto de sua distribuição oficial, Lua inclui um conjunto de bibliotecas paraimplementação de funções para criação de programas. As funções de cada
biblioteca são agrupadas em tabelas, com exceção da biblioteca “básica”.
Algumas das bibliotecas padrões inclusas na distribuição estão listadas abaixo:
string: funções para manipulação de cadeia de caracteres;
table: oferece funções para manipulação de tabelas. Algumas de suas
funções são: table.insert, para inserção de elemento na tabela etable.remove para remoção;
math: oferece funções matemáticas, similar à biblioteca matemática de C.
São algumas das funções: math.sqrt (para cálculo de raiz quadrada),
math.log (logaritmo de um número), math.pow (potenciação),
math.cos (retorna o cosseno), math.abs (para retorno de um valor
absoluto);
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 31/38
31
io: funções para entrada e saída. Como o io.open, io.close, io.read e
io.white (que são utilizados para abrir, fechar, ler e escrever um arquivo,
nesta ordem);
os: funções relacionadas ao sistema operacional. Por exemplo:
os.clock (aproximação de quantidade de tempo de CPU, em segundos,
utilizada pelo programa), os.date (cadeia ou tabela contendo data e
hora, formatada de acordo com a chamada);
debug: funções para depuração de códigos Lua. Oferece funções que
permitem, por exemplo, fazer a consulta do estado corrente da pilha de
execução de Lua.
1.10 Programar em Lua
Regida pela licença MIT, do Instituto de Tecnologia de Massachusetts, Lua permite
alterações do código-fonte e dá liberdade para criação de qualquer aplicação
usando a linguagem sem a necessidade de mostrar o código, a única condição é a
menção do copyright dos criadores e da PUC-Rio.
Em entrevista ao Jornal do Brasil de 2004, o norte-americano Curt Carpenter de 35
anos que trabalha na linha de Novos Produtos Para o Consumidor da Microsoft e
também é usuário de Lua ele afirma: “Ela (Linguagem Lua) é de aprendizagem
simples e por isso não aconselho uma especificação em Lua sem conhecer outras
linguagens como C e C++.”.
O jornal conclui a matéria: “Se trabalhar com Lua pode ser um objetivo a perseguir,
aprender a linguagem ainda é um desafio. Embora ela seja simples, não há uma
estrutura didática formal. A PUC-Rio oferece uma matéria eletiva, mas não há um
curso que atenda a um grupo maior de interessados.”.
Outra barreira que os interessados em Lua encontram são os artigos e arquivos da
linguagem, que na maioria são da língua inglesa, inclusive o manual de Lua, que foi
publicado e encontra-se à venda apenas no site Amazon, dos EUA. Segundo
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 32/38
32
Ierusalimschy, ninguém no país se interessou por publicar o manual em português,
mas no site há uma tradução (http://www.lua.org/manual/5.1/pt/manual.html).
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 33/38
33
1.11 CONCLUSÃO
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 34/38
34
1.12 ANEXOS
1.12.1 ANEXO IE-mail de um dos produtores da Lucas Art‟s elogiando a linguagem e a adotando no
lugar da SCUMM para desenvolvimento dos games.
1.12.2 ANEXO II
Homenagem da Lucas Art‟s. No game “Escape from Monkey Island” o jogador deve
entrar em um bar, este recebe o nome da linguagem: “LUA Bar”
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 35/38
35
1.12.3 ANEXO III
Site TIOBE SOFTWARE – Linguagens de Programação mais populares(Novembro de 2010)
Disponível em: http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html. Acesso em 15 deNovembro de 2010.
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 36/38
36
1.12.4 ANEXO IV
Site da HOPL - Linguagem Lua na HOPL III de 2007
Disponível em: http://research.ihost.com/hopl/HOPL-III.html. Acesso em: 20 de Novembro de 2010.
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 37/38
37
1.13 REFERÊNCIAS
Noções de Lua 3.1 - Noções básicas da linguagem de programação Lua.Extraído de “Programando em Lua – Teoria e Prática (versão 2.1)” e
“Linguagem de Extensão Lua” por Waldemar Celes, Luiz Henrique Figueiredoe Roberto Ierusalimschy. Versão 3.1 atualizada por Roberto de BeuclairSeixas baseado no texto de Anna Magdalena Hester. 1998.
Lua - Conceitos Básicos e API C. LabLua – Agosto de 2008. A Linguagem Lua e suas Aplicações em Jogos. Cales, Waldemar;
Figueiredo, Luiz Henrique de; Ierusalimschy, Roberto. 2004. Uma Introdução à Programação em Lua. Ierusalimschy, Roberto. 2009. Manual de Referência de Lua 5.1. (Ierusalimschy, Roberto; Figueiredo, Luiz
Henrique de; Celes, Waldemar). Versão traduzida por Medeiros, Sérgio
Queiroz de; com apoio da Fábrica Digital e da FINEP – 2008. Disponível em:http://www.lua.org/manual/5.1/pt/manual.html. Acesso em: 20 de Outubro de2010.
Portal da Linguagem na internet: http://www.lua.org/portugues.html. Acessoem: 18 de Outubro de 2010.
Página de downloads da Linguagem Lua: http://www.lua.org/download.html. Acesso em: 21 de Outubro de 2010.
TeCGraf: http://www.tecgraf.puc-rio.br/ . Acesso em: 21 de Outubro de 2010. TIOBE Software:
http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html. Acesso em:15 de Novembro de 2010. Revista PROGRAMAR. ISSN 1647-0710. Edição nº 8 de Maio de 2007 -
páginas 23 a 25 e edição nº 22 de Novembro de 2009 – páginas 17 a 20.Disponível em: www.portugal-a-programar.org.
Revista Espírito Livre. Edição nº 1 de Abril de 2009 – páginas 17 a 20.Disponível em: http://revista.espiritolivre.org.
INTRO – Fit for business. http://www.itpro.co.uk/623587/could-your-next-it-project-come-from-brazil/4. Acesso em: 5 de Novembro de 2010.
Dr. Dobb’s. http://www.drdobbs.com/architecture-and-design/205600791. Acesso em: 5 de Novembro de 2010. Universia. http://universia.com.br/materia/materia.jsp?id=861. Acesso em: 5
de Novembro de 2010. Info EXAME Online. http://info.abril.com.br/professional/desenvolvimento/o-
mundo-se-rende-a-brasileira-lua.shtml. Acesso em: 06 de Novembro de 2010. Lua Press clippings. http://www.lua.org/press.html. Acesso em: 30 de
Outubro de 2010. A linguagem Lua – Características das Linguagens de programação.
Yanagisawa, Rodrigo da S. A Implementação de Lua 5.0. Ierusalimschy, Roberto. PUC – Rio. Disponível
em: http://www.lua.org.
5/10/2018 Linguagem Lua - slidepdf.com
http://slidepdf.com/reader/full/linguagem-lua 38/38
38
A Evolução de Lua. Ierusalimschy, Roberto. PUC – Rio - 2007. Disponívelem: http://www.lua.org.
The evolution of Lua. Ierusalimschy, Roberto; Figueiredo, Luiz Henrique de;
Celes, Waldemar à HOLP III, San Diego 2007. Disponível em:http://www.lua.org. HOPL. http://research.ihost.com/hopl/HOPL-III.html. Acesso em: 20 de
Novembro de 2010.
* Todos os exemplos da sintaxe de Lua inclusos neste trabalho são
reprodução fiel dos que constam nas fontes aqui citadas, portanto todos os
direitos autorais estão reservados a estas. Em momento algum ouve a
intenção de infringi-los, foram adotados e reproduzidos por questões
didáticas.