Trabalho de

Pesquisa
Por Bruno Martins Costa
Estudante de Engenharia de Telecomunicaes - Uff

ndice
1. Introduo................................................................................................................................................................................1
2. Pesquisa Inicial.......................................................................................................................................................................2
2.1. Ferramentas de desenvolvimento Web..............................................................................................................2
2.1.1. HTML......................................................................................................................................................................2
2.1.2. PHP..........................................................................................................................................................................3
2.1.3. Form.......................................................................................................................................................................4
2.2. Banco de Dados.............................................................................................................................................................4
2.2.1. Definio...............................................................................................................................................................4
2.2.2. Sistema de Gerenciamento de Banco de Dados...................................................................................4
2.2.2.1.
Definio............................................................................................................................................5
2.2.2.2.
Modelos de Dados..........................................................................................................................5
2.2.2.3.
A linguagem......................................................................................................................................5
2.2.2.4.
A linguagem SQL............................................................................................................................5
2.2.2.5.
MySQL.................................................................................................................................................6
2.3. Linguagem de programao Lua............................................................................................................................7
2.3.1.Definio e Aplicaes......................................................................................................................................7
3. Pesquisa Final.........................................................................................................................................................................7
3.1. Uma introduo a Lua.................................................................................................................................................7
3.2. Caractersticas Bsicas...............................................................................................................................................8
3.2.1. Linguagem de Scripting..................................................................................................................................8
3.2.2. Linguagem dinmica........................................................................................................................................8
3.2.2.1.
Interpretao dinmica...............................................................................................................8
3.2.2.2.
Tipagem dinmica forte..............................................................................................................8
3.2.2.3.
Gerncia automtica de memria dinmica.......................................................................8
3.2.3.Comentrios..........................................................................................................................................................8
3.3. Diferenciais de Lua.......................................................................................................................................................9
3.3.1. Portabilidade.......................................................................................................................................................9
3.3.2. Simplicidade........................................................................................................................................................9
3.3.3. Pequeno Tamanho............................................................................................................................................9
3.3.4. Acoplabilidade....................................................................................................................................................9
3.4. Variveis e Tipos...........................................................................................................................................................9
3.4.1.Variveis.................................................................................................................................................................9
3.4.1.1.
variveis locais.................................................................................................................................9
3.4.1.2.
variveis globais..............................................................................................................................9
3.4.2.Tipo de dados.......................................................................................................................................................9
3.4.2.1.
Nil...........................................................................................................................................................9
3.4.2.2.
Booleano............................................................................................................................................10
3.4.2.3.
Number..............................................................................................................................................10
3.4.2.4.
String...................................................................................................................................................10
3.4.2.5.
Tabela.................................................................................................................................................10
3.4.2.6.
Function.............................................................................................................................................10
3.4.2.7.
Userdata.............................................................................................................................................10
3.4.2.8.
Thread.................................................................................................................................................10
3.5. Operadores......................................................................................................................................................................11
3.5.1.Aritmticos...........................................................................................................................................................11
3.5.2.Operadores Relacionais..................................................................................................................................11
3.5.3. Operadores Lgicos.........................................................................................................................................11

3.5.4.Operador de Concatenao............................................................................................................................11
3.5.5. Precedncia de operadores..........................................................................................................................12
3.6. Estrutura de controle de fluxo................................................................................................................................12
3.6.1.if.................................................................................................................................................................................12
3.6.2. While.......................................................................................................................................................................12
3.6.3. Repeat.....................................................................................................................................................................12
3.6.4. For............................................................................................................................................................................13
3.7. Tabelas...............................................................................................................................................................................13
3.7.1.Definio.................................................................................................................................................................13
3.7.2. Construtores........................................................................................................................................................14
3.7.3.Iteradores ipairs e pairs...................................................................................................................................15
3.8. Funes..............................................................................................................................................................................16
3.8.1.Definio.................................................................................................................................................................16
3.8.2. Trabalhando com um nmero varivel de argumentos....................................................................16
3.8.3. Passagem de parmetros por referncia.................................................................................................17
3.8.4. Retorno...................................................................................................................................................................17
3.8.5.Chamada..................................................................................................................................................................18
3.9. Metatabelas......................................................................................................................................................................18
3.9.1. Definio................................................................................................................................................................18
3.10. Programao Orientada a Objetos em Lua......................................................................................................19
3.10.1. Objetos.................................................................................................................................................................19
3.11. Co-rotinas........................................................................................................................................................................21
3.11.1. Definio..............................................................................................................................................................21
4. Projeto.........................................................................................................................................................................................22
5. Concluso...................................................................................................................................................................................27
6. Bibliografia................................................................................................................................................................................28

1. Introduo
O presente trabalho se prope a apresentar o resultado das pesquisas realizadas por mim visando o
cumprimento da atividade solicitada pelo grupo PET-TELE como ultima etapa do processo de seleo para o
ingresso no mesmo. Apresento tambm aqui os resultados obtidos no desenvolvimento de um dos projetos
propostos pelo grupo aos candidatos, o Jogo escrito na linguagem de programao Lua.
Inicialmente foi realizada uma pesquisa de forma que eu pudesse conhecer melhor a respeito dos trs temas
propostos: Ferramentas de desenvolvimento Web, Banco de Dados, Linguagem de programao Lua. Os trs
temas foram resumidos no tpico que se segue.
No terceiro tpico foi realizada uma abordagem mais detalhada da linguagem de programao Lua, pois me
responsabilizei por este tema. Foi apresentado o histrico da linguagem, suas aplicaes, caractersticas e
diferenciais que fizeram desta linguagem (desenvolvida no Brasil) a mais usada atualmente para scripting
em jogos.
Devido a sua leveza, praticidade, e outras caractersticas, Lua muito utilizada em plataformas pouco
convencionais. importante destacar que a linguagem participa do padro Ginga para o Sistema Brasileiro
de TV Digital.
No tpico quatro eu apresento resultados do projeto realizado.

2. Pesquisa Inicial
Nesta seo apresento a pesquisa que inicialmente foi realizada para a definio de qual tema proposto seria
escolhido.

2.1 Ferramentas de desenvolvimento de aplicativos para a web.

2.1.1 HTML
2.1.1.1 Definio
Resumindo uma longa histria, HTML foi inventado em 1990 por um cientista chamado Tim Berners-Lee. A
finalidade inicial era a de tornar possvel o acesso e a troca de informaes e de documentao de pesquisas,
entre cientistas de diferentes universidades. O projeto inicial tornou-se um sucesso jamais imaginado por
Tim Berners-Lee. Ao inventar o HTML ele lanou as fundaes da Internet tal como a conhecemos
atualmente.
2.1.1.2 Significado de HTML:
HTML a abreviatura de "HyperText Mark-up Language".
i) Hyper
o oposto de linear. Nos tempos antigos os programas de computadores rodavam linearmente: quando o
programa executava uma ao tinha que esperar a prxima linha de comando para executar a prxima ao
e assim por diante de linha em linha. Com HTML as coisas so diferentes - voc pode ir de onde estiver para
onde quiser.
ii) Text
textual.
iii) Mark-up
Significa marcao e o texto que voc escreve. Voc cria a marcao da mesma forma que escreve em um
editor seus cabealhos, marcadores, negrito, etc.
iv) Language
Significa linguagem e exatamente o que HTML ; uma linguagem. A linguagem HTML usa muitas palavras
do ingls.
2.1.1.3 Estrutura Bsica

A estrutura de um documento HTML apresenta os seguintes componentes:

Onde cada <comando> definido como uma etiqueta ou tag, e tem como objetivo indicar uma ao que deve
ser realizada. A maioria das etiquetas tem sua correspondente de fechamento:
<etiqueta>...</etiqueta>
2.1.1.1 Etiquetas
As etiquetas bsicas de HTML so:
<html>: define o incio de um documento HTML e indica ao navegador que todo contedo posterior deve ser
tratado como uma srie de cdigos HTML
<head>: define o cabealho de um documento HTML, que traz informaes sobre o documento que est
sendo aberto
<body>: define o contedo principal, o corpo do documento. Esta a parte do documento HTML que
exibida no navegador. No corpo podem-se definir propriedades comuns a toda a pgina, como cor de fundo,
margens, e outras formataes

2.1.2 PHP
1.1.2.1 Definio

PHP uma sigla recursiva que significa PHP HyperText Preprocessor. O PHP uma linguagem de
programao de ampla utilizao, interpretada, que especialmente interessante para desenvolvimento
para a Web e pode ser mesclada dentro do cdigo HTML.
O que distingui o PHP de algo como Javascript no lado do cliente que o cdigo executado no servidor,
gerando HTML que ento enviado para o cliente. O cliente receberia os resultados da execuo desse script,
mas no saberia como o cdigo fonte.
1.1.2.2 Aplicaes
O PHP focado para ser uma linguagem de script do lado do servidor, portanto, voc pode fazer qualquer
coisa que outro programa CGI (Common Gateway Interface) possa fazer, como: coletar dados de formulrios,
gerar pginas com contedo dinmico ou enviar e receber cookies. Mas o PHP tem diversas outras
utilidades. Esses so os maiores campos onde os scripts PHP podem se utilizados:
i) Script no lado do servidor (server-side).
Este o mais tradicional e principal campo de atuao do PHP. necessrio trs coisas para o trabalho. O
interpretador do PHP (como CGI ou mdulo), um servidor web e um browser. Basta rodar o servidor web
conectado a um PHP instalado. Voc pode acessar os resultados de seu programa PHP com um browser
visualizando a pgina PHP atravs do servidor web.
3

ii) Script de linha de comando.

Pode-se fazer um script PHP funcionar sem um servidor web ou browser. A nica coisa necessria o
interpretador. Esse tipo de uso ideal para script executados usando o cron* ou o Agendador de Tarefas (no
Windows). Esses scripts podem ser usados tambm para rotinas de processamento de texto.
iii) Escrevendo aplicaes GUI (Graphical User Interface) no lado do cliente (client-side).
O PHP no (provavelmente) a melhor linguagem para produo de aplicaes com interfaces em janelas,
mas o PHP faz isso muito bem, e se desejvel usar alguns recursos avanados do PHP em aplicaes no lado
do cliente pode-se utilizar o PHP-GTK para escrever esses programas. E programas escritos desta forma
ainda sero independentes de plataforma.

*O "cron" um programa de "agendamento de tarefas". Cron permite aos usurios agendar tarefas
(comandos ou scripts shell) para serem executados periodicamente em determinados momentos ou datas.

2.1.3 FORM
1.1.3.1 Definio
Um form uma seo de um documento HTML que contm contedo normal, marcao, elementos especiais
chamados de controls (botes de rdio, menus, etc.), e os rtulos sobre os controls. Usurios em
geral "completam", um form, modificando tais controls (digitar o texto, selecionar itens do menu, etc.), antes
que o form seja apresentado a um agente que executar o processamento (por exemplo, para um
servidor Web, um servidor de email, etc.).
1.1.3.2 Controles
Os usurios interagem com um form por meio da chamada de controls, que podem ser dos seguintes tipos:
- botes
-checkbox
-botes de rdio
-menus
- entradas de texto
-seleo de arquivo
-controles ocultos
-controles de objetos

2.2 Banco de Dados

2.2.1 Definio
Um banco de dados nada mais do que uma hierarquia de estruturas de dados complexas. Na maioria dos
bancos de dados, o conceito da estrutura que mantm os blocos (ou registros) de informaes chamado de
tabela. Estes registros, por sua vez, so constitudos de objetos menores que podem ser manipulados pelos
usurios, conhecidos por tipos de dados (datatypes). Juntos, um ou mais datatypes, formam um registro
(record). Uma hierarquia de banco de dados pode ser considerada como: Banco de dados > Tabela > Registro
> Tipo de dados. Os tipos de dados possuem diversas formas e tamanhos, permitindo ao programador criar
tabelas especficas de acordo com suas necessidades.

2.2.2 Sistema de Gerenciamento de Bancos de Dados (SGBD)

4

2.2.2.1 Definio
Um sistema de gerenciamento de banco de dados no nada mais do que um conjunto de programas que
permitem armazenar, modificar e extrair informaes de um banco de dados. H muitos tipos diferentes de
SGBD. Desde pequenos sistemas que funcionam em computadores pessoais a sistemas enormes que esto
associados a mainframes.
Um sistema de gerenciamento de banco de dados implica a criao e manuteno de bases de dados, elimina
a necessidade de especificao de definio de dados, age como interface entre os programas de aplicao e
os ficheiros de dados fsicos e separa as vises lgica e de concepo dos dados. Assim sendo, so
basicamente trs os componentes de um SGBD:
i) Linguagem de definio de dados
Especifica contedos, estrutura a base de dados e define os elementos de dados.
ii) Linguagem de manipulao de dados
Possibilita a alterao os dados na base.
iii) Dicionrio de dados
Guarda definies de elementos de dados e respectivas caractersticas descreve os dados, quem os acede,
etc.
2.2.2.2 Modelos de Dados
O Modelo de Dados basicamente um conjunto de conceitos utilizados para descrever um Banco de Dados.
No existe uma nica forma de representao deste modelo, porm qualquer forma que permita a correta
compreenso das estruturas de dados compreendidas no Banco de Dados pode ser considerada adequada.
Tipos de modelos de dados
hierrquico;
em rede;
relacional;
orientado a objetos;
2.2.2.3 A linguagem
Geralmente dividida em trs partes:
i) Linguagem de definio de dados ou LDD (ou DDL, do ingls), com comandos como CREATE TABLE;
ii) Linguagem de manipulao de dados, ou LMD (ou DML, do ingls), com comandos como UPDATE e SELECT;
iii) Linguagem de controle de dados, ou LCD, com comandos para controle de acesso dos usurios do sistema,
como GRANT e REVOKE em SQL.

2.2.2.4 A linguagem SQL

Structured Query Language, ou Linguagem de Consulta Estruturada ou SQL, uma linguagem de pesquisa
declarativa para banco de dados relacional (base de dados relacional). Muitas das caractersticas originais do
SQL foram inspiradas na lgebra relacional.
O SQL foi desenvolvido originalmente no incio dos anos 70 nos laboratrios da IBM em San Jose (Califrnia),
dentro do projeto System R, que tinha por objetivo demonstrar a viabilidade da implementao do modelo
relacional proposto por E. F. Codd.
A linguagem SQL um grande padro de banco de dados. Isto decorre da sua simplicidade e facilidade de
uso. Ela se diferencia de outras linguagens de consulta a banco de dados no sentido em que uma consulta
SQL especifica a forma do resultado e no o caminho para chegar a ele. Ela uma linguagem declarativa em
oposio a outras linguagens procedurais. Isto reduz o ciclo de aprendizado daqueles que se iniciam na
linguagem.
2.2.2.5 MySQL
O MySQL um sistema de gerenciamento de banco de dados (SGBD), que utiliza a
linguagem SQL (Linguagem de Consulta Estruturada, do ingls Structured Query Language) como interface.
atualmente um dos bancos de dados mais populares, com mais de 10 milhes de instalaes pelo mundo.
Entre suas caractersticas, podemos destacar:
i) Portabilidade (suporta praticamente qualquer plataforma atual);
ii) Compatibilidade (existem drivers ODBC, JDBC e.NET e mdulos de interface para
diversas linguagens de programao, como Delphi, Java, C/C++, Python, Perl, PHP,
ASP e Ruby)
iii) Excelente desempenho e estabilidade;
iv) Pouco exigente quanto a recursos de hardware;
v) Facilidade de uso;
vi) um Software Livre com base na GPL;
vii) Contempla a utilizao de vrios Storage Engines como MyISAM, InnoDB, Falcon,
BDB, Archive, Federated, CSV, Solid...
viii) Suporta controle transacional;
ix) Suporta Triggers;
x) Suporta Cursors (Non-Scrollable e Non-Updatable);
xi) Suporta Stored Procedures e Functions;
xii)Replicao facilmente configurvel;
xiii)Interfaces grficas (MySQL Toolkit) de fcil utilizao cedidos pela MySQL Inc.

2.3 Linguagem de programao Lua

2.3.1 Definio e Aplicaes
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 uma linguagem de extenso projetada para dar suporte a programao procedural, oferecendo
facilidades para descrio de dados. Isso significa que Lua possibilita combinar a descrio de objetos e a
programao de seus comportamentos num mesmo contexto. Lua uma biblioteca implementada em C,
podendo ser compilada em qualquer plataforma que tenha um compilador C padro. Lua tambm pode ser
compilada sem alteraes como uma biblioteca C++. Por ser uma linguagem de extenso, Lua trabalha
acoplada a uma aplicao hospedeira (host). Essa aplicao pode criar e ler valores armazenados em Lua,
executar funes de Lua e registrar funes C no ambiente de Lua. As funes C registradas em Lua, por sua
vez, podem ser invocadas de programas Lua. Dessa forma, podemos conciliar as facilidades de uma
linguagem de script oferecidas por Lua com a eficincia das linguagens C e C++.
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.

3. Pesquisa Final
3.1 Uma Introduo a Lua
Em 1992, em um projeto entre a PUC - Rio (Pontifica Universidade Catlica do Rio de Janeiro) e a Petrobrs,
surgiu o Tecgraf (grupo de Tecnologia em Computao Grfica), cujo objetivo a princpio baseava-se na
construo de interfaces grficas para programas de simulao. Para tal era utilizada a linguagem DEL
(Linguagem para Especificao de Dilogos), que apresentava algumas limitaes. Um ano depois foi criado
o PGM (Programa Grfico Mestre), utilizado para visualizaes de perfis geolgicos. A linguagem SOL
(Simple Object Language) estava sendo utilizada, mas tambm se limitava.
Foi evidenciada a necessidade crescente de que as aplicaes desenvolvidas no Tecgraf fossem configurveis
externamente pelos usurios. Isso quer dizer que diversos aspectos essenciais das aplicaes podem ser
modificados sem recompilar a aplicao. Desde o incio do desenvolvimento de tais aplicaes esse tipo de
configurao era muito mais do que simplesmente poder escolher a cor da janela ou o tipo de fonte de texto:
era necessrio poder tomar decises em tempo de execuo que somente os usurios sabiam quais
eram. Sendo assim, era necessrio fornecer algum tipo de programao para os usurios finais. Outro tipo
de configurao era a descrio de complexos relatrios e analises feita pela Petrobras por encomenda ao
Tecgraf. Mais uma vez, essa descrio no podia estar congelada dentro da aplicao, pois cada usurio tinha
uma necessidade diferente e que mudava a cada tarefa. O Tecgraf tinha, portanto forte demanda para
aplicaes que fossem configurveis externamente, tanto descrevendo que decises deveriam ser tomadas
quanto descrevendo quais dados seriam usados e como eles seriam usados.
Foi ento que Roberto Ierusalimschy, Luiz Henrique Figueredo e Waldemar Celes se reuniram para
encontrar uma linguagem nica que pudesse atender a todas as necessidades de configurao das suas
aplicaes, de tal forma que fosse uma linguagem de configurao genrica, facilmente acoplvel, porttil e
7

com uma sintaxe simples, de forma que os usurios finais (engenheiros, gelogos, etc.) pudessem utiliz-la
confortavelmente. Ento, em julho de 1993, foi lanada a primeira verso pblica (1.0) de LUA, como uma
alternativa para o desenvolvimento de tais projetos. A primeira verso pblica (1.1) de julho de 1994.
Nos dias atuais a utilizao de LUA no se limita apenas aos projetos desenvolvidos no Tecgraf. Lua
empregada tambm para implementar softwares embutidos em equipamentos de rede (switches ethernet),
aplicaes de simulao em laboratrios de fsica (tendo sido esta uma de suas primeiras utilizaes fora da
PUC - Rio, no Observatrio Astrofsico de Smithsonian) e, notavelmente, no desenvolvimento de jogos.
Uma pesquisa realizada em setembro de 2003 pela gamedev.net que a grande maioria dos jogos (72%)
desenvolvida com o auxlio de uma linguagem de script. Desse total, 20% utilizam Lua (primeira colocao),
e 7% utilizam Python (segunda colocao).

3.2 Caractersticas Bsicas

3.2.1 Linguagem de Scripting
Lua uma linguagem de scripting, ou de extenso. Uma linguagem de script uma linguagem projetada para
controlar e coordenar componentes geralmente escritos em outra linguagem. Apesar de vrias linguagens
dinmicas poderem ser usadas para script, poucas foram projetadas para essa finalidade. Lua uma
linguagem estruturada como uma biblioteca C, com uma API que permite tanto que o cdigo na linguagem
possa chamar funes escritas em C como permite que cdigo C possa chamar funes escritas em Lua.
Por ser uma biblioteca implementada em C, Lua pode ser compilada em qualquer plataforma que tenha um
compilador C padro.
Lua, assim como a maioria das linguagens de scripting, uma linguagem interpretada, sendo necessrio um
interpretador para fazer a interface entre o cdigo e o processamento realizado pelo hardware da
plataforma.

3.2.2 Linguagem dinmica

Lua tambm classificada como uma linguagem dinmica, pois possui as seguintes caractersticas:
3.2.2.1 Interpretao dinmica
Isso significa que a linguagem capaz de executar trechos de cdigo criados dinamicamente, no mesmo
ambiente de execuo do programa. Como exemplo temos a funo loadstring que compila um trecho de
cdigo arbitrrio e retorna a funo resultante, sem execut-la.
3.2.2.2 Tipagem dinmica forte
Em Lua, no necessrio declarar o tipo das variveis. Uma mesma varivel pode armazenar, durante a
execuo do programa, variveis de tipos diferentes. Qualquer erro associado ao tipo da varivel (como, por
exemplo, a soma de um caractere com um numero real) s observado em tempo de execuo.
3.2.2.3 Gerncia automtica de memria dinmica
Isso significa que no h a necessidade de um comando para liberar a memria aps seu uso.

3.2.3 Comentrios
Em Lua os comentrios so iniciados por dois traos seguidos (--) e vo at o final da linha onde estes foram
inseridos.
8

3.3 Diferenciais de Lua

3.3.1 Portabilidade
Pode ser utilizada em praticamente todas as plataformas.

3.3.2 Simplicidade
A linguagem Lua tem apenas um nico tipo de estrutura de dados, a tabela, e um nico tipo numrico, o
number, caractersticas que, dentre outras, tornam a linguagem de fcil entendimento.

3.3.3 Pequeno tamanho

O pacote de sua verso atual, contendo o cdigo fonte, documentao e exemplos, ocupa cerca de 860K
descompactado.

3.3.4 Acoplabilidade
Lua uma biblioteca em C, rpida e pequena, pode ser facilmente embutida em 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.

3.4 Variveis e Tipos

3.4.1 Variveis
Como foi mencionado anteriormente, em Lua as variveis no possuem tipo associados a elas e qualquer
varivel pode armazenar qualquer tipo de dado durante a execuo programa.
Em Lua existem dois tipos de variveis:
3.4.1.1 variveis locais
So declaradas atravs da introduo do termo local antes da varivel. Possuem escopo apenas dentro de
um bloco de comandos, no sendo visveis no restante do programa.
3.4.1.1 variveis globais
No precisam ser declaradas. So visveis em todo o corpo do programa, exceto em bloco de comando que
possua uma varivel local de mesmo nome da varivel global.

3.4.2 Tipo de dados

Em Lua existem oito tipos de dados:
3.4.2.1 Nil
Representa valor indefinido, e qualquer varivel que no fora inicializada assume esse valor. A palavra
reservada nil pode ser usada na programao para expressar o valor do tipo nil.
9

O nil tambm interpretado como falso numa expresso booleana.

3.4.2.2 Booleano
Pode assumir apenas dois valores, ou falso (false) ou verdadeiro (true).
3.4.2.3 Number
Em Lua no h distino entre nmeros inteiros e nmeros de ponto flutuante. H um nico tipo para
represent-los, o number. Com
3.4.2.4 String
Representa uma cadeia de caracteres, que pode ser delimitada por aspas duplas (...), aspas simples (...) ou
duplos colchetes ([[...]]). Os duplos colchetes so utilizados por cadeias que se estendem por vrias linhas.
3.4.2.5 Tabela
So a nica forma de estrutura de dados em Lua, e podem representar vetores, listas, filas, tabelas de
smbolos, conjuntos, grficos, registro e hash. Uma varivel do tipo table associa um ndice a um valor.
Uma tabela deve ser explicitamente criada antes de ser usada, e isso feito atravs da expresso {}. Assim, a
expresso t = {} cria nova tabela que ser armazenada na varivel t.
Podemos adicionar ou recuperar elementos de uma tabela utilizando seus ndices. No h limite para a
adio de elementos, e a nica restrio quanto as ndices que eles no podem ser do tipo nil. Assim, por
exemplo:
t[1] = 3 --armazena 3 na tabela, associada ao ndice 1;
t[carro] = 78 -- armazena 78 na tabela, associado ao ndice carro.
Print (t[1]) --> imprime 3 na tela.
Print (t[carro]) = imprime 78 na tela.
O valor da um campo cuja indexao ainda no foi inicializada recebe o valor de nil.
H a possibilidade de armazenamento de tabelas em outras tabelas, criando conjuntos multidimensionais.
Se a tabela estiver sendo utilizada como um array, o operador # retorna o tamanho do mesmo, podendo
apresentar falhas caso hajam valores iguais a nil.
3.4.2.6 Function
Function so as funes da linguagem que em Lua so tratados como valores de primeira classe, o que
significa que possvel armazen-las em variveis (globais ou locais) ou em campo de tabela, e pass-las
como parmetro para outras funes.
3.4.2.7 Userdata
Esse um tipo de dado host, representado por um ponteiro void*. So utilizados para armazenar dados C em
variveis Lua.A criao e alterao do userdata s pode ser feito por meio da API de Lua em C.
3.4.2.8 Thread
Os valores do tipo thread representam fluxos de execuo independentes. So utilizados em co-rotinas de
Lua.
10

3.5 Operadores
Em Lua so encontrados os seguintes operadores:

3.5.1 Aritmticos
So operadores aritmticos de Lua:
Soma (+)
Subtrao (-)
Multiplicao (*)
Diviso (/)
Operador unrio de negativo (-)
Parnteses podem alterar precedncia de operadores.
Somente podem ser aplicados a valores do tipo number ou a valores do tipo string que possam ser
convertidos para number.

3.5.2 Operadores Relacionais

So operadores relacionais de Lua:
Menor que (<)
Maior que (>)
Menor ou igual a (<=)
Maior ou igual a (>=)
Igual a (==)
Diferente de (~=)
Operadores <, >, <=, >= so aplicveis a number e string.

3.5.3 Operadores Lgicos

So operadores lgicos de Lua:
Conjuno (and)
Disjuno (or)
Negao (not)
Operadores and e or so avaliados da esquerda para a direita.

3.5.4 Operador de Concatenao

representado por dois caracteres ponto (..).
Aplicvel a tipo string, convertendo valores do tipo number quando concatenados a string.
Ex: a = Linguagem
b = Lua
c = 5.1
c = a .. .. b .. c
11

-- armazena Linguagem Lua 3.2 em c

3.5.5 Precedncia dos Operadores

A ordem de precedncia dos operadores est listada abaixo em ordem decrescente.
^
not (unrio)
/
+ ..
< > <= >= == ~=
and or

3.6 Estruturas de controle de Fluxo

3.6.1 if
O if a estrutura de controle bsica de Lua. Se a expresso for verdadeira, executa o bloco iniciado pelo
comando then. Caso contrrio, executa o bloco iniciado pelo comando else (caso exista).
Construo:

3.6.2 While
O while uma das estruturas de repetio. Se a condio do lao for satisfeita, o bloco de comandos
executado repetidas vezes, at que a condio ao seja mais satisfeita.
Construo:

3.6.3 Repeat
Tambm uma estrutura de tomada de repetio, porm difere do while porque a condio testada no fim.
Construo
12

3.6.4 For
O For uma estrutura de repetio que estabelece o valor inicial do parmetro, o seu valor final, e o seu
incremento a cada repetio. Existem dois tipos de for: o for numrico e o for genrico
3.6.4.1 For numrico

Onde
- expr_inicial = valor inicial do parmetro
- expr_final = valor final do parmetro
- expr_incremento = incremento
3.6.4.2 For genrico
O for genrico usado para percorrer valores retornados por uma funo iteradora. Os principais iteradores
so o ipairs (percorre os ndices de um ar Ray), o pairs (percorre as chaves de uma tabela) e o io.lines
(percorre as linhas de um arquivo).

A execuo de laos while, repeat e for pode ser interrompida usando o comando break.

3.7 Tabelas
3.7.1 Definio
A tabela o nico mecanismo de estruturao de dados oferecido por Lua. Todas as estruturas de dados
comumente encontradas em programao podem ser facilmente implementadas com o uso de tabelas.
O comando a seguir cria uma tabela e armazena na varivel (que poderia ser global ou local) t:
t = {}
A tabela, a princpio, est vazia, ou seja, armazena o valor nil.
Podemos armazenar qualquer tipo de dado na tabela, associado a ndices sejam numricos, caracteres
elementos de outra tabela, ou at mesmo outras tabelas (o que possibilita a criao de arrays
multidimensionais). Por exemplo:
13

t[1] = carro --> armazena a string carro na tabela, associada ao ndice 1.

t[lua] = 7 --> armazena a varivel numrica 7 na tabela associada ao ndice lua.
t[2] = m{} --> armazena a tabela m na tabela t, associada ao ndice 2
Para acessar ndices numricos em tabelas, utiliza-se o nmero entre colchetes.
Ex: a = {1.3, 3.14}
print(a[1]) -- imprime 1.3
print(a[2]) -- imprime 3.14
a[3] = 12 -- adiciona uma entrada na tabela
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 t[lua] = 7 pode ser substituda por t.lua=
7.
As demais expresses tambm so vlidas:
t[5.2] = 0
t.jogo = 21
s.dados = {}
t[-15] = nil

3.7.2 Construtores
3.7.2.1 definio
Os mecanismos utilizados para inicializarmos uma tabela so chamados de construtores. A expresso t = {}
um caso particular de construtor. Existem basicamente trs tipos de construtores: um para listas, um para
estruturas e um genrico.

3.7.2.2 Construtor de Listas

O construtor de listas associa diversos dados a ndices numricos inteiros e sucessivos. Tem a seguinte
forma:
{exp1, exp2, exp3, ...}
Essa expresso cria uma tabela que associa a exp1 ao ndice numrico 1, a exp2 ao ndice 2, e assim
sucessivamente. Sendo assim, a expresso
frutas = {laranja, uva, banana, morango, pssego}
print (frutas[3])
imprime na tela a string banana.
3.7.2.3 Construtor de estruturas
O construtor de estruturas cria uma tabela com strings como ndices e tem a seguinte forma:
{nome1 = exp1, nome2 = exp2, nome3 = exp3, ...}

14

Essa expresso cria uma tabela associando o valor da exp1 ao nome1, o valor da exp2 ao nome 2, e assim
sucessivamente. Sendo assim, a expresso
notas = {bruno = 10, marcelo = 7, daniel = 9,5, jos = 8}
print (notas.bruno)
imprime na tela o valor associado a bruno na tabela notas, ou seja, 10.
3.7.2.4 Construtor genrico
O construtor genrico, como o nome sugere, pode ser utilizado para construir qualquer tipo de estrutura
utilizada em Lua e tem a seguinte forma:
{[e1] = exp1, [e2] = exp2, [e3] = exp3, ...}
Essa expresso cria uma tabela com o valor de exp1 associado ao valor da expresso e1, exp2 associado ao
valor da expresso e2, e assim por diante. Em particular, qualquer construtor de listas pode ser reescrito na
forma a seguir:
{ [1] = exp1, [2] = exp2, [3] = exp3, ...}
De forma similar, construtores de estruturas tambm podem ser reescritos usando-se o construtor genrico:
{ ["nome1"] = exp1, ["nome2"] = exp2, ...}
Algumas chaves do tipo string s podem ser criadas com o uso do construtor genrico, como demonstrado a
seguir:
m = {or = 1, += 2} --> expresso invlida pois a palavra or e o smbolo + so reservados em Lua
m = {[or] = 1, [+] = 2} --> expresso vlida
op = {["+"] = "add", ["-"] = "sub", ["*"] = "mul", ["/"] = "div"} --> expresso vlida.
3.7.2.5 Inicializao mista
Podemos inicializar uma tabela utilizando os trs construtores apresentados anteriormente de uma forma
mista, como por exemplo:
conjunto = {1, 22, 43, rio de janeiro, valor = 100, [for] = para}
print (conjunto[4]) --> imprime rio de janeiro
print (conjunto.valor) --> imprime 100
print (conjunto.for) --> expresso invlida em Lua
print (conjunto[for] --> imprime para

3.7.3 Iteradores ipairs e pairs

A biblioteca padro de Lua oferece duas funes que permitem iterar sobre os elementos armazenados na
tabela. A funo ipairs itera sobre todos os ndices numricos armazenados na tabela. Assim,
for i,v in ipairs(t) do ... end

15

itera sobre os pares (1,t[1]), (2,t[2]), . . . , ate que o primeiro ndice com valor associado igual a nil seja
encontrado. A funo pairs permite iterar sobre todos os pares armazenados na tabela, independente do tipo
associado `a chave:
for k,v in pairs(t) do ... end
Nesse caso, a ordem em que os pares k,v so reportados e indefinida.

3.8 Funes
3.8.1 Definio
Funes em Lua so valores de primeira classe. Isso significa que, como qualquer outro valor, uma funo
pode ser criada, armazenada em uma varivel (local ou global) ou campo de tabela e passada adiante como
parmetro ou valor de retorno de outra funo. Uma funo pode receber zero ou mais valores. A lista de
parmetros e especificada da maneira usual: entre os parnteses que seguem o nome da funo.
Funes em Lua so valores dinmicos ou seja, so criadas dinamicamente, durante a execuo de um
programa.
Podemos criar uma funo das seguintes formas:
function f (lista-de-parmetros)
bloco
end

Ou:
f = function(lista-de-parmetros)
bloco
end

Onde f representa a varivel que armazenar a funo.

Lua faz ajuste no nmero de parmetros passados funo, completando com nil os parmetros faltantes.
Ex: function func1(a, b, c, d)
bloco
end
-- chamada da funo:
func1(1, 2)
-- dentro da funo: a = 1, b = 2, c = d = nil
-- chamada da funo:
func1(1, 2, 3, 4, 5, 6)
-- dentro da funo: a = 1, b = 2, c = 3, d = 4
-- os valores 5 e 6 passados funo so ignorados

3.8.2 Trabalhando com um nmero varivel de argumentos:

16

Se adicionarmos ao final da lista de argumentos o sinal ...(trs pontos seguidos) poderemos criar uma funo
cujo numero total de argumentos varivel. Os argumentos extras so colocados na tabela implcita arg.
Ex: function func1(a, b, )
bloco
end
-- chamada da funo:
func1(1, 2, 3, 4, 5)
-- dentro da funo: a = 1, b = 2, arg = {3, 4, 5}
-- ou seja, arg[1] = 3, arg[2] = 4, arg[3] = 5

3.8.3 Passagem de parmetros por referncia

Valores do tipo table, function e userdata so passados por referncia, ou seja, passado para a funo um
ponteiro para os mesmos na verdade
Ex: function func1(a)
a[1] = 1
a[2] = 2
end
x = {3, 4}
func1(x)
-- resulta em: x[1] = 1 e x[2] = 2

3.8.4 Retorno
O Comando return efetua o retorno da funo imediatamente. Ele deve ser o ltimo comando do bloco e
pode retornar zero, um ou mais valores (mltiplo retorno).
Ex: function func1(param1)
if (not param1) then
return
end
print(param1)
end
-- somente imprimir o valor de param1 se no for nil
Ex: function func1()
return 1, 2, teste
end
x, y, z = func1()
-- resulta em: x = 1, y = 2 e z = teste
Lua faz ajuste no nmero de parmetros retornados da funo, completando com nil os parmetros faltantes.
Ex: function func1()
return 1, 2
end
-- chamada da funo:
a, b, c, d = func1()
-- resulta em: a = 1, b = 2, c = d = nil
-- chamada da funo:
17

a = func1()
-- resulta em: a = 1
-- o valor 2 retornado ignorado

8.6 Chamada
As funes em Lua so chamadas pelo nome da funo seguido dos argumentos entre parntesis, separados
por vrgulas:
Ex: func1(1, 2, 3)

3.9 Metatabelas
3.9.1 Definio
Uma metatabela uma tabela Lua comum que define o comportamento do valor original, sob
certas operaes especiais.
As metatabelas nos permitem alterar o comportamento de uma tabela. Por exemplo, usando metatabelas,
podemos definir como Lua calcula a expresso a + b, onde a e b so tabelas. Lua, sempre que tenta
adicionar duas tabelas, verifica se qualquer uma delas possui uma metatabela e se esta possui um
campo __add. Se Lua encontra nesse campo, ele chama o valor correspondente (o metamtodo chamado, que
deve ser uma funo) para calcular a soma.
Na metatabela, podemos programar a ao que deve ser tomada quando ocorre um determinado evento. Por
exemplo, a operao de soma no especificada para tabelas; no entanto, podemos fazer com que duas
tabelas possam ser somadas, gerando uma terceiro novo tabela. Para isso, devemos primeiro criar uma
metatabela com o comportamento da operao de soma definido:
local mt = {
__add = function (a,b)
return {a[1] + b[1], a[2] + b[2]}
end }
Devemos ento definir mt como a metatabela de pelo menos uma das tabelas envolvida na operao de soma
atravs do comando setmetatable:
setmetatable (x, mt)
Assim ento, poderemos validar a seguinte expresso:
x = {1,2}
y = {7,3}
z = x+y
print (z[1], z[2]) --> imprime 8 , 5
Alem de add, podemos (re-)definir o comportamento quando da ocorrncia dos seguintes eventos de
operao aritmtica:
sub (subtrao)
mul (multiplicao)
18

div (diviso)
pow (exponenciao)u
nm (negao)
concat (concatenao)
eq (igualdade)
lt (menor que)
le (menor ou igual que)
Basta criar o campo adequado na metatabela. (O nome do campo e o nome do evento precedido de __.)
Existem ainda dois eventos especiais cujos comportamentos podem ser programados: index, gerado quando
tentamos acessar um indice no existente na tabela, e newindex, gerado quando tentamos atribuir um valor a
um ndice ainda no existente na tabela. Esses eventos podem ser usados para programar diferentes
comportamentos. Por exemplo, podemos usar o evento ndex para delegar a outra tabela a busca do valor
associado ao ndice. Dessa forma, podemos programar nosso prprio mecanismo de herana. Se o objeto no
tem o campo, retornamos o campo associado `a sua classe:

3.10 Programao Orientada a Objetos em Lua

3.10.1 Objetos
Em Lua, a programao orientada a objetos se vale da combinao de tabelas com funes de primeira
classe. Em Lua, um objeto meramente uma tabela, contendo campos com seus dados (variveis de
instncia) e operaes (mtodos).
Ex:
circulo = {x = 1, y = 2 , cor = azul, raio = 10} --> define um novo objeto atravs da tabela circulo
Podemos criar mtodos e associ-los aos objetos utilizando funes.
Ex:
function circulo.area (self)
return math.pi * self.raio^2
end
A funo armazenada no campo circulo.area aplicada a circulo retorna o valor armazenado no campo raio
elevado ao quadrado multiplicado pela funo math.PI, que retorna o valor de . Essa funo pode ser vista
como um mtodo para obtermos a rea de qualquer elemento da classe circulo, como ser explicado a
posteriormente.
O comando:
print (circulo.area(circulo))
imprime na tela o valor da rea do circulo, e poderia ser substituda pela expresso
print (circulo:area())
O operador de dois pontos automaticamente insere o receptor do mtodo como um primeiro argumento
adicional na chamada. Sendo assim, tambm poderamos reescrever a funo da seguinte forma:
19

function circulo:area ()
return math.pi * self.raio^2
end
Nesse caso, o operador insere automaticamente um primeiro argumento adicional na definio do mtodo,
com o nome self. Para criarmos novos objetos dentro dessa classe precisamos nos utilizar das metatabelas.
As metatabelas em Lua nos permitem utilizar o mecanismo da delegao.
Delegao permite que uma tabela herde campos de outra tabela. Mais especificamente, suponha que uma
tabela A delega sua indexao para outra tabela B. Se indexamos A com uma chave presente, o valor
associado retornado normalmente. Mas se indexamos A com uma chave ausente, Lua automaticamente ir
procurar essa chave na tabela B. (Uma Introduo programao em Lua. Ierusalimschy, Roberto)
X = {a = 100}
Y = {a = 200, b = 300}
mt = {__index = Y} --> metatabela
print(X.a, X.b) --> 10 nil
setmetatable(X, mt)
print(X.a, X.b) --> 10 30
O comando setmetatable(X, mt) define mt como a metatabela de X. Quando o programa solicita um campo
que no existe em X, o mesmo verifica se X possui uma metatabela e se esta possui um campo indexado por
__index. Ento, o programa retorna o ndice solicitado relativo tabela que est armazenada em __index.
Poderamos reescrever o cdigo acima sem o uso de mt:
X = {a = 100}
Y = {a = 200, b = 300}
Y[__index] = Y
print(X.a, X.b) --> 10 nil
setmetatable(X, Y)
print(X.a, X.b) --> 10 30
Podemos agora escrever uma funo para gerar novos objetos associados classe crculo.
circulo = {x = 1, y = 2 , cor = "azul", raio = 10}
circulo.__index = circulo
function circulo:area ()
return math.pi * self.raio^2
end
function circulo:novo(t)
setmetatable (t, self)
return t
end
c = circulo:novo({x = 200, y = 100, cor = vermelho, raio = 10}) --> atribui os mtodos relativos a --circulo a c

20

print(c:area()) --> imprime na tela o calculo de rea de crculo.

3.11 Co-rotinas
3.11.1 Definio
O termo co-rotina se refere a um mecanismo que permite que um procedimento suspenda temporariamente
sua execuo e continue mais tarde. Em Lua, co-rotinas so valores de primeira clase e, ou seja, podem ser
armazenadas em funes e invocadas em qualquer ponto do programa. Alm disso, podem ser suspensas
durante a execuo de outras funes (com pilha) ou apenas enquanto executando a sua funo principal.

3.11.2 Controle de fluxo

O controle de fluxo pode ser simtrico ou assimtrico. O controle simtrico tem uma nica primitiva para
transferir o controle entre co-rotinas; o assimtrico tem duas primitivas, uma para suspender a execuo e
outra para reiniciar. Em Lua, o controle de fluxo assimtrico.

3.11.3 Criando um co-rotina

A funo coroutine.wrap cria uma co-rotina e retorna uma funo que, ao ser chamada, executa (resume) a
co-rotina.9 O parmetro nico para wrap uma funo Lua contendo o cdigo do corpo da co-rotina:
cr = coroutine.wrap (function() print (Ol mundo) end)
cr() --> imprime Ol mundo
Essa funo pode opcionalmente ter parmetros, cujos valores so dados na chamada co-rotina:
cr = coroutine.wrap (function(x) x=x^2 print(x) end)
cr(3) --> imprime na tela o numero 9
A maior vantagem parra o uso de co-rotinas est no fato de podermos suspender temporariamente a
execuo da co-rotina e posteriormente voltarmos ao mesmo ponto. Em Lua, utilizamos os comandos yield
(para suspender a execuo da co-rotina) ou resume (para continuar a execuo da co-rotina).
cr = coroutine.wrap (
function(x)
x=x^2
print(x)
coroutine.yield()
x=x^2
print(x)
end)
cr(3) --> imprime na tela o numero 9
cr(3)--> imprime 81, pois continua do mesmo ponto.

21

4. Projeto
Segue abaixo o cdigo-fonte do programa.

22

23

24

25

O array x armazena as cartas do jogador e o array y armazena as cartas da mquina.

O programa se utiliza do mecanismo que possibilita armazenarmos funes em variveis de primeira classe,
para facilitar a visualizao e o entendimento do mesmo.
O programa gera um arquivo de sada com o nome As dez maiores pontuaes++ que armazenar os 10
maiores scores.
Usei uma tabela para armazenar os 10 maiores resultados. O programa, quando inicializado, carrega esses
valores do arquivo As dez maiores pontuaes++, caso este exista no diretrio onde o arquivo *.luac est
localizado. Caso o arquivo no exista, a funo que denominei loadd gera um erro (devido ao uso da funo
assert). Como loadd est sendo chamada pela funo pcall, esse erro no ocasiona o encerramento do
programa, apenas pcall retorna nil e o jogo prossegue.
Os valores carregados so armazenados na tabela mt.
Quando o jogador vence o jogo, sua pontuao ser igual ao valor apostado pelo jogador multiplicado pelos
pontos que ele obteve no jogo. Esse valor armazenado em uma nova posio em mt, tornando-se o ultimo
elemento do array.
A funo ordenar, quando chamada, coloca a tabela mt em ordem descrecente (a partir do ndice 2, pois o
primeiro armazena uma varivel do tipo string). A funo maiores_pontuaes armazena os valores de mt no
arquivo de sada at o ndice 11 (uma string e 10 valores numricos).
O A inicialmente possui valor igual a 11, porm seu valor alterado para 1 caso, dependendo das cartas
anteriores, aquele no seja o melhor valor para o jogo do usurio ou da mquina.
Tentei contemplar todas as possibilidades em que o A deve deixar de ser igual a 11 e passar a ser igual a 1,
caso o A seja a ultima carta (pois o valor do mesmo depende apenas das cartas anteriores).
A funo cartasy escolhe aleatoriamente um elemento do baralho e atribui ao array y(cartas da mquina)
Quando chamada pela primeira vez, executa o lao apenas duas vezes (independente da soma dos pontos).
Quando chamada posteriormente executa o lao at a soma dos pontos em y ser maior que 17.
Caso a ultima carta seja um A, a funo pode alterar o valor do A de 11 para 1, caso seja melhor para a
mquina, como nas seguintes hipteses:
- A mquina recebe inicialmente duas cartas iguais a A. Nesse caso,uma delas ser igual a 1 e a outra
a 11.
-O jogador decide no pedir mais cartas. A mquina recebe uma carta A de valor igual a 11, sua
pontuao supera os 17 pontos, porm a mesma inferior pontuao do jogador. Nesse caso, o valor de 11
no o melhor para a mquina, pois ela perde o jogo. Ento, o programa atribui 1 ao A e a mquina recebe
mais uma carta,
-A mquina recebe mis uma carta e sua pontuao supera 21.
Essa tomada de deciso ocorre dentro da funo cartasy, atravs do uso do if e dos operadores lgicos and e
or.
Para as cartas do jogador, a atribuio do valor do A seguiu ao seguinte princpio: o A ter seu valor alterado
de 11 para 1 caso a pontuao do jogador supere os 21 pontos. Como o usurio s conhece uma das cartas da
mquina, a pontuao total desta no interfere na deciso.
26

5. Concluso
A linguagem Lua uma linguagem leve e poderosa. Possui sinttica simples, uma nica estrutura de dados (a
tabela), porm possibilita a realizao de programas complexos, tanto em programao procedural quanto
em orientao a objetos, devido ao seu mecanismo de delegao usando metatabelas.
Parte desse poder de Lua vem da versatilidade das tabelas, que podem ser usadas para construir arrays ou
matrizes, descrever objetos (caractersticas e mtodos), armazenar funes entre outras aplicaes.
A linguagem Lua tem sido amplamente utilizada no desenvolvimento de jogos. A Lucasarts, por exemplo,
usou a verso 3.1 de Lua para desenvolver os ttulos Grim Fandango e Scape fromMonkey Island. A
verso 3.1 de Lua foi por eles modificada para tratar co-rotinas. Hoje, como vimos suporte para co-rotinas
esta presena na verso 5.0. Double Fine utilizou Lua em Psychonauts para controlar toda a lgica do jogo.
Basicamente, a engine carrega um mundo esttico e os scripts em Lua tomam o controle, dando vida e
interatividade `as cenas. Em Baldurs Gate, Bioware usou Lua para prover uma ferramenta de depuracao
em tempo-real. Relic utilizou Lua em Impossible Creatures para controlar a IA, as aparncias dos objetos e
personagens, para definir as regras do jogo e tambm como ferramenta de depurao em tempo-real. Em
FarCry, Crytek tambm utilizou Lua para controlar diversos aspectos do jogo e para permitir a criao de
modificadores atravs da codificao de scripts Lua.

27

6. Bibliografia
http://pt-br.html.net/tutorials/html/ . Acessado em 01/10/2011
http://www.w3.org/TR/html4/interact/forms.html#h-17.3. Acessado em 01/11/2011
http://pt.wikipedia.org/wiki/Sistema_de_gerenciamento_de_banco_de_dados. Acessado em 01/10/2011
http://pt.wikipedia.org/wiki/MySQL. Acessado em 01/10/2011
http://pt.wikipedia.org/wiki/SQL. Acessado em 01/10/2011
http://www.lua.org/pil/. Acessado de 08/10/2011 a 01/11/2011
http://www.lua.org/manual/5.1/pt/manual.html. Acessado de 08/10/2011 a 01/11/2011
http://www.lua.org/manual/5.1/. Acessado de 08/10/2011 a 01/11/2011
http://www.youblisher.com/p/74341-Linguagem-Lua/. Acessado em 19/10/2011
http://www.lua.org/doc/jai2009.pdf. Acessado em 08/10/2011

28