Linguagem Lua

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

2

GUTHIERRY FERREIRA ALMEIDA LEON PEDROSA DE MEIRELLES PAULO HENRIQUE RODRIGUES ORIND

LINGUAGEM DE PROGRAMAÇÃO LUA

Trabalho acadêmico apresentado ao Curso de Ciência da Computação, FAESA, como parte das exigências da disciplina de Linguagem de Programação I sob orientação da professora Cinthia C. L .Caliari.

VITÓRIA/ES 2010

3

SUMÁRIO 1. Linguagem Lua .......................... ............ .......................... .......................... ........................... .......................... .......................... ................. .... 5 1.1. Introdução................................................................................................. Introdução................................................................................................. 5 1.2. História ..................................................................................................... 6 1.3. Importância ............................................................................................... 7 1.4. Aplicações ............................................................................................... 7 1.5. Características Principais ......................................................................... 10 1.5.1. Domínio de programação ................................................................ 10 1.5.2. Paradigma .......................... ............. .......................... .......................... .......................... .......................... ...................... ......... 10 1.5.3. Sintaxe ............................................................................................ 10 1.6. Diferenciais ............................................................................................... 11 1.6.1. Portabilidade ................................................................................... 11 1.6.2. Simplicidade .......................... ............ .......................... .......................... .......................... .......................... .................... ...... 11 1.6.3. Pequeno Tamanho .......................... ............. .......................... ........................... .......................... ..................... ......... 11 1.6.4. Acoplabilidade ......................... ............ .......................... .......................... .......................... .......................... ................. .... 11 1.6.5. Eficiência .......................... ............. .......................... .......................... .......................... .......................... ........................ ........... 12 1.7. Valores e Tipos ......................................................................................... 12 1.7.1. Variáveis Locais .............................................................................. 12 1.7.2. Tipos ............................................................................................... 13 1.7.2.1. Nil .......................... ............. .......................... .......................... .......................... .......................... ........................ ........... 13 1.7.2.2. Boolean .......................... ............. .......................... .......................... .......................... .......................... ................. 14 1.7.2.3. Number ......................... ............ .......................... .......................... .......................... .......................... ................. .... 14 1.7.2.4. String .......................... ............ .......................... .......................... .......................... .......................... .................... ...... 15 1.7.2.4.1. Concatenação ......................... ............ .......................... .......................... ...................... ......... 15 1.7.2.5. Table........................... ............. .......................... .......................... .......................... .......................... .................... ...... 16 1.7.2.5.1. Inicialização de tabelas ........................... .............. .......................... ................... ...... 18 1.7.2.5.1.1. Via indexação consecutiva .......................... ............. ................. .... 18 1.7.2.5.1.2. Via atribuição de campos .......................... ............. ................... ...... 19 1.7.2.5.1.3. Inicialização mista .......................... ............. .......................... ................. .... 19 1.7.2.6. Function .......................... ............. .......................... .......................... .......................... .......................... ................. 21 1.7.2.6.1. Declarando e chamando uma função ........................ ............. ........... 21 1.7.2.6.2. Número varável de parâmetros .......................... ............. ..................... ........ 22 1.7.2.6.3. Retorno de um único valor .......................... ............. .......................... ................. 23 1.7.2.7. Userdata ......................... ............ .......................... .......................... .......................... .......................... ................. 23 1.7.2.8. Thread .......................... ............. .......................... .......................... .......................... .......................... ................. .... 24 1.7.2.8.1. Co-rotinas............................ Co-rotinas............... .......................... .......................... .......................... ............. 25 1.7.3. Coerção .......................... ............. .......................... .......................... .......................... .......................... .......................... ............. 25 1.8. Expressões e Atribuições ......................................................................... 26 1.8.1. Operadores ..................................................................................... 26 1.8.1.1. Aritméticos .......................... ............. .......................... .......................... .......................... ........................ ........... 26 1.8.1.2. Relacionais ......................... ............ .......................... .......................... .......................... ........................ ........... 26 1.8.1.3. Lógicos ......................... ............ .......................... .......................... .......................... .......................... ................. .... 27 1.8.1.4. Operador de concatenação .......................... ............. .......................... ........................ ........... 27

4

1.8.1.5. Precedência de operadores.......................... ............. .......................... ........................ ........... 27 1.8.2. Estruturas de controle ..................................................................... 27 1.8.2.1. If............................................................................................ If............................................................................................ 27 1.8.2.2. While........................... ............. .......................... .......................... .......................... .......................... .................... ...... 28 1.8.2.3. Repeat .......................... ............. .......................... .......................... .......................... .......................... ................. .... 28 1.8.2.4. For ......................... ............ .......................... .......................... .......................... .......................... ........................ ........... 28 1.8.2.4.1. For numérico ......................... ............ .......................... .......................... ........................ ........... 28 1.8.2.4.2. For genérico .......................... ............. .......................... ........................... ........................ .......... 29 1.8.2.5. Break e return ......................... ............ ........................... ........................... .......................... ................... ...... 29 1.9. Biblioteca padrão Lua ......................... ............ .......................... .......................... .......................... .......................... ................. 30 1.10. Programar em Lua .......................... ............. .......................... ........................... .......................... ..................... ......... 31 1.11. Conclusão .......................... ............. .......................... .......................... .......................... .......................... ...................... ......... 33 1.12. Anexos ......................... ............ .......................... .......................... .......................... .......................... .......................... ................. 34 1.12.1. Anexo I ......................... ............ .......................... .......................... .......................... .......................... ................. .... 34 1.12.2. Anexo II .......................... ............. .......................... .......................... .......................... .......................... ................. 34 1.12.3. Anexo III ......................... ............ .......................... .......................... .......................... .......................... ................. 35 1.12.4. Anexo IV ......................... ............ .......................... .......................... .......................... .......................... ................. 36 1.13. Referências .......................... ............. .......................... ........................... .......................... ..................... ......... 37

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.

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ção Grá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 iniciavase 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 via registradores e novo algoritmo para tabelas.

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

(ANEXO I), logo após publicação do artigo na “Dr. Dobb‟s”, está também em “FarCry”, “World of WarCraft”, 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. “Lucas Arts”

Outra pesquisa (ANEXO III) de novembro de 2010 da TIOBE Software aponta a linguagem 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 o seu 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 t eve grande aceitação em jogos, são os principais:

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.

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” – “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 l ayout 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 utilizadas para tal;

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 Lu a, 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:

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.

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 na linguagem 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

13

if a > 0 then local b = a –- cria variável local b a = a + 1 –- incrementa a variável global a local 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

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 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 = 4 b = 4.0

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 \t \r \v \f \xxx \a \b \" \' \\

new line Tab carriage return vertical tab form feed caracter com código decimal xxx bell 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 de tratá-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 no exemplo abaixo:

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 de caracteres. 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 programa anterior 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, representam um 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

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] = 13 t[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" "exemplificando" t[2.34] = 12 t.tabela, t[0] = 3, 12 t[-234] = 0 a = "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"]. exemplo, t[a] corresponde a t.Lua.

Assim, no

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 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] = 23 t[2] = 45 t[3] = -7 t[4] = "Lua" t[5] = 6+4

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.0 t.[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} Lua",versao=3.0,[4]=80}

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

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: 3 table.insert (t, "d") print (#t) --valor impresso: 4 t [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 11 print (#t) -- ?? t [5] = "e" -- Agora o array não tem "buracos" e o operador # retorna o -- valor esperado print (#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 a nil 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. de tabelas. Por exemplo, um ponto 3D, dado pelas suas coordenadas. Em Lua, pode-se escrever: Lua permite a especificação de um “construtor” na criação

21

local p = Point{x=3.0,y=1.3,z=3.2} 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} 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, podese, por exemplo, validar e inicializar campos do objeto, desta forma: function Point (self) self.x = tonumber(self.x) or 0.0 self.x = tonumber(self.y) or 0.0 self.x = tonumber(self.z) or 0.0 return 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. f unçõ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:

22

function f (a, b) local x = a or 1 -- x recebe o valor padrão 1 quando a é -- um valor falso local y = b or 1 -- y recebe o valor padrão 1 quando b é -- um valor falso return 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, print (s, p) s, p = f (2) print (s, p) s, p = f (2, print (s, p) print (f ())

4)-- a é 3 -- imprime -- b é nil -- imprime 5, 8) -- 8 -- imprime -- imprime

e 7 e 3 é 7 2

b é 4 12 y é inicializado com 1 2 descartado 10 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 i mprime aquelas com tamanho maior do que 3.

FIGURA 3 – Função com número variável de parâmetros

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 r etorne 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 a, b = (f (5, 10)) print (a, b) -- imprime 15 a, b, c = f (1, 2), (f (3, print (a, b, c) -- imprime

50 nil 4)) 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.

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 uma estrutura 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 e fim do buffer. A variável n irá armazenar o número de elementos atualmente no buffer, ao passo que size  representa o número máximo de elementos que 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 um array com tamanho 0 em C 89. O trecho de código a seguir mostra a função que cria um novo buffer circular: 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17

static int buffernew (lua_State *L) { int n; size_t bsize; CircBuffer *cb; n = luaL_checkinteger (L, 1); luaL_argcheck (L, n >= 1, 1, "invalid buffer size"); bsize = sizeof (CircBuffer) + (n - 1) * sizeof (int); cb = (CircBuffer *) lua_newuserdata (L, bsize); cb->size = n; cb->start = 0; cb->end = 0; cb->n = 0; return 1; }

A função luaL_argcheck  é útil para gerar mensagens de erro sobre algum argumento da função. O segundo parâmetro de luaL_argcheck é a condição a ser testada, o terceiro parâmetro indica qual argumento está sendo testado 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.

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 , no sentido de que temos uma linha de execução com seu próprio ambiente local (pilha de execução) compartilhando o ambiente global com outras corotinas. A grande diferença entre uma co-rotina e uma função é que a execuçã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 executa por vez. As funções que manipulam co-rotinas estão agrupadas na tabela coroutine. 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)) 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: print("resultado: " .. 23)

tem como saída uma string:

resultado: 23 .

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

+ * / ^

Adição Subtração Multiplicação Divisão Exponenciação

Binários

Para precedência de operadores pode-se utilizar dos parênteses. Os operadores aritméticos só poderão ser aplicados sobre valores do tipo number ou 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: > < >= , =, 30 then print ("maior elseif x > 20 then print ("maior elseif x > 10 then print ("maior else print ("que x end

que 30") que 20") que 10") pequeno")

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 = 0 while i < 10 do print (i) i = i + 1 end

1.8.2.3 Repeat Diferente 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 repeat f = f * i i = i + 1 until 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:

29

for var=exp1, exp2, exp3 do corpo_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 valor print (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:

30

i = 5 while 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 = 5 while i < 10 do do break -- Ok! break agora é o último comando do bloco end i = i + 1 -- Atribuição é o último comando do bloco "while" "while" end

1.9 Biblioteca padrão Lua Junto de sua distribuição oficial, Lua inclui um conjunto de bibliotecas para implementaçã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 e table.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 math.cos

absoluto);

(logaritmo de um

número), math.pow (potenciação),

(retorna o cosseno), math.abs (para retorno de um valor

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

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 http://www.lua.org/manual/5.1/pt/manual.html)).

33

1.11 CONCLUSÃO

34

1.12 ANEXOS

1.12.1 ANEXO I E-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”

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 http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html.. Acesso em 15 de Novembro de 2010.

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 http://research.ihost.com/hopl/HOPL-III.html.. Acesso em: 20 de Novembro de 2010.

37

1.13 REFERÊNCIAS 

Noções de Lua 3.1 - Noções básicas da linguagem de programação Lua. 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 Figueiredo

 

 





 



















e Roberto Ierusalimschy. Versão 3.1 atualizada por Roberto de Beuclair Seixas baseado no texto de Anna Magdalena Hester. 1998. Lua - Conceitos Básicos Básicos e API 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 de http://www.lua.org/manual/5.1/pt/manual.html 2010. Portal da Linguagem na internet: http://www.lua.org/portugues.html http://www.lua.org/portugues.html.. Acesso em: 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. http://www.lua.org/download.html 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 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 http://revista.espiritolivre.org.. INTRO  – Fit for business. http://www.itpro.co.uk/623587/could-your-next-itproject-come-from-brazil/4.. Acesso em: 5 de Novembro de 2010. project-come-from-brazil/4 Dr. Dobb’s. http://www.drdobbs.com/architecture-and-design/205600791.. 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 http://universia.com.br/materia/materia.jsp?id=861.. Acesso em: 5 de Novembro de 2010. Info EXAME Online. Online. http://info.abril.com.br/professional/desenvolvimento/omundo-se-rende-a-brasileira-lua.shtml.. Acesso em: 06 de Novembro de 2010. mundo-se-rende-a-brasileira-lua.shtml Lua Press clippings. http://www.lua.org/press.html 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 http://www.lua.org..

38







A Evolução de Lua. Ierusalimschy, Roberto. PUC  – Rio - 2007. Disponível em: http://www.lua.org 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.. http://www.lua.org http://research.ihost.com/hopl/HOPL-III.html.. Acesso em: 20 de HOPL. http://research.ihost.com/hopl/HOPL-III.html 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.