Compiladores Construção de Interpretadores e Compiladores para a linguagem Arith

Transcrição

1 Compiladores Construção de Interpretadores e Compiladores para a linguagem Arith Simão Melo de Sousa Departamento de Informática Universidade da Beira Interior Conteúdo 1 Introdução 2 2 A linguagem Arith 2 3 Análise léxica e sintáctica 3 4 Árvores de sintaxe abstracta 3 5 Análise Semântica Tabelas dos símbolos Vericação estática dos tipos Interpretação de programas Arith 11 7 Compilação de programas Arith Arquitectura da máquina virtual alvo Instruções máquinas relevantes Programa principal 12 9 Extensões 13 1

2 1 Introdução O objectivo desta cha prática é implementar: um pequeno interpretador um pequeno compilador para uma linguagem de expressões aritméticas chamada Arith. Contemplaremos igualmente a denição de algumas extensões ao referido compilador que, consoante a diculdade, poderão servir de base a pequenos trabalhos. 2 A linguagem Arith A linguagem Arith permite avaliar expressões aritméticas simples e dar um nome a certas expressões. Um programa em Arith é composto por uma sequência de instruções da forma: s e t i d e n t = e x p r ; p r i n t e x p r ; onde ident é um identicador e expr uma expressão aritmética podendo conter declarações de variáveis locais da forma: l e t i d e n t = e x p r i n e x p r A gramática. Mais formalmente a sintaxe das instruções Arith pode ser descrita pela gramática seguinte: <i n s t > : : = s e t <i d e n t > = <expr > ; p r i n t <expr > ; <expr > : : = < i n t e i r o > <r e a l > <i d e n t > <expr > <binop > <expr > <unop> <expr > l e t <i d e n t > = <expr > i n <expr > ( <expr > ) <binop > : : = + / <unop> : : = 2

3 Um programa Arith é assim uma sequência não vazia de instruções. Convenções léxicas. Espaços, tabulações e caracteres de nova linha constituem os caracteres "brancos". As palavras set, let, in e print formam o conjunto das palavras chave; <ident> é a classe dos identicadores que só podem ser constituídos por caracteres alfa-numéricos ou o '_' e começar por uma letra; a classe <inteiro> é a classe das sequências de algarismos; e nalmente a classe <real> é a classe dos números reais. De forma sintética podemos descrever estas duas classes numéricas pelas expressões regulares seguintes: digito ::= 0-9 inteiro ::= -?(digito)+ real ::= -?(digito)+(.(digito)*)?((e E)(+ -)?(digito)+)? Finalmente, os operadores aritméticos usufruem das prioridades e das regras de associatividade habituais. 3 Análise léxica e sintáctica Exercício 1: (Parsing and Lexing) Dena um analisador léxico e um analisador sintáctico para a linguagem Arith. Os analisadores construídos deverão ter em conta uma gestão apropriada dos erros que possam surgir (por enquanto léxicos e sintácticos). 4 Árvores de sintaxe abstracta Exercício 2: (Árvore de sintaxe abstracta) Dena os tipos instr, expr e prg sugeridos pela gramática da linguagem Arith. Implemente o tipo dos identicadores pelo tipo: t y p e i d e n t = s t r i n g 3

4 Estes tipos permitam uma representação estruturada e rigorosa dos programas da linguagem sob a forma de árvores de sintaxe abstracta. Exercício 3: (Lexing e Parsing (bis)) Modique os analisadores léxicos e sintácticos por forma a que seja construída uma árvore de sintaxe abstracta no caso de uma análise bem sucedida. O parser e o lexer construídos deverão, mais uma vez, assinalar de forma clara e precisa os erros. 5 Análise Semântica 5.1 Tabelas dos símbolos A politica de utilização de variáveis dos programas Arith é relativamente simples: devemos assinalar com um erro qualquer utilização de variável que não foi previamente denida. A redenição de um símbolo existente não deverá originar um erro. Mas, neste caso, a denição mais recente esconde a denição prévia. Este comportamento só terá importância quando implementarmos o interpretador e o compilador. Outro aspecto por considerar nos programas Arith é o seguinte: a execução de programas Arith necessita que seja guardada a informação dos valores das variáveis denidas ao longo do programa. Estes dois factos levam a que seja considerada a construção de duas tabelas de símbolos que representarão ambientes de execução. Um ambiente representa o estado da memória disponível para um determinado programa durante uma determinada execução. Teremos uma tabela de símbolos globais e uma tabela de símbolos locais. A diferença fundamental entre as duas tabelas de símbolos é o facto de que a tabela de símbolos locais arquiva variáveis temporárias (por serem locais) que deverão desaparecer no m da análise de cada instrução. I.e., no m de cada instrução, a tabela de símbolos locais é reinicializada. Outro aspecto a considerar é que os símbolos locais tem prioridade em relação aos símbolos globais. 4

5 Assim sendo, aquando da introdução (denição) dum símbolo deveremos guardar na tabela de símbolo adequada (local ou global) a informação de que a variável foi denida. Para termos uma gestão uniforme dos símbolos no interpretador e no compilador, arquivaremos também o tipo e o valor (quando possível) de cada símbolo. O compilador precisará do nome e do tipo de cada símbolo, enquanto o interpretador precisará adicionalmente do valor associado a cada símbolo. Considerando o tipo option do OCaml que é denido como: type ' a o p t i o n = None Some of ' a utilizaremos o tipo: type v a l o r t = NoI I n t e i r o of ( i n t o p t i o n ) R e a l of ( f l o a t o p t i o n ) onde NoI representa a ausência de informação (NoI = No Information), ( Inteiro x) representa um valor de tipo inteiro. Quando este valor é conhecido então x = (Somev) em que v é um inteiro. Se a única informação disponível é o tipo, então x = N one. De forma semelhante o elemento (Real y) representa um valor de tipo real. Como no caso inteiro, y guarda um valor real. Numa primeira abordagem às tabelas de símbolo, codicaremo-las como listas associativas (Consultar para esse efeito a secção Association Lists do manual de referência da linguagem OCaml,). Repare que poderíamos também ter utilizado o tipo denido no módulo Map (Documentação) De forma resumida, uma lista associativa é uma lista de pares de tipo (' a 'b) em que cada par representa a associação de um valor de 'a (a chave) com um valor de 'b (o valor). No caso de existir dois pares com a mesma chaves, só o primeiro par será considerado. A função de procura de valores em listas associativas é a função List. assoc cujo protótipo é: v a l a s s o c : ' a > ( ' a ' b ) l i s t > ' b (assoc a l ) devolve o valor associado a a na lista associativa l. Isto é, (assoc a [...;( a,b);...]) = b se (a,b) é o par (chave,valor) a mais a esquerda na lista l. A execução de (assoc a l ) levanta a excepção Not_found se não existir tal associação na lista. Utilizaremos assim os tipos: 5

6 type t s i m b o l o s = ( i d e n t v a l o r t ) l i s t type env = t s i m b o l o s r e f para codicar os ambientes (locais e globais). Relembramos que o tipo ident representa o tipo dos identicadores Para simplicar, designaremos por genv o ambiente global (de tipo env) e por lenv o ambiente local (igualmente de tipo tsimbolos). A diferença entre genv e lenv reside na natureza das variáveis locais, isto é no facto de que o ambiente das variáveis locais deve ser reinicializado convenientemente cada vez que a analise sai de um let x =... in... (cada vez que x "perde"vida). Neste sentido, é mais conveniente considerar a tabela local como um parâmetro suplementar às funções de análise e não como uma variável mutável (de tipo env). Exercício 4: (Implementação da tabela dos símbolos por uma lista associativa) Modique a construção da árvore de sintaxe abstracta de forma a que sejam construídas e utilizadas tabelas de símbolos. A modicação deverá contemplar os pontos seguintes: 1. A utilização duma variável não previamente denida deverá resultar num erro semântico devidamente assinalado. 2. O teste de existência de variáveis deverá considerar a procura na tabela de símbolos locais como prioritária. 3. A denição de uma variável local deverá resultar na actualização do ambiente local. 4. A denição de uma variável global deverá resultar na actualização do ambiente global. 5. Nesta fase da análise semântica, o valor por arquivar com uma variável identicada por x é (`` x '', NoI). 6. A análise semântica duma expressão ou instrução deverá ter em conta reinicializações adequadas do ambiente local. 6

7 No exercício anterior utilizamos ambientes de tipo ( ident valort ) list. No entanto, quando o número de variáveis é grande, o custo da operação de procura (numa lista) começa a ser importante. Habitualmente prefere-se à utilização das listas a utilização de estruturas de arquivo como as tabelas de hash. Com este tipo de estruturas a operação de procura é mais eciente. O objectivo do exercício seguinte é substituir o ambiente global genv por uma tabela de hash. Exercício 5: (Implementação da tabela dos símbolos por uma tabela de hash (Bis)) Modique a análise semântica do exercício anterior por forma a que utilize ambientes implementados com a ajuda de tabelas de hash do módulo Hashtbl da biblioteca standard do OCaml. 5.2 Vericação estática dos tipos Uma das mais importantes vericações realizadas pela análise semântica é a vericação estática dos tipos do programa alvo. Basicamente, trata-se de vericar se todas as execuções possíveis do programa contemplam exclusivamente operações com parâmetros adequados, e isso sem precisar de executar o programa em si. De facto esta fase da análise deves ser capaz de detectar, por exemplo, que uma operação sobre inteiros terá potencialmente parâmetros reais. A política de tipo por garantir na linguagem Arith é relativamente simples: em qualquer operação aritmética todos os valores envolvidos devem ser do mesmo tipo. Por exemplo, se uma expressão conter um real, todos os outros valores devem ser também reais. Vamos dar a seguir uma apresentação detalhada do algoritmo de vericação. Primeiro introduzimos algumas notações. Seja e uma construção da linguagem Arith (um programa, uma instrução ou uma expressão), t um tipo e Γ uma lista de pares (x : t x ) (onde x é um símbolo e t x um tipo) Γ e : t signica que no contexto Γ (que representa o conjunto das declarações feitas e aceites antes de analisar e), a expressão e tem por tipo t. A notação 7

8 Γ, (x : t x ) e : t designa o contexto Γ aumentado da declaração (x, t x ). Seja p inst 1 ;... ; inst n um programa (contendo n instruções) Γ inst 1 ;... ; inst n : signica que p é constituído exclusivamente de elementos (expressões etc,...) bem tipados. Informalmente, o algoritmo funciona da seguinte forma: são percorridos sequencialmente e recursivamente todas as construções do programa Arith analisado. O contexto inicial duma vericação de um programa é o contexto vazio. Este contexto vai evoluindo (em particular, aumentando) a medida que declarações de variáveis globais e locais são analisadas e aceites. Por exemplo, seja Γ o contexto utilizado para a análise do programa: s e t x = 5 ; s e t y = x+x ; Se a análise da primeira instruções for bem sucedida e se concluir por x é de tipo inteiro (i.e. Γ x : inteiro), então a instrução seguinte (set y = x+x;) terá como contexto Γ, (x : inteiro), i.e. o contexto Γ aumentado da informação de que x é inteiro. Uma situação semelhante deverá ser considerada com a declaração de variáveis locais mas com o cuidado adicional de que as variáveis locais podem desaparecer do contexto por serem locais. Em termos práticos, esta gestão do contexto é de tal forma semelhante a vericação política de precedência de símbolos que se costuma juntar a gestão da tabela de símbolos com a vericação de tipos. A descrição formal do algoritmo de tipagem da linguagem Arith é apresentada na gura 1. Este tipo de algoritmo é classicamente apresentado sob a forma de um conjunto de regras de inferência e só contempla os casos de tipagem bem sucedidos. Qualquer conguração diferente resulta num erro que deverá ser devidamente assinalado. Assim, uma regra de inferência da forma ef eito_lateral cond 1... cond n c deve ser lida como: a conclusão c é válida se as condições cond 1 até cond n são igualmente válidas. Neste caso esta regra terá o efeito lateral a acção 8

9 especicada em ef eito_lateral. Em particular e numa leitura "bottom-up": Γ e 1 : t 1... Γ e n : t n Γ e : t signica que para poder garantir que Γ e : t é preciso garantir/vericar que Γ e 1 : t 1,..., Γ e n : t n Como já o referimos, a presentação do algoritmo de inferência considerada aqui: contempla também a vericação da precedência dos símbolos (isto é, integra a vericação dos símbolos realizada a custa das duas tabelas dde símbolos, global e local) sugere que a validação dos tipos é realizada por um algoritmo (estruturalmente) recursivo. Exercício 6: (Vericação dos tipos) 1. Redena a árvore de sintaxe abstracta de tal forma a que incorpora informação dos tipos de cada expressão. Por exemplo a árvore de sintaxe abstracta de uma variável x de tipo inteiro deverá, nesta nova versão da árvore de sintaxe abstracta, incluir a informação de que tem por identicador x e por tipo inteiro. Para esse efeito utilize preferencialmente o tipo valort. 2. Dene uma função typecheck_expr: expr > expr que verica se uma expressão segue a política de tipos da linguagem Arith. Esta função deverá tomar conta da gestão das variáveis locais. Para tal dever-se-á considerar um parâmetro suplementar (a tabela dos símbolos locais) caso seja conveniente. 3. Dene uma função typecheck_instr: instr > instr que verica se uma instrução segue a política de tipos da linguagem Arith. 4. Dene uma função typecheck_prg: prg > prg que verica se um programa verica a política de tipos da linguagem Arith. 5. Integre todas essas funções na análise semântica da linguagem Arith. 9

10 Γ (set x = e) : t Γ, (x : t) inst 1 ;... ; inst n : Γ (set x = e); inst 1 ;... ; inst n : Γ (print e) : t Γ inst 1 ;... ; inst n : Γ (print e); inst 1 ;... ; inst n : t {inteiro, real}. Γ e : t Γ (set x = e) : t t {inteiro, real} Γ e : t Γ (print e) : t i constante inteira Γ i : inteiro r constante real Γ r : real x variável (x : t) Γ Γ x : t Γ e 1 : t Γ e 2 : t binop {+,,, /} Γ e 1 binop e 2 Γ e : t Γ ( e) : t Γ e 1 : t 1 Γ, (x : t 1 ) e 2 : t 2 Γ (let x = e 1 in e 2 ) : t 2 Figura 1: Algoritmo de tipagem da linguagem Arith 10

11 6 Interpretação de programas Arith Exercício 7: (Avaliação duma expressão) Escreva a função eval_expr de tipo expr > valort que calcula o valor duma expressão. Esta função deverá contemplar a boa utilização e actualização de ambientes que permitam ligar nome de variáveis (locais e globais) aos seus valores. Tenha aqui uma particular atenção à avaliação de identicadores associados ao valor NoI (i.e. ausência de informação sobre o tipo) ou aos valores ( Inteiro None) e (Real None) (i.e. ausência de informação sobre os valores). Esta avaliação deverá resultar num erro semântico devidamente assinalado. Outro ponto por contemplar é a utilização de variáveis não denidas. A avaliação deverá ser também capaz de devidamente assinalar este tipo de situação. Exercício 8: (Avaliação duma instrução) Escreva uma função eval_instr : instr > unit que aceita como parâmetro uma instrução e calcula o seu valor actualizando, se necessário, um ambiente (que, relembramos, liga identicadores de variáveis à valores). 7 Compilação de programas Arith 7.1 Arquitectura da máquina virtual alvo A máquina virtual para qual vamos compilar os programas Arith é uma máquina semelhante a máquina virtual do Java. Visto a linguagem Arith ser relativamente pequena, só iremos aqui considerar uma parte substancialmente simples desta máquina. Trata-se duma máquina de pilhas (por oposição a máquina de registos) cujos código fonte (em OCaml) e documentação poderão ser encontrados no site desousa/compil. Assim a máquina virtual considerada é organizada consoante a gura 2: 11

12 Figura 2: Arquitectura da Máquina virtual A máquina contém uma zona de código C e um registo pc que aponta para a instrução por executar. A máquina dispõe igualmente duma pilha P que permite o arquivo de valores inteiros. Três registos permitam o acesso a diferentes partes de P: sp (stack pointer) aponta para o primeiro espaço vazio da pilha, fp (frame pointer) aponta para o endereço de base das variáveis locais e gp aponta para o endereço de base a partir da qual deverão ser introduzidas as variáveis globais. 7.2 Instruções máquinas relevantes As instruções da máquina virtual necessárias para a compilação da linguagem Arith são apresentadas na gura 3. Exercício 9: Dena as funções compile_expr, compile_instr et compile_prg que permitam respectivamente traduzir em código máquina os valores dos tipos expr, instr e prg. 8 Programa principal 12

13 Código Descrição sp Condição ADD P [sp 2] := P [sp 2] + P [sp 1] sp 1 P [sp 2] e P [sp 1] inteiros SUB P [sp 2] := P [sp 2] P [sp 1] sp 1 P [sp 2] e P [sp 1] inteiros MUL P [sp 2] := P [sp 2] P [sp 1] sp 1 P [sp 2] e P [sp 1] inteiros DIV P [sp 2] := P [sp 2]/P [sp 1] sp 1 P [sp 2] e P [sp 1] inteiros FADD P [sp 2] := P [sp 2] + P [sp 1] sp 1 P [sp 2] e P [sp 1] reais FSUB P [sp 2] := P [sp 2] P [sp 1] sp 1 P [sp 2] e P [sp 1] reais FMUL P [sp 2] := P [sp 2] P [sp 1] sp 1 P [sp 2] e P [sp 1] reais FDIV P [sp 2] := P [sp 2]/P [sp 1] sp 1 P [sp 2] e P [sp 1] reais PUSHF n P [sp] := n sp + 1 n real PUSHI n P [sp] := n sp + 1 n inteiro PUSHN n P [sp] := 0...P [sp + n 1] := 0 sp + n n inteiro PUSHG n P [sp] := P [gp + n] sp + 1 n inteiro PUSHL n P [sp] := P [fp + n] sp + 1 n inteiro STOREG n P [gp + n] := P [sp 1] sp 1 n inteiro STOREL n P [fp + n] := P [sp 1] sp 1 n inteiro WRITEI Imprime P [sp 1] no ecrã sp 1 P [sp 1] inteiro START Atribui o valor de sp afp sp STOP Para a execução do programa sp Figura 3: conjunto de instruções da máquina virtual Exercício 10: (o programa arithc ) Reutilize todas as funções escritas por forma a ter um programa arithc que funcione da seguinte forma: Comando Acção arithc i ch. arith interpreta o cheiro ch. arith arithc c ch. arith compila o cheiro ch. arith para o cheiro ch. avm arithc ch. arith compila o cheiro ch. arith para o cheiro ch. avm 9 Extensões Várias extensões ao compilador arithc são possíveis. Listamos a seguir algumas delas. Realçamos aqui que alguns pontos aqui introduzidos não são de resolução simples ou imediata, mas podem servir de base ou de inspiração à denição de pequenos trabalhos (por exemplo a segunda parte do trabalho por realizar nesta disciplina). 13

14 Exercício 11: (o programa arithc++ ) Modique o compilador arithc por forma a implementar as seguintes funcionalidades: 1. construções let x = e1 in e2 aninhadas tanto em e1 como em e2. Verique se o seu compilador tem em conta esta situação. Caso negativo extenda o seu programa por forma a integrar esta construção; 2. comentários de uma linha via \\ ou de mais de uma linha via os delimitadores ( e ). Estes comentários poderão ser aninhados. 3. produção automática de listagem no formato html. Pretendemos que a página produzida apresenta o programa Arith numa versão mais agradável à leitura: os comentários em cinzento, as palavras chaves são apresentadas na cor vermelha, os identicadores a verde, as constantes de tipo inteiro em laranja, as constantes de tipo real em magenta e o restante dos símbolos em preto. Esta função deverá ser executada quando a opção html for apresentada na linha de comando do compilador. Diga que consequências sobre a implementação deste mecanismo terá o requisito suplementar seguinte: apresentar os identicadores de tipo inteiro numa cor diferente dos identicadores de tipo real. Proponha esta variante via a opção html2; 4. Gestão apropriada dos erros. Pretendemos que cada erro detectado seja assinalado da forma seguinte: Error: AAAAA File: BBBBB, line: CC, characters: DD-EE Reason: FFFFF Em que AAAAA é a classe do erro (sintáctico, léxico, etc.), BBBBB o nome do cheiro onde ocorre o erro, CC a linha, DD e EE o intervalo de colunas onde ocorre o erro. A mensagem FFFFF é a descrição pormenorizada da provável origem/explicação do erro; 14

15 5. directiva de inclusão de cheiro. Pretendemos acrescentar uma directiva de carregamento de cheiro, a directiva load ch ; Esta directiva carrega o código fonte contido no cheiro "ch.arith"e o inclui no ponto em que a directiva é encontrada. A implementação desta directiva deverá incluir a gestão adequada de directivas aninhadas e detectar os ciclos (por exemplo, load A; no cheiro B e load B no cheiro A); 6. directivas de pre-processamento. Pretendemos que seja acrescentada a directiva dene ident expr ; à linguagem Arith (onde ident é um identicador aceite pela linguagem Arith e expr uma expressão arith). A semântica associada a palavra chave dene é semelhante (de facto é uma simplicação) ao #dene da linguagem C. A integração de directivas dene obriga o compilador a execução duma fase de pre-processamento do código fonte, antes da própria fase de compilação, que consiste em percorrer sequencialmente o código fonte e arquivar as associações (ident, value) introduzidas pelas directivas dene e substituir qualquer ocorrência de ident no código fonte (inclusive nas directivas dene seguintes) que apareça depois do dene introduzido pelo referido par (ident, value) por value; 7. pretty-printing e indentação automática. Pretendemos, via a opção na linha de comando indent output, dispor dum mecanismo de produção de código Arith bem formado e bem apresentado. Na presença desta opção, o compilador reproduz o programa Arith previamente analisado (i.e. do qual temos uma AST) no cheiro output. arith. 8. conversão de código fonte para a linguagem OCaml. Pretendemos que se implementa um mecanismo de tradução de código Arith para programas em OCaml. Este mecanismo deverá ser invocado via a opção da linha de comando ml output.ml e produzirá o cheiro output.ml. Este cheiro, quando compilado pelos compiladores OCaml standard e executado, deverá produzir o mesmo output de que o programa executado pela máquina virtual; 9. produção de relatórios. Pretendemos aqui fornecer à linguagem Arith uma ferramenta de produção de relatórios no espírito do ocamlweb e do sistema AFT (Almost Free Text). Esta extensão deverá ser invocada pela opção doc output e gerar uma página html de nome 15

16 output.html. deseja-se que a documentação gerada tenha em atenção os seguintes pontos: os comentários formam a documentação do código; o código em si pode ser apresentado consoante as convenções dada pela opção anterior html; a sequência *texto* nos comentários coloca o texto texto em negrito; a sequência /texto/ nos comentários coloca o texto texto em itálico; o comentário ( s o título título o título ; ) permite a denição duma secção de é gerado um indice remissivo de todas as denições. O índice apresenta as denições por ordem alfabética. Cada entrada do índice remissivo é constituído pela seguinte informação: símbolo tipo pagina, onde símbolo é o símbolo referenciado, tipo o seu tipo e nalmente página o numero da página em que é denido; a cada utilização dum símbolo é associado um link para o local de denição deste último. 10. a introdução de booleanos, de operadores booleanos (igualdade, comparações etc.) e da estrutura condicional if <boolexpr> then <expr> else <expr>; 11. a introdução de variáveis mutáveis (cujo valor pode mudar), a atribuição ident:=<expr> (em que ident é necessariamente o identicador duma variável mutável) e a sequência de expressões e1,e2,..., en onde e1... en são expressões separadas por virgulas (que toma aqui o papel do ponto e vírgula do PASCAL). O valor duma sequência de expressões é sempre o valor da última expressão da sequência; 12. a denição de estruturas iterativas como for x=<expr> to <expr> do <expr> ou while <boolexpr> do <expr>. Atribuiremos a estas duas estruturas a semântica habitual; 16

17 13. a possibilidade de denir funções (eventualmente recursivas) introduzindo a instrução function ident x1... xn = e ; em que ident é um identicador (o nome da função), x1... xn os identicadores dos parâmetros e e a expressão denindo o corpo da função; 14. a utilização de vectores de inteiros ou reais pela sintaxe x[e], onde x é o identicador dum vector e e uma expressão necessariamente inteira (positiva) que representa o índice da célula do vector considerada. 17