Documentacao_Luatoy

Prévia do material em texto

UFBA/DCC 
MATA61 – COMPILADORES 2013.1 
 
Danilo Azevedo 
Danilo Dias 
Ive Andresson Tourinho 
 
Linguagem-Base: LUA 
 
Definição: Luatoy é uma linguagem de programação compilada baseada na linguagem de 
programação LUA (interpretada e dinâmica), Luatoy tem estrutura procedimental, há nela 
construções para descrição de dados, baseadas em tabelas associativas, semântica extensível e 
expressões regulares, linguagem com tipos fortes. 
 
 
http://www.lua.org/cgi-bin/demo 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Sumário: 
 
1. Palavras reservadas 
2. Expressóes regulares para alguns tokens da linguagem* 
3. Simbolos 
4. Comentarios ( expressão regular)* 
5. Sintaxe e Semãntica dos principais comandos ( extensões) 
6. Gramática completa da linguagem base ( VERMELHO corte, VERDE extensões) 
7. “Start” da gramática 
8. Legenda para BNF para expressões regulares 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Convenções Léxicas Luatoy: 
 Os itens em cor verde indicam extensões à linguagem base(Lua), e os itens em cores 
vermelhas indica os cortes. 
 
 
 
1- Palavras-chave e caracteres: 
As seguintes palavras-chave são reservadas e não podem ser utilizadas como nomes: 
 and break do else elseif end false for function if 
 in local nil not or return repeat return then true until while 
 number string array void switch case const print read io.read void 
As seguintes cadeias denotam outros itens léxicos: 
 + ++ - - - * / % ^ # 
 == ~= <= >= < > = 
 ( ) { } [ ] 
 ; : , . .. ... 
2 - Cortes: 
 
2.1 - Palavras Reservadas, variaveis e strings 
Exluido Case Sensitive para palavras reservadas (equalsIgnoreCase em Java). Uso apenas de aspas 
simples para Strings e podem conter as seguintes seqüências de escape no estilo de C: '\n' (quebra 
de linha), '\\' (barra invertida), '\"' (citação [aspa dupla]) e '\'' (apóstrofo [aspa simples]). Exclui 
todas as regras de aspas longas descritas no manual de referenciada linguagem serão excluidas, 
assim como comentário longo – só serão utilizados comentarios curtos - e regras de constantes. 
Comentarios serão apenas com “--”. Tudo – apenas na mesma linha -que vir depois desta cadeia de 
caracter será entendida como comentario e não será interpretada pelo compilador. 
Excluidos os tipos userdata, thread e table e todas as funcionalidades associadas a estes tipos. 
A estrutura table será substituida por uma nova estrutura chamada array. 
As funções “nativas” da linguagem Lua serão excluidas,exceto funções de entrada e saida, e só 
serão permitidas uso de funções declaradas e definidas localmente ao projeto que a utiliza. 
As funções de conversão automática que a linguagem provê serão excluidas. 
 
2.2 - Declarações 
Variáveis globais e locais serão diferenciadas de acordo com o local onde foram declaradas e só 
serão validas no seus escopo. As palavras reservadas local e global não existirão. 
Consequentemente , as tabelas de ambiente não serão usadas. Atribuições multiplas não serão 
permitidas. 
2.3- Estruturas de Controle 
As estruturas de controle if, while e repeat possuem o significado usual e a sintaxe familiar: 
 comando ::= while exp bloco end 
 comando ::= repeat bloco until exp 
 comando ::= if exp bloco [else bloco] end 
2.4 - Expressões 
Expressões vaarg não serão permitidas. 
2.4.1- O Operador de Comprimento 
O operador de comprimento denotado pelo operador unário #, não estará presente na linguagem 
toy. 
2.5 - Tratamento de Erros 
O tratamento de erros da LuaToy, será feita pelo programador através de estruturas de controle. Os 
vinculos com com a linguagem C no que diz respeito a tratamento de erros, não estará presente na 
nova linguagem. 
2.6 – Metatables 
O recuso de metatables não será ultilizado. 
 
2.7– Ambientes 
Os ambientes também serão excluidos da nova linguagem. 
2.8 - Coleta de Lixo 
Este Recurso não será implementado. 
2.9 - Co-rotinas 
Lua oferece suporte a co-rotinas, também conhecidas como fluxos de execução (threads) 
colaborativos. Em LuaToy esta funcionalidade não será implementada. 
2.10 - A Interface de Programação da Aplicação (API) 
A API C para Lua será substituida por uma nova API LuaToy, desenvolvida nesta mesma linguagem, 
seguindo o padrão de nomenclatura da linguagem base Lua. Bibliotecas auxiliares Lua, não estarão 
presentes na nova linguagem toy. 
 
2.11 – Funções 
O retorno multiplo presente na linguagem-base, não mais existirá; a nova linguagem deverá 
suportar apenas o retorno simples; um só valor poderá ser retornado. 
 
3 - Extensões: 
 
3.1 - Palavras Reservadas, variaveis e strings 
O uso de constantes será marcado com a palavra reservada “const” seguido do nome da constante; 
Variáveis serão declaradas conforme o exemplo: 
 
number k 
const gravity = 10 
 
3.2- Estruturas de Dados 
A linguagem Luatoy terá, como unica estrutura de dados a estrutura array como vetor 
bidimensional. O tipo dos dados que o array ira armazenar deve vir antes da palavra-chave array – 
tipos mistos não serão permitidos. 
Exemplos: 
 array number vet [2] = {2 , 3 } 
3.3 – API Lua 
Mini API LuaToy será criada, com algumas funcões básicas da linguagem original, porém em alguns 
casos com sintáxe diferenciada. 
Exemplo: 
 number result = add(2,3) 
 print(“ compiladores”) 
 
3.4 – Funções 
Diferente da linguagem-base – Lua – as funções em Luatoy devem ser tipadas; seu tipo de retorno 
deve ser especificado na implementação.Os tipos dos parametros também devem ser 
especificados. 
 number function printer(number c) 
 string b = “olámundo” 
 print(b.c) 
 return c 
 end 
 
3.5 – Outros Exemplos 
3.5.1 - Comandos de Seleção 
 
 if b 
 print(“b diferente de nil”) 
 if a 
 print(“b igual a nil”) 
 else 
 print(“saindo”) 
 end 
 
 switch exp 
 case 1: 
 print (“bloco 1”) 
 case 2: 
 print (“bloco 2”) 
 break 
 
3.5.2 - Comandos de interação 
 
 while expr 
 print (“bloco ”) 
 end 
 
 repeat 
 i=i–1 
 until (i == 0) 
 
3.5.3 – Exemplos de Programas 
Ex enquanto: 
while i == 10 
 if(( i / 2) == 0) 
 print (“ argumento :” i) 
 end 
i = i +1 
 end 
 
Ex repita até: 
 repeat 
 i=i–1 
 until (i == 0) 
 
Ex QuickSort: 
void function quickSort(number array v[], number ini, number fim) 
 number i = ini 
number j = fim 
 number pivo = v[floor((ini + fim)/2)] 
 
 while i <= j 
 while (v[i] < pivo) 
 i=i+1 
 end 
 
 while (v[j] > pivo) 
 j=j-1 
 end 
 
 if (i<=j) 
 v[i] = v[j] 
v[j]= v[i] 
 i = i+1 
j= j-1 
 end 
 end 
 
 if j > ini 
 quickSort(v, ini, j) 
 end 
 if i < fim 
 quickSort(v, i, fim) 
 end 
end 
obs: a função floor (função matemática teto) terá que ser implementada já que a linguagem ainda 
não dá suporte a bibliotecas matemáticas externas. 
 
8 - Sintaxe completa Luatoy 
 
 
programa::= {comando [`;´]} [ultimocomando [`;´]] 
 
bloco::= programa 
 
comando::= listarvariaveis `=´ listarexpressao |while expressao bloco end | repeat bloco until 
expressao |if expressao bloco [else bloco ] end |function nomedafuncao corpodafuncao end 
 
ultimocomando ::= return [listarexpressao] | break 
 
nomedafuncao ::= Nome {`.´ Nome} [`:´ Nome] 
 
listarvariaveis ::= tipo variavel {`,´ variavel} 
 
variavel ::= Nome | expprefixo `[´ expressao `]´ | expprefixo `.´ Nome 
 
 tipo ::= boolean | number [ array] | string [ array] | array | // float e int pertence a uma só classe NUMBER 
 
 listarexpressao ::= {expressao `,´} expressao 
 
 funcao ::= function corpodafuncao 
 
expressao ::= nil | false | true | numero | cadeia | `...´ | funcao | expprefixo | expressao operadorexpressao | operador expressao 
 
 expprefixo ::= variavel | `(´ expressao `)´ 
 
 argumentos ::= `(´ [listarexpressao] `)´ | cadeia 
 
corpodafuncao ::= `(´ [listarparametros] `)´ bloco 
 
listarparametros ::= listadenomes [`,´ `...´] | `...´ 
 
listadenomes ::= Nome {`,´ Nome} 
 
operador ::= `+´ | `-´ | `*´ | `/´ | `^´ | `..´ |`<´ | `<=´ | `>´ | `>=´ | `==´ | `~=´ |and | or | not 
 
 
9 - Start da Linguagem 
 
Assim como a linguagem-base, a Luatoy tem como start qualquer palavra reservada pertencente a 
gramática especificada. Podemos começar qualquer script Luatoy com uma declaração de variavel, 
uma declaração/implementação de função, um comando de repetição, desde que seja válido. O 
codigo não deve começar, por exemplo com uma chamada de função , ou atribuição de valor à 
uma variavel que não foi declarada anteriormente. 
 
10 - Legendas para BNF para expressões regulares 
 
Letra  a-zA-Z 
Digito  0-9 
Identificador  Letra (Letra | Digito)* 
Numero  Digito+(Digito*[‘.’]Digito+) 
Operador  `+´ | `-´ | `*´ | `/´ | `^´ | `..´ |`<´ | `<=´ | `>´ | `>=´ | `==´ | `~=´| `,´ |and | or | not 
PalavrasReservadas  and | break | else | end | function | if | nil | not | or | return | repeat | true 
| until | while | number | string | array | void | switch | case | const 
Token  Numero | Identificador | Operador | PalavrasReservadas 
Separador  / | \n | \t | ‘ ’ | “ ” 
 
Obs: na linguagem Luatoy, é preciso verificar sobre a procedência de comando / por linha visto que 
foi retirado algumas palavras reservadas que iniciavam este comando a exemplo temos o “if then 
end” (LUA), Luatoy foi retirado o “then” provavelmente temos que substituir o “then” e outros 
similares por “\n” quebra de linha, tipo a declaração de variáveis ocorre o mesmo tem que ser uma 
variável por linha.