Linguagens de Script: Caso de Estudo Lua

Linguagens de Script

Caso de estudo: Lua
Prof: Sérgio Souza Costa

Sobre mim
Sérgio Souza Costa
Professor - UFMA
Doutor em Computação Aplicada (INPE)
prof.sergio.costa@gmail.com

https://sites.google.com/site/profsergiocosta/home
http://www.slideshare.net/skosta/presentations?order=popular
https://twitter.com/profsergiocosta
http://gplus.to/sergiosouzacosta

Introdução
● Pragmática
● Conceitos chaves
● Caso de estudo: Lua

Pragmática
Script é um paradigma caracterizado por:
●
●
●
●

integração com outros sistemas
desenvolvimento rápido
eficiência modesta
funções de alto nível e para aplicações
específicas

Integração com outros sistemas
Grandes sistemas, são compostos por diversos
subsistemas
Linguagens de script, podem ser usadas para
integrar estes subsistemas.
Também, para aumentar as possibilidades de
customização de grandes sistemas.

Exemplos
● Lua
○ Jogos, multimedia, Integrado com engines

● JavaScript
○ Web, cliente, Integrado ao browser

● PHP, JSP, ASP
○ Web, servidor, Integrado com servidor de paginas
●

VbScript
○ Office, Integrado aos aplicatiovos

●

Shell Script
○ operações de sistemas operacionais

Desenvolvimento rápido
Scripts são caracterizados por um rapido
processo de desenvolvimento.
Alguns scripts são escritos e usados apenas
uma vez, tais como sequencias de comandos,
ex. shell script.
Outros usados mais frequentes, mas sempre
com modificações

Scripts são caracterizados por um rapido
processo de desenvolvimento.
Alguns scripts são escritos e usados apenas
Citem duas
uma vez, tais como sequencias de comandos,
caracteristicas que torna
ex. shell script.
o processo de
desenvolvimento rápido
nesta linguagem.

Outros usados mais frequentes, mas sempre
com modificações

Edite-rode, diferentemente de edite-compilelink-rode, das linguagens compiladas.

Edite-rode, diferentemente de edite-compilelink-rode, das linguagens compiladas.
Usualmente são dinamicamente tipadas,
facilitando o reuso de código e redigibilidade,
códigos menores

Eficiência modesta
● Eficiência não é um requisito essencial em
linguagens de script.
● Contudo, o script será apenas parte de um
grande sistema,
● Dificilmente, um sistema será todo
desenvolvido em uma linguagem de script
● Veja o comparativo das linguagens quanto a
velocidade, observem a colocação das
○

http://shootout.alioth.debian.org/u32/which-programming-languages-are-fastest.php

Eficiência modesta
● Eficiência não é um requisito essencial em
Por que estas
linguagens não são
● Contudo, o script será apenas parte de um
tão eficientes ?
grande sistema,
● Dificilmente, um sistema será todo
desenvolvido em uma linguagem de script
● Veja o comparativo das linguagens quanto a
velocidade, observem a colocação das
○


Funções de alto nível
● Como, são de uso específicos, elas teram
funções de alto nível que tem como objetivo
facilitar o seu uso.

Conceitos chaves
Linguagens de script são similares a
linguagens imperativas:

Conceitos chaves
Linguagens de script são similares a
linguagens imperativas:
● Variaveis, que mudam de valor
● Comandos,
● Procedimentos, com efeitos colaterais

Conceitos chaves
Podemos destacar algumas caracteristicas
específicas:
● processamento de strings em alto nivel
● suport a interface gráfica em alto nível
● dinamicamente tipadas

Caso de estudo: Lua
GUIA ESSENCIAL: Principais Conceitos

Lua
● Desenvolvida na PUC-Rio desde 1993
● Início modesto, para uso interno expansão
lenta e gradual
● "Comitê" de três pessoas: Roberto
Ierusalimschy, Luiz H. de Figueiredo,
Waldemar Celes
● Lua, é usado em jogos, tv interativa
(nclLua), modelos dinamicos (terrame-inpe)
...

Uma das linguagens mais usadas
Neste mês teve uma
queda. No mês anterior
ela estava a frente de
Ruby, JavaScript,
Delphi

http://www.tiobe.com/index.
php/content/paperinfo/tpci/index.html

Mais eficiente que suas
"concorrentes"


Lua
● Linguagem de script
○ similariedade com Perl, Python, Tcl
● Uma linguagem de extensão
○ ênfase em comunicação inter-linguagens
○ enfatiza desenvolvimento em múltiplas linguagens

● Uma linguagem de descrição de dados
○ anterior a XML

XML - Lua - Json
<note>
<to>Tove</to>
<from>Jani</fr>
<heading>Reminder</heading>
<body>Don't forget me this weekend!</body>
</note>

XML

XML - Lua - Json
<note>
<to>Tove</to>
<from>Jani</fr>
</note>

XML

note{
to = "Tove",
from= "Jani",
heading ="Reminder",
body="Don't forget me this weekend!"
}

Lua

XML - Lua - Json
<note>
<to>Tove</to>
<from>Jani</fr>
</note>

XML

note{
to = "Tove",
from= "Jani",
heading ="Reminder",
body="Don't forget me this weekend!"

Lua

to : "Tove",
from : "Jani",
heading :"Reminder",
body:"Don't forget me this weekend!"

JSON

}
note{

}

Lua em Jogos
"It is easy to see why Lua is rapidly becoming
the de facto standard for game scripting."
Artificial Intelligence for Games, Morgan
Kaufmann, 2006. "It's quite possible that game
developers will look back at the 2000s as the
decade of Lua".,
Game Programming Gems 5,
Charles River Media, 2005.

Lua:Aplicações
● Ginga
○ middleware padrão brasileiro para TV digital

● Wireshark
○ analisador de protocolos

● Snort
○ intrusion detection and prevention system

Lua: Aplicações
● TerraME
○ Ambiente de modelagem dinâmica (INPE),

● nmap
○ rastreador de redes para segurança

● Eyeon's Digital Fusion
○ pós-produção de filmes

● E muitas outras...

Lua: vantagens
● Portabilidade
○ No contexto que foi proposto, não havia outra
linguagem que rodasse no unix, windows, linux ...

● Simplicidade
○ sintaxe simples

● Pequeno tamanho
○ Ainda é muito pequenas, bibliotecas e includes não
ultrapassa 700 kb.

Lua: vantagens
● Acoplabilidade
○ Facil integração com C, deste modo com diversas
linguagens.
○ C, é o ingles das linguagens de programação ..

● "Eficiência",
○ ainda é uma das mais eficientes linguagens
dinamicas e de scripts

Lua: Sintaxe
● Sintaxe com inspiração no Pascal
● O uso de ; é opcional
function fact (n)
local f = 1
for i =1, n do
f=f*i
end
return f
end

Lua: Comentários
● Comentarios em linha
-- este é um comentario
● Comentario em bloco
--[[
este é
um
comentario
--]]

Lua: usando
● Linguagem interpretada
● Não existe o conceito de função principal
● Meu primeiro programa
print ( "hello world" )

Ou
function ola ()
end
ola() -- chamando a função

Lua: usando
● Linguagem interpretada
● Não existe o conceito de função principal
● Meu primeiro programa

Ou

Salve estes programas
em um arquivo primeiro.
lua e execute-o:

function ola ()
> lua primeiro.lua
end
ola() -- chamando a função

Lua: Usando
Usando no modo iterativo:

sh> lua
> print ( "ola mundo !!" )
> print (10+9)

Lua: Atribuições
Em Lua, podemos fazer atribuições multiplas:
a = 10
b = 20
a, b = b, a

Lua: Sistema de tipos
● Linguagem dinamicamente tipada
● Escopo e amarração de variáveis
○ Tudo é global, até que se prove o contrário

● Tipos de dados
○ nil, boolean, number, string, table, function, userdata

● Funções como valores de primeira ordem
○ Parametros e retorno de funções, tem a mesmos
previlegios dos outros tipos

Lua: Sistema de tipos
Como os tipos variam durante a execução, lua
fornece uma função que retorna o tipo de uma
variavel:
print (type (a))
a = 1234
print (type (a))
a = "ola"
print (type (a))

Quais serão as saídas ?

Lua: tipos de dados
●
●
●
●
●
●

nil
number
string
function
userdata
table

Tipo nil
● Representa o valor indefinido ou inexistente.
● Tipo do valor default das variáveis
● Também significa o falso booleano
○ Qualquer valor de outro tipo significa verdadeiro
■ Com exceção de false

Tipo boolean
● Valor booleano
○ Falso (false) ou verdadeiro (true)

if (choveu == true) then ....
● Operadores relacionais booleanos
==, ~=, <, >, <=, >=

Tipo number
Único tipo nativo para valores numéricos
double (por default)
a=3
b = 3.5
c = 4.5e-8

Tipo string
● Valores imutáveis
○ Não é um vetor de caracteres, não tem como
modificar uma dada posição

● Sem limite de tamanho
○ É comum ler arquivo completo em uma string
○ Similar ao Haskell

● Strings não usam 0 para terminação
● Podem armazenar dados binários quaisquer
● Pattern-matching poderoso
○ Implementado via biblioteca padrão

Tipo String
Exemplo:
a = "ola"
b = "mundo"
c = a.." "..b -- o .. é usado para concatenar
print (c)

Tipo function
Duas notações:

function inc (x)
return x+1
end

inc = function (x)
return x+1
end

Tipo function
Valores de primeira classe
function twice (f, a)
return f (f (a))
end
function dobra (a)
return 2* a
end
print (twice (dobra, 4))

w={
redraw = function () ...
end,
pick = function (x,y) ...
end,
}

Tipo function
Retorno multiplos
function f (a,b)
return 2*a, 2*b
end
print ( f(4,5))

Tipo function
Passando multiplos parametros:

function f(...)
for i=1, #arg do
print(arg[i])
end
end
f (5,7,8)

Tipo function
Funções anônimas, suporte a notação lambda
a = twice (2, function (x) return 2*x end)
print (a)

Amarração
● Tudo é global até que prove o contrário
● Importante, sempre declare como local suas
variaveis dentro das funções
function f1 ()
local a = 1;
end
f1()
print (a)

Amarração
● Tudo é global até que prove o contrário
● Importante, sempre declare como local suas
variaveis dentro das funções
function f1 ()
local a = 1;
end
f1()
print (a)

Rode este código com e
sem a palavra reservada
"local"

Amarração
● Acesso a variáveis em escopos externos
○ Closures

● Expressão cujo valor é calculado quando a
função que a contém é criada
○ Quando o fecho é feito

function add (x)
return function (y)
return y+x
end
end

add1 = add(1)
print(add1(10)) --> 11

Tipo userdata
● Armazena um ponteiro void* de C
● Tipo opaco para a linguagem
○ Somente atribuição e teste de igualdade

● Linguagem extensível em C
○ Esqueleto para construção de linguagens de
domínio específico

Tipo table
●
●
●
●

Resultado da expressão {}
Arrays associativos
Qualquer valor com chave
Único mecanismo de estruturação de dados
○ É para Lua o que lista é para Lisp

Tipo table
The only structured data type is table. I implements
associative arrays, that is, arrays that can be indexed not
only with integers, but with string, double, table, or function
values.
For table indexing, both table.name and table[''name''] are
acceptable. Tables can be used to implement records,
arrays, and recursive data types.

Tipo table
Como vetores, o primeiro indice é 1
v = {2,3,5,6}
print (v[1], v[2])
Matrizes, tabela de tabela
m = { {1,2,3},{4,5,6}}
print (m[2][2])

Tipo table
● Pode ser indexada por diferentes tipos, não
somente inteiros
● Estrutura de dados registros ou tipos
cartesianos
● Acessando dado, notação "sugar"
t.x para t["x"]:

Tipo table

pessoa = {
Nome = Joao ,
Idade = 20,
Telefone = 66666666
}
print (pessoa.Nome)
print (pessoa[Nome])

Tipo table
Descrição de dados + semântica imperativa
article{
author="F.P.Brooks",
title="The Mythical Man-Month",
year=1975
}

temp = {}
temp["author"] = "F.P.Brooks"
temp["title"] = "The Mythical Man-Month"
temp["year"] = 1975
article(temp)

Unico
construtor

Tipo table
● Duas maneiras de percorrer tabelas
○ table.foreach será removida de versões futuras.

t = {4,5,6,7,8}
for i,v in pairs (t) do print (i,v) end
table.foreach (t, function (i,v) print (i,v) end)

Tipo table
Atribuição de tabela é sempre referencia,
similar a Java ,JavaScript ... :
a = {"joão"}
b=a
print (a[1], b[1])
b[1] = "Maria"
print (a[1], b[1])

Tipo table
● Funções 1a classe + tabelas = quase OO
○ Tabelas podem ter funções como campos
p = {x = 10, y = 20} -- dados
-- cria uma função na tabela "p"
function p.getX (self)
print (self.x)
end
-- chama a função da tabela "p"
p.getX(p)

Tipo table
● Funções 1a classe + tabelas = quase OO
○ Tabelas podem ter funções como campos

● "Sugar notation"
p = {x = 10, y = 20}
function p:getX ()
// nao precisa passar explicito self
print (self.x)
end
// nao precisa passar "p"
p:getX()

Tipo table
Existem diversas funções úteis (olhar manual):
t = {2,3,4,5}
table.getn (t) -- retorna o tamanho da tabela
#t -- ao inves de getn, podemos usar o operador "#"
table.insert (t, 10)
table.remove (t) -- equivalente ao pop, remove o ultimo
...

Construtores
Simulando POO
person = {};
person.name = "Nicholas";
person.age = 29;
person.job = "Software Engineer";
function person:sayName ()
print(self.name);
end
person:sayName()

Construtores
Simulando POO
person = {};
person.age = 29;
print(self.name);
end
person:sayName()

Sempre que criar um novo
"person", terei que escrever a
função sayName?

Construtores
Simulando POO
person = {};
person.age = 29;
print(self.name);
end
person:sayName()

Sempre que criar um novo
"person", terei que escrever a
função sayName?

Qual a solução ?

Construtores
function Person(name, age, job)
local self = {}
self.name = name;
self.age = age;
self.job = job;
self.sayName = function()
print(self.name);
end
return self
end
person1 = Person("Nicholas", 29, "Software Engineer");
person2 = Person("Greg", 27, "Doctor");
person1:sayName ()
person2:sayName ()

Construtores
local self = {}
self.name = name;
self.age = age;
self.job = job;
print(self.name);
end
return self
end

Qual o problema desta
solução ?

person1:sayName ()
person2:sayName ()

Construtores
local self = {}
self.name = name;
self.age = age;
self.job = job;
print(self.name);
end
return self
end

Qual o problema desta
solução ?
Como resolver ?

person1:sayName ()
person2:sayName ()

Construtores
● Solução: metatabelas, conceito "prototype",
presente em diversas outras linguagens
● Conceito chave: separar os metodos em
uma tabela distinta, de modo a ter replicas
destes metodos na memoria.

Construtores: Metatabela
Separando metodos dos dados:
person_methods = {
sayName = function (self) print (self.name) end
}
local self = {}
self.name = name;
self.age = age;
self.job = job;
setmetatable(self, {__index = person_methods} )
return self
end
person2:sayName ()

Estou dizendo para a
linguagem procurar
nos indices (__index)
de outra tabela,:

Sobrecarga de operadores

local Point_metatable = {
__add = function (p1,p2) return Point(p1.x+p2.x,p1.y+p2.y) end
}
-- Construtor
function Point (p1,p2)
local self = {}
self.x = tonumber(p1) or 0.0
self.y = tonumber(p2) or 0.0
setmetatable(self,Point_metatable)
return self
end
local r = Point (3,4) + Point (5,2)
print (r.x, r.y)

Estou dizendo como
ele faz a soma, _add

Controle de fluxo
if (10 > 5) then
print ("10>5")
else
print ("algo de muito errado")
end
for i = 0, 10 do
print ("i",i)
end

i=0
while (i < 10) do
print ("i", i)
i=i+1
end

Programação modular
Que estrutura é usada para modularizar ?

Que estrutura é usada para modularizar ?

TABELAS, logicamente, :)

● Lua utiliza a combinação de tabelas com
funções de primeira classe para construção
de módulos.
○ As bibliotecas padrão de Lua são implementadas
como módulos via tabelas.

● Exemplo
mod1.lua
mod1 = {}
function mod1.ola()
print ("Ola, modulo")
end

main.lua
require "mod1"
mod1.ola()

Usando a API C
●

Para usar a API C do Lua, basta baixar a
versão de biblioteca referente ao seu
sistema (Linux, Windows, 32bit, 64bits ....)
●

http://sourceforge.
net/projects/luabinaries/files/5.1.4/

Entendendo a API
●

Não tenho como objetivo ensinar esta API,
apenas mostrar o mecanismo de
integração de uma linguagem de script.
●

●

O mecanismo irá variar de linguagem para
linguagem.

Esta API é relativamente simples,

Conceitos chave
●
●

●

Carregue o arquivo Lua na memoria.
Consulte valores da memoria, e coloque
os na pilha.
Retire os valores da pilha e traga-os para
variaveis do C.

Considere o seguinte arquivo
config.lua

width = 200
height = 300

Função para ler o arquivo
void load (char *filename, int *width, int *height) {
lua_State *L = luaL_newstate ();
luaL_openlibs(L); /* opens Lua */
// carrega o arquivo
if (luaL_loadfile(L, filename) || lua_pcall(L, 0, 0, 0))
error(L, "cannot run configuration file: %s”, lua_tostring(L, -1));
// consulta valores, e coloca na pilha
lua_getglobal(L, "width");
lua_getglobal(L, "height");
// verifica, e pega o valores da pilha
if (!lua_isnumber(L, -2)) error(L, "`width' should be a numbern");
if (!lua_isnumber(L, -1)) error(L, "`height' should be a numbern");
*width = (int)lua_tonumber(L, -2);
*height = (int)lua_tonumber(L, -1);
lua_close(L);
}

A função principal ...
int main () {
int w, h;
load("./config.lua", &w, &h);
printf ("%d - %d n", w,h);
}

Função definida
anteriormente

Nome do
Arquivo

A função principal ...
Função definida
anteriormente

int main () {
int w, h;
load("./config.lua", &w, &h);
printf ("%d - %d n", w,h);
Nome do
Lembrem-se que
}

Arquivo
em Lua o arquivo
de configuração
não precisa ser
tão simples

Chamando funções
Considerem o seguinte arquivo config.lua

function soma (a, b)
return a+b
end

Chamando funções
Dado um estado do arquivo lua, poderiamos
carrega-la:
int soma (lua_State *L, int a, int b) {
int res;
lua_getglobal(L, "soma");
lua_pushinteger (L, a);
lua_pushinteger (L, b);
if (lua_pcall (L, 2, 1, 0) != 0 )
printf ("erron");
res = lua_tointeger (L,-1);
return res;
}

Chamando funções
A função main, ficaria:
int main () {
int r;
if (luaL_loadfile(L, "./config.lua") || lua_pcall(L, 0, 0, 0))
error(L, "cannot run configuration file: %s",lua_tostring(L, -1));
r = soma(L, 10, 20);
printf ("%dn", r);
lua_close(L);
}

Chamando funções
A função main, ficaria:
int main () {
int r;

Saber mais sobre a API,
acesse:

if (luaL_loadfile(L, "./config.lua") || lua_pcall(L, 0, 0, 0))
error(L, "cannot run configuration file: %s",lua_tostring(L, -1));

Conceitos Básicos e API C

r = soma(L, 10, 20);
printf ("%dn", r);
lua_close(L);
}

Linguagens de Script: Caso de Estudo Lua

Mais conteúdo relacionado

Mais procurados

Semelhante a Linguagens de Script: Caso de Estudo Lua

Mais de Sérgio Souza Costa

Linguagens de Script: Caso de Estudo Lua