Você está na página 1de 38

1

FAESA FUNDAO DE ASSISTNCIA E EDUCAO FACULDADES INTEGRADAS ESPRITO-SANTANSES UNIDADE DE COMPUTAO E SISTEMAS

GUTHIERRY FERREIRA ALMEIDA LEON PEDROSA DE MEIRELLES PAULO HENRIQUE RODRIGUES ORIND

LINGUAGEM DE PROGRAMAO LUA

VITRIA/ES 2010

GUTHIERRY FERREIRA ALMEIDA LEON PEDROSA DE MEIRELLES PAULO HENRIQUE RODRIGUES ORIND

LINGUAGEM DE PROGRAMAO LUA

Trabalho acadmico apresentado ao Curso de Cincia da Computao, FAESA, como parte das exigncias da disciplina de Linguagem de Programao I sob orientao da professora Cinthia C. L .Caliari.

VITRIA/ES 2010

SUMRIO 1. Linguagem Lua ............................................................................................... 5 1.1. Introduo................................................................................................. 5 1.2. Histria ..................................................................................................... 6 1.3. Importncia ............................................................................................... 7 1.4. Aplicaes ............................................................................................... 7 1.5. Caractersticas Principais ......................................................................... 10 1.5.1. Domnio de programao ................................................................ 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. Eficincia ......................................................................................... 12 1.7. Valores e Tipos......................................................................................... 12 1.7.1. Variveis 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. Concatenao ............................................................ 15 1.7.2.5. Table ..................................................................................... 16 1.7.2.5.1. Inicializao de tabelas .............................................. 18 1.7.2.5.1.1. Via indexao consecutiva .............................. 18 1.7.2.5.1.2. Via atribuio de campos ................................ 19 1.7.2.5.1.3. Inicializao mista ........................................... 19 1.7.2.6. Function ................................................................................ 21 1.7.2.6.1. Declarando e chamando uma funo ........................ 21 1.7.2.6.2. Nmero varvel de parmetros .................................. 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................................................................... 25 1.7.3. Coero........................................................................................... 25 1.8. Expresses e Atribuies ......................................................................... 26 1.8.1. Operadores ..................................................................................... 26 1.8.1.1. Aritmticos ............................................................................ 26 1.8.1.2. Relacionais ........................................................................... 26 1.8.1.3. Lgicos ................................................................................. 27 1.8.1.4. Operador de concatenao .................................................. 27

1.8.1.5. Precedncia de operadores .................................................. 27 1.8.2. Estruturas de controle ..................................................................... 27 1.8.2.1. 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 numrico .............................................................. 28 1.8.2.4.2. For genrico ............................................................... 29 1.8.2.5. Break e return ....................................................................... 29 1.9. Biblioteca padro Lua ............................................................................... 30 1.10. Programar em Lua .......................................................................... 31 1.11. Concluso ....................................................................................... 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. Referncias .......................................................................... 37

LINGUAGEM DE PROGRAMAO LUA 1.1 INTRODUO nica linguagem de aceitao mundial desenvolvida fora do eixo EUA Europa Japo, Lua, foi criada em 1993 no Brasil e se destaca pelo poder, simplicidade e rapidez. Lua foi projetada para estender aplicaes, totalmente tipada dinamicamente, interpretada e tem gerenciamento automtico de memria com coletor de lixo incremental. Essas e outras caractersticas fazem dela uma linguagem ideal para configurao e automao (Scripting). Por tambm ser de licena 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, alm da presena em empresas importantes como o Incor, Intel, Microsoft e NASA, por exemplo.

1.2 HISTRIA Em 1992, em um projeto entre a PUC-Rio (Pontifcia Universidade Catlica do Rio de Janeiro) e a Petrobras, surgiu o TeCGraf (Grupo de Tecnologia em Computao Grfica), a princpio baseava-se na construo de interfaces grficas para programas de simulao. Para tal era utilizada DEL (Linguagem para Especificao de Dilogos), que apresentava algumas limitaes. Um ano depois, em novo projeto com a Petrobras foi criado o PGM (Programa Grfico Mestre), utilizado para visualizao de perfis geolgicos. A linguagem SOL (Simple Object Language) estava sendo utilizada, mas tambm 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 soluo, precisavam de uma linguagem de configurao genrica, completa, facilmente acoplvel, porttil, de boa sintaxe e que fosse simples, e neste mesmo ano, 1993, a soluo: Lua. O nome, segundo Ricardo, seria uma sugesto de um amigo, j que eles estavam abandonando o projeto de SOL. A primeira verso de Lua (1.0), a posteriori, data de julho de 1993, mas a primeira verso pblica (1.1) s veio em julho de 1994 era mais eficiente. Distribuda publicamente pela internet, Lua era de licena livre para uso acadmico e restritiva para uso comercial, foi quando comearam os problemas com a concorrncia (Perl, Python,...). Lua 2 (Lua 2.1, de fevereiro de 1995 a Lua 2.5 de novembro de 1996) foi a primeira verso com licena free software, nesta verso 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. Dobbs, artigos estes importantssimos para divulgao da linguagem e em 1997 Lua premiada com o prmio COMPAQ, ano em que iniciavase as verses 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 cdigo escrito em clean C interseo entre as linguagens C e C++ -, alm de maior eficincia. Em Lua 5 houve a implantao de co-rotinas e de um for genrico (via geradores), melhoria da visibilidade lxica, maior facilidades para mdulos, alm da implementao de uma mquina virtual via registradores e novo algoritmo para tabelas.

FIGURA 1 Logomarca da Linguagem Lua

Hoje, na verso 5.1 (verso beta 5.2 lanada 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 apario nesta indstria de que se tem notcia foi no game Grim Fandango da Lucas Arts (ANEXO I), logo aps publicao do artigo na Dr. Dobbs, est tambm em FarCry, World of WarCraft, The Sims 2, Baldurs Gate e Amped. Mas no 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 a linguagem brasileira entre as 30 linguagens de programao 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 IMPORTNCIA Lua tem importncia global. Alm de vrias aplicaes no mundo inteiro, em 2007 o seu projeto e evoluo foram apresentados na HOPL III, 3 Conferncia da ACM sobre a Histria das Linguagens de Programao (ANEXO IV) tal conferncia s acontece uma vez a cada 15 anos e h apresentao 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 APLICAES Como j dito, Lua teve grande aceitao em jogos, so os principais:

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

No mercado de softwares em geral: Ginga NCL middleware padro brasileiro para TV Digital; Wireshark analisador de protocolos; Snort deteco de intrusos e proteo do sistema; Adobe Lightroom gerenciador e organizador de imagens; nmap rastreador de redes para segurana; Eyeons Digital Fusion ps-produo de filmes; INPE biblioteca GIS; Olivetty firmware para impressoras; Omnitronix monitoramento remoto; RealTimeLogic servidores Web; APT-RPM, Conectiva padro para distribuies RPM; Publique! gerenciador de contedo para web; Sputnik wiki extensvel disponvel como software livre.

Empresas diversas e importantes tambm aderiram linguagem, empregando-a em aplicaes das mais variadas: Hands: uso no desenvolvimento de navegadores de contedo para micros de bolso; Incor (Instituto do Corao em So 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 criao de sua interface; Intel: empregada na ferramenta interna para layout de chips (processadores); Rob Crazy Ivan: Lua um dos componentes do seu crebro, responsvel, segundo fabricantes do rob, pela parte lgica. Ivan ganhou o concurso de inteligncia artificial da RoboCup 2000, concurso de robs realizado na Dinamarca; AXAF (Advanced X-ray Astrophysics Facility): terceiro dos grandes

observatrios espaciais lanados pela NASA, tem a tarefa de simular em imagens os sinais recebidos do espao, Lua uma das linguagens utilizadas para tal;

10

NASA: Lua foi a linguagem usada no controle dos nveis de concentrao de gases perigosos na preparao para o lanamento de nibus espacial. Petrobras: principal usuria, utilizando principalmente em visualizaes de perfis geolgicos.

1.5 CARACTERSTICAS PRINCIPAIS

1.5.1 Domnio de Programao Lua uma linguagem de scripting, ou de extenso. Linguagens com este domnio tem a finalidade de estender funcionalidades de aplicaes. Seu uso pode ser tanto como ferramentas de configurao e instalao em sistemas operacionais, como no Linux (tomsrtbt) que utiliza Lua, quanto nos games, no caso de Lua, em Baldurs Gate em que utilizada em comandos de debug mapeados e prompt para debug em tempo real, no ImpossibleCreatures em Controle de IA, aparncia de efeitos e de outros elementos grficos e tambm debug em tempo real, por exemplo.

1.5.2 Paradigma Lua de paradigma imperativo, que lhe d eficincia, paradigma bem estabelecido e eficincia. Mas oferece suporte para abstrao de dados, para programao Orientada a Objetos.

1.5.3 Sintaxe Escrita na interseo das linguagens C e C++, Lua de sintaxe convencional:

11

FIGURA 2 Funo 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 padro. 1.6.2 Simplicidade A linguagem Lua possui apenas um nico tipo de estrutura de dados, as tabelas e um nico tipo numrico, o number (tipicamente double), alm disso, utiliza de mecanismos ao invs de polticas, como a exemplo a orientao a objetos. 1.6.3 Pequeno tamanho Sua distribuio completa cabe confortavelmente em um disquete. Apesar de grandes recursos, incluir Lua numa aplicao no aumenta em quase nada o seu tamanho, pois o pacote com sua verso atual, contendo o cdigo-fonte, a documentao e exemplos, ocupa cerca de 212K comprimido e 860K descompactado. Com interface bem definida, o ncleo tem menos de 100K e apresenta bibliotecas independentes, ou seja, removveis.

1.6.4 Acoplabilidade Lua uma biblioteca em C, rpida e pequena, pode ser facilmente embutida a aplicaes. Apresenta API simples e bem definida, com operaes primitivas e modelo de pilha. possvel estender programas, no 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 Eficincia As execues de programas independentes mostram Lua entre as mais rpidas das linguagens interpretadas com tipagem dinmica. Pores substanciais de aplicaes grandes so 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 mquina (trash).

1.7 VALORES E TIPOS Em Lua, as variveis globais no precisam ser declaradas, ou seja, ao se escrever o comando: a = 1.5 significa que a varivel a global. Outra caracterstica fundamental que na linguagem as variveis no tem tipo associado, estes esto aos dados armazenados nela. A varivel a citada anteriormente adquiriu um tipo numrico e ao fazer posteriormente: a = "Lua" ela passa a armazenar uma string.

1.7.1 Variveis Locais A definio de escopo local de uma varivel pode ocorrer em qualquer lugar dentro de um bloco de comandos, e seu escopo termina quando o bloco em que foi declarada tambm termina. Declarar uma varivel local com mesmo nome de uma global obscurece temporariamente o acesso varivel global. Como exemplo, segue o cdigo abaixo: a = 2 - cria varivel global a

13

if a > 0 then local b = a - cria varivel local b a = a + 1 - incrementa a varivel global a local a = b - cria varivel local a print(a) end print(a) Em Lua os comentrios so feitos utilizando dois hifens seguidos (--). No primeiro print, imprime-se o valor 2, pois se refere a varivel 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 varivel a referida global. possvel ainda declarar e inicializar vrias variveis 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 variveis locais que no forem inicializadas assumem valor nil.

1.7.2 Tipos Existem oito tipos de dados em Lua: 1.7.2.1 Nil Nil; Boolean; Number; String; Table; Function; Userdata; Thread.

14

Representa o valor indefinido. Todas as variveis que ainda no foram inicializadas assumem o valor nil. Portanto no cdigo: a = b sem que haja qualquer atribuio varivel b, b passa a assumir o contedo de valor nil, o que significa que a passa a armazenar nil tambm, independentemente do valor anteriormente armazenado em a. A palavra reservada nil pode ser utilizada na programao para expressar o valor do tipo nil. Com isso: a = nil atribuindo o valor nil varivel a (a partir deste ponto, como se a varivel a ainda no tivesse sido atribuda). Tambm h como testar se uma varivel foi ou no inicializada, comparando seu valor com nil: a == nil. O nil tambm interpretado como falso numa expresso booleana.

1.7.2.2 Boolean Valor booleano, podendo ser falso (false) ou verdadeiro (true). Uma expresso ser considerada falsa caso seja igual nil, como dito anteriormente, ou verdadeira caso contrrio, inclusive quando igual a 0.

1.7.2.3 Number Lua no faz distino entre valores numricos com valores inteiros e reais, h um tipo para represent-los, o number, que ponto flutuante por padro, podendo representar um nmero inteiro de at 32 bits. Podendo ser feito: a = 4 b = 4.0

15

c = 0.4e1 d = 40e-1 armazenando o valor numrico quatro nas variveis 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 comea com aspas simples, ela deve terminar com aspas simples, do mesmo para as duplas. Os duplos colchetes so utilizados para cadeias que se estendem por vrias linhas. Esse tipo imutvel em Lua, toda vez que a cadeia alterada, na verdade, cria-se uma nova. Dentro de uma string so interpretadas as sequncias de escape: \n \t \r \v \f \xxx \a \b \" \' \\ new line Tab carriage return vertical tab form feed caracter com cdigo decimal xxx bell backspace aspas duplas () aspas simples () barra invertida (\)

No entanto, ao delimitar uma cadeia de caracteres com aspas duplas, por exemplo, pode-se utilizar de aspas simples no seu contedo sem que haja a necessidade de trat-la como sequncia de escape. Assim, so vlidas e equivalentes as seguintes atribuies: s = "olho d'agua" s = 'olho d\'agua' 1.7.2.4.1 Concatenao Para concatenar duas strings, utiliza-se do operador de concatenao (..), 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 so cadeias de caracteres. O objetivo escrever um programa que cria uma cadeia com todos os elementos de t separados por vrgulas 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 satisfatrio. Caso contrrio, a execuo do programa iria demorar mais do que o esperado. Como em Lua cada cadeia de caracteres nica, a criao de vrias novas cadeias um pouco custoso, de forma que possvel evit-la com uma soluo mais eficiente, atravs da funo table.concat, para concatenar vrias cadeias, recebendo uma tabela como primeiro parmetro 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) so a nica forma de estruturao de dados em Lua, representam um vetor associativo, implementado internamente com o uso de uma eficiente combinao de array e hash (tabela de disperso). Com as tabelas podem-se representar vetores, listas, filas, tabelas de smbolos, conjuntos, grafos, registros e hash. Uma varivel do tipo table pode ser indexada por valores de qualquer tipo, com exceo do tipo nil. Uma tabela deve ser explicitamente criada antes de ser usada, a criao feita pela expresso {}. Assim, o cdigo: t = { }, cria uma tabela vazia e armazena na

17

varivel de nome t. Da, a varivel t armazena um valor do tipo table e pode ento ser indexada. vlido escrever, por exemplo: t[1] = 13 t[45] = 56 No h limite para a indexao da tabela. Se necessrio, Lua redimensiona a tabela automaticamente. Alm disso, tambm 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 no seja uma palavra reservada da sintaxe da linguagem). Assim, a atribuio anterior t["nome"] = t[1]+2 pode ser escrita por t.nome = t[1]+2. Como dito, esta notao para string simples, portanto no possvel fazer o mesmo no exemplo abaixo, por se tratar de uma string composta: t[Rio de Janeiro"] = 1994 Tambm vlido escrever: t[t] = 5 que significa que a tabela t indexada pelo valor t (prpria tabela) armazena o valor numrico 5. As atribuies abaixo tambm so vlidas para a tabela t: t[10] = "exemplificando" t[2.34] = 12 t.tabela, t[0] = 3, 12 t[-234] = 0 a = "Lua" t[a] = 5 Quanto ltima atribuio necessria uma anlise minuciosa. A varivel a armazena o valor Lua, a ltima atribuio 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 indexao ainda no foi inicializada recebe nil. Portanto, considerando apenas as atribuies anteriormente exemplificadas, o cdigo: print (t[999]) imprimir o valor nil, pois o campo 999 de t no 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, tambm vlido: s = { } s.dados = { } s.dados.nome = "Linguagem Lua" s.dados.versao = 3.0

1.7.2.5.1 Inicializao de tabelas 1.7.2.5.1.1 Via indexao consecutiva Lua permite a inicializao de tabelas na criao. Uma forma possvel para inicializao de tabelas {expr1, expr2, ..., exprN} Isto , escreve-se uma lista de expresses entre as chaves que criam a tabela. Cada expresso listada avaliada e seu valor armazenado no ndice correspondente: o valor da primeira expresso armazenado no ndice 1 da tabela, o valor da segunda expresso no ndice 2, e assim por diante. Portanto: 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 atribuio de campos

Lua permite tambm a inicializao de campos da tabela, sua forma geral : { [exprA] = expr1, [exprB] = expr2, ... } Ou seja, na criao de tabelas a inicializao de qualquer tipo de campo (que a tabela pode armazenar) possvel. 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

Inicializao mista

H a possibilidade de combinao das duas maneiras de inicializao mostradas anteriormente. A forma geral : tabela = {lista-de-expresses; lista-de-atribuies-de-campos} Dessa forma, a lista de expresses de uma inicializao por indexao pode vir seguida do ponto e vrgula (;) enquanto a lista de atribuies de campos por nomes. Escrever: t = {23, 45, -7 ; nome="Linguagem 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, possvel saber o nmero de elementos do array usando o operador de tamanho #. Este operador retorna um ndice n do array desde que o valor da posio n do array seja diferente de nil e que o valor na posio n+1 seja nil. Podendo apresentar falhas quando trabalhado com um array que contm 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 no tem um comportamento bem definido neste caso 11 print (#t) -- ?? t [5] = "e" -- Agora o array no tem "buracos" e o operador # retorna o -- valor esperado print (#t) --> 6 Duas funes de iterao sobre os elementos armazenados na tabela so oferecidas na biblioteca padro de Lua. Ipairs

Itera sobre os ndices numricos 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 so reportados indefinida. Lua permite a especificao de um construtor na criao de tabelas. Por exemplo, um ponto 3D, dado pelas suas coordenadas. Em Lua, pode-se escrever:

21

local p = Point{x=3.0,y=1.3,z=3.2} Esse cdigo equivalente a: local p = Point({x=3.0,y=1.3,z=3.2}) A tabela foi criada, chamou a funo Point passando a nova tabela como parmetro. Essa funo pode ser o construtor do objeto sendo criado. Usando a funo, 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 no tiverem sido especificados, ento a funo os inicializa com zero.

1.7.2.6 Function Function so as funes da linguagem, que em Lua so tratadas como valores de primeira classe, o que significa que possvel armazen-las em variveis (globais ou locais) ou em campo de tabela, passa-las como parmetro para outras funes.

1.7.2.6.1 Declarando e chamando uma funo A declarao da funo pode ser da seguinte forma: function nomedafunco (arg_1, arg_2, ..., arg_n) corpoDaFunco end Onde as variveis arg_N indicam os parmetros da funo. Em Lua, uma funo pode ter desde nenhum at centenas de parmetros. Assim, uma funo pode retornar vrios valores ou nenhum. Como exemplo a funo f, que recebe dois parmetros e retorna a soma e o produto deles:

22

function f (a, b) local x = a or 1 -- x recebe o valor padro 1 quando a -- um valor falso local y = b or 1 -- y recebe o valor padro 1 quando b -- um valor falso return x + y, x * y end Mesmo possuindo dois parmetros, possvel chamar a funo f com quantidade diferente de parmetros. Se f for chamada com mais parmetros do que o esperado, os valores excedentes sero descartados, caso o valor de parmetros sejam menores, os valores dos parmetros no 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 Nmero varivel de parmetros As funes com nmero varivel de parmetros so declaradas utilizando trs pontos (...) . Para acessar os parmetros que foram chamados, usa-se a notao {...}, para criao de um array onde o primeiro parmetro da funo est na posio 1, o segundo na 2 e assim sucessivamente. A seguir, o exemplo mostra uma funo que recebe strings e imprime aquelas com tamanho maior do que 3.

FIGURA 3 Funo com nmero varivel de parmetros

23

1.7.2.6.3 Retorno de um nico valor Como dito anteriormente, em Lua pode-se retornar nenhum, apenas um ou mltiplos valores. Porm, nem sempre possvel obter todos os valores retornados por uma funo. Quando se avalia uma lista de expresses, somente ser obtido o primeiro valor de retorno de cada membro da lista, com exceo da ltima expresso, que pode retornar mltiplos valores normalmente. O uso abaixo da funo 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 expresso da lista de expresso, retornou dois valores, 11 e 30. s vezes, faz-se necessrio que uma chamada de funo retorne somente um valor, no importando se a chamada de funo faz parte de uma lista de expresses ou no. Nesse caso, deve-se colocar parnteses ao redor da chamada de funo, limitando o nmero de valores de retorno da funo a no mximo 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*. So utilizados para armazenar dados C em variveis Lua. A criao e alterao 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 variveis start e end guardam, respectivamente, as posies de incio e fim do buffer. A varivel n ir armazenar o nmero de elementos atualmente no buffer, ao passo que size representa o nmero mximo de elementos que o buffer pode armazenar. A varivel array representa o buffer e ser inicializada com um tamanho adequado quando o buffer for criado. Inicialmente array possui tamanho 1, uma vez que no possvel criar um array com tamanho 0 em C 89. O trecho de cdigo a seguir mostra a funo 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 funo luaL_argcheck til para gerar mensagens de erro sobre algum argumento da funo. O segundo parmetro de luaL_argcheck a condio a ser testada, o terceiro parmetro indica qual argumento est sendo testado e o ltimo parmetro especifica uma parte da mensagem de erro. Assumindo que buffer.new seja a funo Lua equivalente para buffernew, no caso da chamada a seguir: buffer.new (0) teramos a seguinte mensagem de erro: stdin:1: bad argument #1 to 'new' (invalid buffer size) (Lua Conceitos Bsicos e API C. LabLua, Agosto de 2008. Captulo 9, pginas 56 e 57).

1.7.2.8 Thread Os valores do tipo thread representam fluxos de execuo independentes. So utilizados em co-rotinas de Lua.

25

1.7.2.8.1 Co-rotinas
Co-rotinas so um poderoso mecanismo de programao para jogos. Uma co-rotina semelhante a um thread num sistema de multithreading, no sentido de que temos uma linha de execuo com seu prprio ambiente local (pilha de execuo) compartilhando o ambiente global com outras corotinas. A grande diferena entre uma co-rotina e uma funo que a execuo de uma co-rotina pode ser suspensa e retomada posteriormente (no ponto em que foi suspensa). A diferena 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 funes que manipulam co-rotinas esto agrupadas na tabela coroutine. Criamos uma co-rotina passando uma funo (em geral, anmina) para a funo de criao, que retorna um valor do tipo thread: local c = coroutine.create(function () ... end) print(type(c)) --> "thread" (A Linguagem Lua e suas Aplicaes em Jogos. Celes, Waldemar; Figueiredo, Luiz Henrique de; Ierusalimschy, Roberto. 2004 Pgina: 11, tpico: 3.8).

1.7.3 Coero Lua possui alguns mecanismos de converso automtica de tipos. Qualquer operao aplicada sobre uma string h uma tentativa de converso dela em um valor numrico correspondente. Ou seja, se a string contm um valor numrico, ento este valor assumido na operao aritmtica. Quando esta converso no for possvel, um erro reportado pela linguagem. Portando, o cdigo: b = "53" c = 2 + b resulta no armazenamento do valor numrico 55 na varivel c.

J quando se utiliza um valor numrico onde deveria conter uma string, por exemplo, uma concatenao, este valor convertido para uma cadeia de caracteres. Assim, o cdigo: print("resultado: " .. 23) tem como sada uma string: resultado: 23.

26

Existem funes pr-definidas para as converses anteriores sejam feitas explicitamente, o tonumber para converso de string para forma numrica e tostring para converter um valor numrico para uma cadeia de caracteres.

1.8 EXPRESSES E ATRIBUIO

1.8.1 Operadores Os operadores oferecidos por Lua so basicamente os aritmticos, relacionais e lgicos usuais, comumente encontrados em outras linguagens. Lua tambm alguns operadores especiais, como para concatenao de strings.

1.8.1.1 Aritmticos Os operadores aritmticos presentes em Lua so: Unrios: - Negao

Binrios + * / ^ Adio Subtrao Multiplicao Diviso Exponenciao

Para precedncia de operadores pode-se utilizar dos parnteses.

Os operadores aritmticos s podero ser aplicados sobre valores do tipo number ou string, se este estiver convertida para nmero atravs de coero.

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

27

~= Diferena Os operadores >, <, >=, <= so aplicveis apenas a dados do tipo number ou string. 1.8.1.3 Lgicos Combinam valores booleanos e so dados por: and Conjuno (e) or Disjuno (ou) not Negao As conjunes ou disjunes mltiplas so avaliadas da esquerda para direita.

1.8.1.4 Operador de concatenao Como dito acima e anteriormente no tpico String, Lua tem um operador para concatenao 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 unio das outras cadeias originais.

1.8.1.5 Precedncia dos operadores A precedncia dos operadores usual. Como dito anteriormente, o uso dos parnteses permitido, para alterar a ordem de precedncia natural. A ordem de precedncia de operadores est listada abaixo em ordem decrescente: ^ not -(unrio) * / + .. < > <= ~= == and or

1.8.2 Estruturas de Controle

1.8.2.1 If O if a estrutura de controle bsica de Lua. Caso a condio do if seja verdaira, o comando do then executado, caso contrrio, a parte else executada. A seguir um exemplo de uso do if.

28

local x = 44 if x > 30 then print ("maior elseif x > 20 then print ("maior elseif x > 10 then print ("maior else print ("que x end 1.8.2.2 While

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

O while uma das estruturas de repetio presentes na linguagem Lua. Caso a condio do lao seja verdadeira, o bloco executado e a condio avaliada novamente, o lao s termina quando a condio no 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 deciso no fim, o repeat pode ser assim expressado: f = 1 -- valor do fatorial i = 1 -- controle do lao repeat f = f * i i = i + 1 until i > n peat Onde o bloco executado pelo menos uma vez, at o valor verdadeiro da expresso seja encontrado.

1.8.2.4 For Em Lua existem dois tipos de for: o numrico e o genrico.

1.8.2.4.1 For numrico A sintaxe do for numrico 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 lao 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 expresso exp3 representa o passo do lao. Quando o passo no 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 varivel var visvel apenas dentro do lao e no deve ser alterada.

1.8.2.4.2 For genrico O for genrico usado para percorrer valores retornados por uma funo iteradora. O principais iteradores fornecidos por Lua so 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, possvel imprimir todos os seus valores com uso de um for genrico: for i, v in ipairs (a) do -- i guarda o ndice, v o valor print (v) end

1.8.2.5 Break e return

So comandos utilizados para sair de um bloco de programa. O break mais utilizado em laos, pois permite encerrar a execuo do lao. O return permite retornar valores de uma funo ou terminar a execuo de uma. Em Lua, este comando pode receber mltiplos argumentos, retornando mais de um valor. Os comandos return ou break devem so restritos ao uso no final do bloco, portanto o cdigo que segue no compilar por esse motivo:

30

i = 5 while i < 10 do break -- Erro! break deve ser o ltimo comando do bloco i = i + 1 --Atribuio o ltimo comando do bloco "while" end As solues para correo possveis so a reordenao do cdigo 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 -- Atribuio o ltimo comando do bloco "while" end

1.9 Biblioteca padro Lua

Junto de sua distribuio oficial, Lua inclui um conjunto de bibliotecas para implementao de funes para criao de programas. As funes de cada biblioteca so agrupadas em tabelas, com exceo da biblioteca bsica. Algumas das bibliotecas padres inclusas na distribuio esto listadas abaixo:

string: funes para manipulao de cadeia de caracteres; table: oferece funes para manipulao de tabelas. Algumas de suas funes so: table.insert, para insero de elemento na tabela e table.remove para remoo;

math: oferece funes matemticas, similar biblioteca matemtica de C. So algumas das funes: math.sqrt (para clculo de raiz quadrada), math.log (logaritmo de um nmero), math.pow (potenciao),

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

31

io: funes para entrada e sada. Como o io.open, io.close, io.read e io.white (que so utilizados para abrir, fechar, ler e escrever um arquivo, nesta ordem);

os: funes relacionadas ao sistema operacional. Por exemplo: os.clock (aproximao 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: funes para depurao de cdigos Lua. Oferece funes que permitem, por exemplo, fazer a consulta do estado corrente da pilha de execuo de Lua.

1.10 Programar em Lua

Regida pela licena MIT, do Instituto de Tecnologia de Massachusetts, Lua permite alteraes do cdigo-fonte e d liberdade para criao de qualquer aplicao usando a linguagem sem a necessidade de mostrar o cdigo, a nica condio a meno 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 tambm usurio de Lua ele afirma: Ela (Linguagem Lua) de aprendizagem simples e por isso no aconselho uma especificao em Lua sem conhecer outras linguagens como C e C++.. O jornal conclui a matria: Se trabalhar com Lua pode ser um objetivo a perseguir, aprender a linguagem ainda um desafio. Embora ela seja simples, no h uma estrutura didtica formal. A PUC-Rio oferece uma matria eletiva, mas no h um curso que atenda a um grupo maior de interessados.. Outra barreira que os interessados em Lua encontram so os artigos e arquivos da linguagem, que na maioria so da lngua inglesa, inclusive o manual de Lua, que foi publicado e encontra-se venda apenas no site Amazon, dos EUA. Segundo

32

Ierusalimschy, ningum no pas se interessou por publicar o manual em portugus, mas no site h uma traduo (http://www.lua.org/manual/5.1/pt/manual.html).

33

1.11 CONCLUSO

34

1.12 ANEXOS

1.12.1 ANEXO I E-mail de um dos produtores da Lucas Arts elogiando a linguagem e a adotando no lugar da SCUMM para desenvolvimento dos games.

1.12.2 ANEXO II Homenagem da Lucas Arts. 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 Programao mais populares (Novembro de 2010)

Disponvel em: 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

Disponvel em: http://research.ihost.com/hopl/HOPL-III.html. Acesso em: 20 de Novembro de 2010.

37

1.13 REFERNCIAS Noes de Lua 3.1 - Noes bsicas da linguagem de programao Lua. Extrado de Programando em Lua Teoria e Prtica (verso 2.1) e Linguagem de Extenso Lua por Waldemar Celes, Luiz Henrique Figueiredo e Roberto Ierusalimschy. Verso 3.1 atualizada por Roberto de Beuclair Seixas baseado no texto de Anna Magdalena Hester. 1998. Lua - Conceitos Bsicos e API C. LabLua Agosto de 2008. A Linguagem Lua e suas Aplicaes em Jogos. Cales, Waldemar; Figueiredo, Luiz Henrique de; Ierusalimschy, Roberto. 2004. Uma Introduo Programao em Lua. Ierusalimschy, Roberto. 2009. Manual de Referncia de Lua 5.1. (Ierusalimschy, Roberto; Figueiredo, Luiz Henrique de; Celes, Waldemar). Verso traduzida por Medeiros, Srgio Queiroz de; com apoio da Fbrica Digital e da FINEP 2008. Disponvel em: http://www.lua.org/manual/5.1/pt/manual.html. Acesso em: 20 de Outubro de 2010. Portal da Linguagem na internet: http://www.lua.org/portugues.html. Acesso em: 18 de Outubro de 2010. Pgina 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. Edio n 8 de Maio de 2007 pginas 23 a 25 e edio n 22 de Novembro de 2009 pginas 17 a 20. Disponvel em: www.portugal-a-programar.org. Revista Esprito Livre. Edio n 1 de Abril de 2009 pginas 17 a 20. Disponvel em: 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. Dr. Dobbs. 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/omundo-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 Caractersticas das Linguagens de programao. Yanagisawa, Rodrigo da S. A Implementao de Lua 5.0. Ierusalimschy, Roberto. PUC Rio. Disponvel em: http://www.lua.org.

38

A Evoluo de Lua. Ierusalimschy, Roberto. PUC Rio - 2007. Disponvel em: http://www.lua.org. The evolution of Lua. Ierusalimschy, Roberto; Figueiredo, Luiz Henrique de; Celes, Waldemar HOLP III, San Diego 2007. Disponvel 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 so reproduo fiel dos que constam nas fontes aqui citadas, portanto todos os direitos autorais esto reservados a estas. Em momento algum ouve a inteno de infringi-los, foram adotados e reproduzidos por questes didticas.