38
 1 FAESA FUNDAÇÃO DE ASSISTÊNCIA E EDUCAÇÃO FACULDADES INTEGRADAS ESPÍRITO-SANTANSES UNIDADE DE COMPUTAÇÃO E SISTEMAS GUTHIERRY FERREIRA ALMEIDA LEON PEDROSA DE MEIRELLES PAULO HENRIQUE RODRIGUES ORIND LINGUAGEM DE PROGRAMAÇÃO LUA VITÓRIA/ES 2010

Linguagem Lua

Embed Size (px)

Citation preview

Page 1: 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

Page 2: Linguagem Lua

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.

Page 3: Linguagem Lua

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

Page 4: Linguagem Lua

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

Page 5: Linguagem Lua

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.

Page 6: Linguagem Lua

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.

Page 7: Linguagem Lua

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:

Page 8: Linguagem Lua

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.

Page 9: Linguagem Lua

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;

Page 10: Linguagem Lua

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:

Page 11: Linguagem Lua

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.

Page 12: Linguagem Lua

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

Page 13: Linguagem Lua

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

Page 14: Linguagem Lua

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

Page 15: Linguagem Lua

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:

Page 16: Linguagem Lua

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

Page 17: Linguagem Lua

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.

Page 18: Linguagem 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 

Page 19: Linguagem Lua

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

Page 20: Linguagem Lua

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:

Page 21: Linguagem Lua

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:

Page 22: Linguagem Lua

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

Page 23: Linguagem Lua

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.

Page 24: Linguagem Lua

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.

Page 25: Linguagem 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.

Page 26: Linguagem Lua

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

Page 27: Linguagem Lua

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.

Page 28: Linguagem Lua

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: 

Page 29: Linguagem Lua

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:

Page 30: Linguagem Lua

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);

Page 31: Linguagem Lua

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

Page 32: Linguagem Lua

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).

Page 33: Linguagem Lua

5/10/2018 Linguagem Lua - slidepdf.com

http://slidepdf.com/reader/full/linguagem-lua 33/38

33

1.11 CONCLUSÃO 

Page 34: Linguagem Lua

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” 

Page 35: Linguagem Lua

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.

Page 36: Linguagem Lua

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.

Page 37: Linguagem Lua

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. 

Page 38: Linguagem Lua

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.