Analise Semântica. Simão Melo de Sousa

Transcrição

1 Analise Semântica Simão Melo de Sousa RELEASE - RELiablE And SEcure Computation Group Computer Science Department University of Beira Interior, Portugal desousa@di.ubi.pt desousa/ S. Melo de Sousa (DIUBI) A. Semântica 1 / 49

2 Este documento é uma tradução adaptada do capítulo "Analyse Sémantique" da sebenta "Cours de Compilation" de Christine Paulin ( paulin). S. Melo de Sousa (DIUBI) A. Semântica 2 / 49

3 Plano 1 Introdução 2 Tabelas de símbolos e analise de porte 3 Analise de Tipos S. Melo de Sousa (DIUBI) A. Semântica 3 / 49

4 Papel da analise semântica Entrada: Uma árvore de sintaxe abstracta Saída: uma árvore de sintaxe abstracta decorada: resultado da compreensão do programa auscultado. um erro, se o programa auscultado é incorrecto. Ferramentas teóricas: descrições semânticas. Ferramentas de software: programas de natureza recursivas sobre as árvores de sintaxe abstracta. S. Melo de Sousa (DIUBI) A. Semântica 4 / 49

5 Plano 1 Introdução 2 Tabelas de símbolos e analise de porte Princípios Exemplo Implementação 3 Analise de Tipos S. Melo de Sousa (DIUBI) A. Semântica 5 / 49

6 Objectivos e princípios da analise de porte Detectar e localizar a declaração de objectos inerentes à linguagem de suporte (variáveis, tipos, procedimentos, funções, objectos, classes, etc.). Ligar a utilização de um objecto a sua declaração. Uma vez esta ligação definida, arquivá-la adequadamente para o seu uso em fases posteriores. Localizar e exibir a utilização de objectos não declarados. S. Melo de Sousa (DIUBI) A. Semântica 6 / 49

7 Tabela dos símbolos Várias informações devem ser calculadas e extraídas para cada identificador introduzido: Natureza/qualidade do objecto: variáveis, procedimento, tipo... para as variáveis, se estas são globais ou locais, qual é o porte, etc... Tipo duma variável, assinatura de uma função, etc. Alocação em memória (localização, tamanho. etc.) Estas informações servirão de cada vez que o objecto alvo é utilizado Criação de uma ligação directa entre a utilização e as informações arquivadas. S. Melo de Sousa (DIUBI) A. Semântica 7 / 49

8 Árvores de sintaxe anotadas Há várias representações possíveis para ligar as utilizações às declarações: Cada utilização é um apontador para a declaração Cada utilização é um nome único ou então um número que se refere a uma tabela anexa que contém informação sobre as declarações. Neste caso, é possível utilizar várias tabelas, consoante utilidade e a fase de compilação considerada. A analise de porte (scope) subjacente permitirá construir uma nova representação da árvore de sintaxe. S. Melo de Sousa (DIUBI) A. Semântica 8 / 49

9 Verificar o porte Entrada: a árvore de sintaxe proveniente da analise sintáctica Saída: uma nova árvore de sintaxe abstracta com identificadores únicos e uma tabela de símbolos que arquiva as informações sobre os identificadores (e.g. onde estão as variáveis, se estas são locais ou globais etc.) Erro: Se uma variável foi utilizada sem ser previamente declarada, ou então fora do seu âmbito/porte (scope) Técnica utilizar uma lista de associações intermédias entre nomes visíveis e declarações de ambiente identificadas por um nome único. S. Melo de Sousa (DIUBI) A. Semântica 9 / 49

10 Arith extendido com funções type i d e n t = s t r i n g type binop = Sum D i f f Prod Quot type unop = Neg type e x p r = F o f f l o a t I o f i n t Var o f i d e n t Op o f binop e x p r e x p r UOp o f unop e x p r L e t i n o f i d e n t e x p r e x p r App o f i d e n t e x p r l i s t type i n s t r = Set o f i d e n t e x p r P r i n t o f e x p r Fun o f i d e n t i d e n t l i s t e x p r type prg = i n s t r l i s t A analise sintáctica vai construir um objecto de tipo prg A analise de porte irá produzir um novo objecto de tipo prg e uma tabela identificando cada declaração. S. Melo de Sousa (DIUBI) A. Semântica 10 / 49

11 (Um exemplo de programa s e t x = 4 fun f ( x, y ) = 2 x + y s e t xx = l e t y = f ( x, 5 ) i n ( y y ) A árvore de sintaxe abstracta resultante é: [ Set ("x",i 4) ; Fun ("f", ["x";"y"], Op (Plus, Op (Mult, I 2, (Var "x")), Var ("y",u), U); Set ("xx", Letin ("y", App ("f",[var "x"; I 5]), UOp (Neg, Op (Mult,Var "y",var "y")))) ] S. Melo de Sousa (DIUBI) A. Semântica 11 / 49

12 Após a analise de porte Nomes únicos para os objectos Uma tabela de símbolos que arquiva as informações sobre as declarações: o nome original, a natureza do nome, a sua localização, o número de parâmetros no caso de funções, etc... [ Set ("x_0",i 4) ; Fun ("f_3", ["x_1";"y_2"], Op (Plus, Op (Mult, I 2, (Var "x_1",u), U), Var ("y_2",u), U); Set ("xx_5", Letin ("y_4", App ("f_3",[var "x_0"; I 5],U), UOp (Neg, Op (Mult,Var "y_4",var "y_4",u), U))) ] x 0 Global(1) x x 1 Param(1) x y 2 Param(2) y f 3 Fun(1) f y 4 Local(1) y xx 5 Global(2) xx S. Melo de Sousa (DIUBI) A. Semântica 12 / 49

13 Regras para a análise de porte ρ e ok significa: no ambiente em que os identificadores de ρ são visíveis, a expressão e respeita as regras de porte. ρ e 1 ok ρ e 2 ok ρ Op (e 1, op, e 2 ) ok ρ e 1 ok ρ UOp (op, e 1 ) ok x ρ ρ Var (x) ok ρ e 1 ok ρ + x e 2 ok ρ Letin (x, e 1, e 2 ) ok (ρ e i ok) i=1...n f ρ ρ App (f, [e 1 ;... ; e n ]) ok ρ e ok ρ + x p ok ρ (Set (x, e) :: p) ok ρ e ok ρ p ok ρ (Print (e) :: p) ok (ρ + I [+f] e ok) ρ + f p ok ρ (Fun (f, I, e) :: p) ok ρ [] ok S. Melo de Sousa (DIUBI) A. Semântica 13 / 49

14 Decorar o AST ρ e e, d e respeita as regras de porte no ambiente ρ e : AST correspondente onde os identificadores são únicos para as variáveis d: conjunto das declarações: para cada identificador x, o nome original no programa, a sua natureza (função, variável local, variável global, parâmetro etc...) ) S. Melo de Sousa (DIUBI) A. Semântica 14 / 49

15 Regras de decoração ρ e e, d ρ e 1 e 1, d 1 ρ e 2 e 2, d 2 ρ e 1 e 1, d ρ Op(op, e 1, e 2) Op(op, e 1, e 2), d 1 d 2 ρ UOp(op, e 1, ) UOp(op, e 1), d (x n) ρ ρ Var(x) Var(n), (ρ e i e i, d i ) (f f ) ρ ρ App(f, [e 1;... ; e n]) App(f, [e 1;... ; e n]), i d i ρ e 1 e 1, d 1 (n, d) = new(x, LOC) ρ + (x n) e 2 e 2, d 2 ρ Letin(x, e 1, e 2) Letin(x, e 1, e 2), {d} d 1 d2 S. Melo de Sousa (DIUBI) A. Semântica 15 / 49

16 Regras de decoração ρ p p, d ρ e e, d 1 ρ p p, d 2 ρ Print(e) :: p Print(e ) :: p, d 1 d 2 ρ e e, d 1 (n, d) = new(x, GLOB) ρ(x n) p p, d 2 ρ Set(x, e) :: p Set(n, e ) :: p, {d} d 1 d 2 ((n i, d i ) = new(x i, PAR)) i ρ + (x i n i ) i e e, d e (f, d f ) = new(f, FUNC) ρ + (f f ) p p, d p ρ Fun(f, [x 1;... ; x p], e) :: p Fun(f, [n 1;... ; n p], e ) :: p, ( i d i ) d e d f d p S. Melo de Sousa (DIUBI) A. Semântica 16 / 49

17 Algumas notas sobre a analise de porte É preciso distinguir claramente: a tabela dos símbolos que contém, o conjunto das declarações locais e globais incluídas no programas e que faz parte da representação (abstracta) do programa do ambiente local ρ que arquiva as variáveis visíveis num ponto particular de um programa e que deixa de ser utilizada após a analise de porte. S. Melo de Sousa (DIUBI) A. Semântica 17 / 49

18 Funções de análises - estruturas de dados e assinaturas Tabela dos símbolos: pode ser global e x c e p t i o n S c o p e E r r o r t y p e annot = GLOB LOC PAR FUNC ( s t o r e d e c l a r a t i o n i n t a b l e, r e t u r n s u nique i d e n t i f i e r ) v a l add_decl : i d e n t annot i d e n t Variáveis visíveis: lista associativa ou uma estrutura de dados de tipo map (associações funcionais optimizadas, para as quais existe um módulo em OCaml) que associa um inteiro a uma string type t v a l empty_vis : t v a l add_vis : i d e n t i d e n t t t ( r a i s e S c o p e E r r o r i f not found ) v a l f i n d _ v i s : i d e n t t i n t S. Melo de Sousa (DIUBI) A. Semântica 18 / 49

19 Implementação Gerar novos nomes: l e t new_name = l e t i = r e f 0 i n fun x i n c r i ; x^"_"^( s t r i n g _ o f _ i n t! i ) Criar uma tabela de dispersão global para a tabela de símbolos l e t tsymb = H a s h t b l. c r e a t e 97 l e t add_decl x a = l e t x = new_name x i n H a s h t b l. add tsymb x ( x, a ) ; x S. Melo de Sousa (DIUBI) A. Semântica 19 / 49

20 Implementação Estrutura de map funcional para o ambiente das variáveis visíveis: module I d e n t = s t r u c t type t = i d e n t l e t compare = compare end module V i s = Map. Make ( I d e n t ) type t = i d e n t V i s. t l e t ( empty_vis : t ) = V i s. empty l e t ( add_vis : i d e n t i d e n t t t ) = V i s. add l e t f i n d _ v i s ( x : i d e n t ) ( v i s : t ) = t r y V i s. f i n d x v i s with Not_found > r a i s e S c o p e E r r o r S. Melo de Sousa (DIUBI) A. Semântica 20 / 49

21 Função de análise de expressões l e t r e c scope_expr v i s = f u n c t i o n Var x Var ( f i n d _ v i s x v i s ) I n as x x F r as x x Op ( o, e1, e2 ) Op ( o, scope_expr v i s e1, scope_expr v i s e2 ) UOp ( o, e1 ) UOp ( o, scope_expr v i s e1 ) L e t i n ( x, e1, e2 ) l e t e1 = scope_expr v i s e1 and x = add_decl x LOC i n l e t v i s = add_vis x x v i s i n L e t i n ( x, e1, scope_expr v i s e2 ) App ( f, l e ) l e t f = f i n d _ v i s f v i s i n l e t l e = L i s t. map ( scope_expr v i s ) l e i n App ( f, l e ) S. Melo de Sousa (DIUBI) A. Semântica 21 / 49

22 Função de análise de programas l e t r e c scope_prog v i s = f u n c t i o n [ ] [ ] P r i n t ( e ) : : prog P r i n t ( scope_expr v i s e ) : : scope_prog v i s prog Set ( x, e ) : : prog l e t x = add_decl x GLOB i n l e t v i s = add_vis x x v i s i n Set ( x, scope_expr v i s e ) : : scope_prog v i s prog Fun ( f, l v, e ) : : prog l e t v i s e, l v = L i s t. f o l d _ r i g h t ( fun x ( v, l ) l e t x = add_decl x Par i n l e t v = add_vis x x v i n ( v, x : : l ) ) l v ( v i s, [ ] ) i n l e t f = add_decl f FUNC i n l e t v i s = add_vis f f v i s i n Fun ( f, l v, scope_expr v i s e e ) : : scope_prog v i s prog S. Melo de Sousa (DIUBI) A. Semântica 22 / 49

23 Algumas notas A tabela dos símbolos é global. Engloba todas as declarações do programa e será utilizada nas fases seguintes da compilação O ambiente das variáveis visíveis é uma estrutura temporária que varia consoante o ponto do programa analisado. A implementação funcional (persistente) do ambiente permite uma gestão facilitada da junção e remoção de elementos. Na realidade, quando bem utilizada, nunca é preciso remover elementos do ambiente. Basta utilizar o ambiente prévio à junção dos elementos por remover. S. Melo de Sousa (DIUBI) A. Semântica 23 / 49

24 Algumas notas Por exemplo: l e t rec v e r i f i c a env = function (... ) L e t i n ( v, e1, e2 ) l e t new_e1 = v e r i f i c a env e1 in l e t new_e2 = v e r i f i c a ( ( v, ( e x t r a c t _ t y p e new_e1 ) ) : : env ) e2 in L e t i n ( v, new_e1, new_e2 ) (... ) Temos neste exemplo dois ambientes: env e (v, (extract_typenew_e1)) :: env quando a associação (v, (extract_typenew_e1)) não for mais precisa, basta re-utilizar env S. Melo de Sousa (DIUBI) A. Semântica 24 / 49

25 Algumas variantes Podemos optar por definir construtores diferentes GVAR, LVAR, PVAR para discriminar variáveis locais, globais e os parâmetros. Podemos introduzir tabelas diferentes em função da natureza das declarações (variáveis, funções, tipos,...) se a implementação permite facilmente escolher a tabela certa por utilizar. A analise de porte pode também ser realizada em mesmo tempo que a analise da tipagem (por exemplo, por enquanto, verificar que o número de argumentos na chamada de uma função corresponde à declaração). É o caso da fase de analise semântica implementada na linguagem artih. S. Melo de Sousa (DIUBI) A. Semântica 25 / 49

26 analise de porte e de tipo l e t rec typecheck_expr env = f u n c t i o n F ( x ) F x I i I i Var ( v, t ) ( t r y Var ( v, a s s o c v env ) with Not_found t r y Var ( v, H a s h t b l. f i n d t c g e n v v ) with _ r a i s e ( VarUndef v ) ) Op ( op, e1, e2, t ) l e t new_e1 = typecheck_ expr env e1 i n l e t new_e2 = typecheck_ expr env e2 i n l e t ( t1, t2 )=( e x t r a c t _ t y p e new_e1, e x t r a c t _ t new_e2 ) i n i f ( t1=t2 ) then Op ( op, new_e1, new_e2, t1 ) e l s e r a i s e ( T ypeerror (... ) " ) UOp ( op, e, t ) l e t new_e = typecheck_ expr env e i n UOp ( op, new_e, ( e x t r a c t _ t new_e ) ) L e t i n ( v, e1, e2, t ) l e t n_e1 = typecheck_ expr env e1 i n l e t n_e2 = typecheck_expr ( ( v, ( e x t r a c t _ t n_e1 ) ) : : env ) e2 i n L e t i n ( v, n_e1, n_e2, ( e x t r a c t _ t n_e2 ) ) S. Melo de Sousa (DIUBI) A. Semântica 26 / 49

27 Algumas variantes (continuação) Nos contextos de analise até agora encontrados as analises de porte podem ser realizadas de forma independente das analises de tipos. Esta situação nem sempre acontece. Por exemplo, quando a linguagem de programação autoriza sobrecarga de operadores, as informações oriundas da analise de tipos são importantes para poder realizar a analise de porte. S. Melo de Sousa (DIUBI) A. Semântica 27 / 49

28 Plano 1 Introdução 2 Tabelas de símbolos e analise de porte 3 Analise de Tipos Princípios Regras de tipagem Verificação de tipos S. Melo de Sousa (DIUBI) A. Semântica 28 / 49

29 A tipagem Dividir o espaço dos valores em colecções: um tipo de dados é uma colecção de valores que partilham uma (mesma) característica. Por exemplo, o tipo int representa os inteiros codificados em 32 ou 64 bits, o tipo float representa os números de virgula flutuante (norma IEEE-754), o tipo string agrupa os valores que são cadeias de caracteres (entre aspas). ou ainda: secret vs. public, volatile vs. persitent etc... Dependendo da linguagem em causa, a política dos tipos é fortemente ou não, verificada no momento dea execução (tipagem dita dinâmica) no momento da compilação (tipagem estática) S. Melo de Sousa (DIUBI) A. Semântica 29 / 49

30 Tipagem estática: interesse detecção precoce dos erros; documentação, estruturação (primeira informação sobre o programa); eliminação de certos erros que iriam comprometer a execução; (em consequência) maior segurança; uma forma geral de descrever analises de programas (e.g. analise de excepções, efeitos colaterais, segurança do código, etc.) S. Melo de Sousa (DIUBI) A. Semântica 30 / 49

31 Tipagem estática vs. dinâmica A tipagem dinâmica é mais precisa ( if B then 1 else 2 + "a") com B = true mas os erros de tipos dependem dos valores de execuções particulares as linguagens com tipagem estática podem ser compiladas mais eficazmente (e.g. removem a necessidade do teste de representação durante a execução), facilita a optimização (registos, acessos, representação, etc.) é por exemplo possível utilizar a mesma representação para dois valores de tipos diferentes sem riscos de confusão na execução, e.g.: representar true e false por inteiros; em ocaml, representar os constructores de valores de tipos indutivos por inteiros consecutivos. S. Melo de Sousa (DIUBI) A. Semântica 31 / 49

32 Propriedades esperadas da tipagem A tipagem estática deve ser conservativa: Se um programa é bem tipado estaticamente então não são esperados erros de tipos (de representação...) durante a execução Well types programs cannot go wrong (R. Milner, 1978) Mais precisamente: θ : τ Contra exemplo (em C...): o programa θ termina normalmente θ v [τ] union t e s t { i n t campo1 ; f l o a t campo2 ; } ; main ( ) { union t e s t s ; s. campo2 = 3. 8 ; p r i n t f ( "%d\n", s. campo1 ) ; } } A confusão entre inteiro e endereço provoca falhas de segmentação na execução. S. Melo de Sousa (DIUBI) A. Semântica 32 / 49

33 Algumas notas Nas linguagens tipadas modernas, o desafio é encontrar sistemas de tipos os mais ricos possíveis; Linguagens como o Java associam tipagem estático com tipagem dinâmica (a tipagem dinâmica é parte constituinte do valor do objecto) Nesta aula Vamos estudar os princípios da tipagem estática Como formular as regras que definem a tipagem? Princípios dos algoritmos subjacentes S. Melo de Sousa (DIUBI) A. Semântica 33 / 49

34 Vocabulário O que é um tipo? Tipificar uma expressão: um tipo é uma expressão de uma linguagem de tipos declarar um tipo = introduzir um nome de tipo Exemplo: declaração de struct ou de enum Definir um tipo = associar um nome a uma expressão de tipo Exemplo: utilização de typedef Tipificar = associar um tipo a uma expressão Tipagem forte = qualquer expressão tem um tipo principal S. Melo de Sousa (DIUBI) A. Semântica 34 / 49

35 Verificação vs. Inferência Verificação dos tipos O programa associa um tipo a cada declaração de identificador e o compilador verifica se a utilização dos identificadores é conforme (e.g. C, C++, Pascal, Ada, etc.) i n t add ( i n t x1, i n t x2 ) { i n t temp ; temp = x1 + x2 ; r e t u r n temp ; } Sínteses de tipos Os tipos são adivinhados (mais formalmente: inferidos ou sintetizados) pelo compilador por uma analise dita por restrição das utilizações de variáveis (e.g. Caml, SML, Haskell, etc.) l e t add x1 x2 = l e t temp = x1 + x2 i n temp v a l add : i n t i n t i n t = <fun> S. Melo de Sousa (DIUBI) A. Semântica 35 / 49

36 Regras de inferência A verificação dos tipos faz-se com base em regras de tipagem. O programa P está devidamente tipado e tem por tipo ty = P : ty Verificação de tipos: verificar quer ty é um tipo válido para P Síntese de tipos: encontrar um ty válido tal que esta seja o tipo de P Tipificar uma expressão: percorrer a expressão associando um tipo a cada sub-expressão desta. S. Melo de Sousa (DIUBI) A. Semântica 36 / 49

37 Regras de tipagem Axiomas: P : ty ou ainda P : ty Representam factos triviais sobre tipagem (por exemplo, qualquer valor inteiro tem por tipo int) Regras de inferência: P 1 : ty 1... P n : ty n C(P 1,..., P n) : ty Representam a seguinte política de tipos: Se se verifica que P 1 tem por tipo ty 1,..., se verifica que P n tem por tipo ty n então a construção C(P 1,..., P n) tem por tipo ty. Outra leitura possível: Para garantir que a construção C(P 1,..., P n) tenha por tipo ty, basta verificar que P 1 tenha por tipo ty 1,..., que P n tenha por tipo ty n. tipar (ou tipificar): construir uma árvore em que as folhas são axiomas e os nodos, as regras de inferência. um programa P C(P 1,..., P n) é bem tipado quando se consegue construir uma árvore desta forma.. P 1 : ty 1... P n : ty n C(P 1,..., P n) : ty S. Melo de Sousa (DIUBI) A. Semântica 37 / 49

38 Algumas regras Axiomas: I i : int true : bool false : bool F r : float Uma regra de inferência: e 1 : int e 2 : int op {Plus, Minus, Mult, Div} Op(op, e 1, e 2 ) : int S. Melo de Sousa (DIUBI) A. Semântica 38 / 49

39 Alguns exemplos tipagem de 2 + ( 4 * 5) 4 : int 5 : int 2 : int 4 5 : int (4 5) : int 2 * 4 5 tipagem de 2 + ( true * 5) true : bool 5 : int 2 : int true 5 : int (true 5) :? 2 * true 5 S. Melo de Sousa (DIUBI) A. Semântica 39 / 49

40 Identificadores O que fazer na presença de identificadores? i n t x = 1 ; i n t y ; y = 2 + (4 x ) ; Para poder tipar uma expressão temos de nos lembrar individualmente do tipo das variáveis visíveis na expressão. Precisamos de introduzir um ambiente de tipagem, que designaremos por env. Na sua essência, este é muito semelhante ao ambiente das variáveis visíveis utilizada na analise de porte. Contém associações (identificador, tipo) No presente exemplo: env =< (y, int); (x : int) > S. Melo de Sousa (DIUBI) A. Semântica 40 / 49

41 Notações Notação: Env P : ty Ambiente de tipagem: No ambiente Env, o programa P tem por tipo ty Um conjunto de associações < (x 1 : ty 1 ),..., (x n, ty n ) > Uma função de acesso access tal que access(x, < (x 1 : ty 1 ),..., (x n, ty n ) >) { ty1 se x = x = 1 access(x, < (x 2 : ty 2 ),..., (x n, ty n ) >) senão A analise de porte terá previamente assegurada a unicidade dos identificadores S. Melo de Sousa (DIUBI) A. Semântica 41 / 49

42 Linguagem dos tipos Tipos de base: int, float, char, string,... Tipos estruturados: construtor de tipos (operação sobre tipos) e.g. int [] type typ = Tbool Tint T f l o a t Tchar T s t r i n g... Tarr o f typ... Poderíamos também ter: Abreviação de tipos (tipos sinónimos) Tdef of ident typ, tipos definidos pelo utilizador, classes, etc... gestão da igualdade de tipos, de tabelas de simbolos de tipos. S. Melo de Sousa (DIUBI) A. Semântica 42 / 49

43 A linguagem type c t e = I n t o f i n t F l o a t o f f l o a t Bool o f b o o l... type primop = Sum D i f f Prod Quot... type oper = Prim o f primop User o f i d e n t type e x p r = Cst o f c t e Var o f i d e n t Op o f oper e x p r l i s t L e t i n o f i d e n t e x p r e x p r type i n s t r = Set o f i d e n t e x p r P r i n t o f e x p r Fun o f i d e n t ( i d e n t typ ) l i s t e x p r type prg = i n s t r l i s t S. Melo de Sousa (DIUBI) A. Semântica 43 / 49

44 Assinatura Associamos a cada função uma assinatura que especifica: o número de argumentos esperados o tipo de cada argumento o tipo de retorno Existem vários tipos de operadores: Operadores primitivos (e.g. aritméticos): assinatura fixa. Operadores genéricos (acesso a vectores): a assinatura dependerá dos tipos dos argumentos Operadores definidos pelo utilizador: a assinatura é dada pelo programa. Uma assinatura pode ser dada pelo tipo Ocaml seguinte: type s i g n = typ l i s t typ S. Melo de Sousa (DIUBI) A. Semântica 44 / 49

45 Algoritmo de tipagem - Requisitos Cada expressão tem um tipo único que pode ser inferido. Uma tabela associa a cada declaração o seu tipo. v a l add_typ : i d e n t typ u n i t v a l f i n d _ t y p : i d e n t typ De forma semelhante, para as assinaturas dos operadores: v a l add_sign : i d e n t s i g n u n i t v a l f i n d _ s i g n : i d e n t s i g n S. Melo de Sousa (DIUBI) A. Semântica 45 / 49

46 Algoritmo de tipagem l e t r e c type_expr = f u n c t i o n Cte c type_cte c Var x f i n d _ t y p x Op( op, l e ) l e t ( l t, t ) = f i n d _ s i g n op i n c h e c k _ l e x p r l t l e ; t L e t I n ( x, e1, e2 ) l e t t1 = type_expr e1 i n add_typ x t 1 ; type_ expr e2 and c h e c k _ l e x p r = f u n c t i o n [ ], [ ] ( ) t : : l t, e : : l e i f eqt ( type_expr e ) t then c h e c k _ l e x p r l t l e e l s e r a i s e TypeError _,_ r a i s e TypeError S. Melo de Sousa (DIUBI) A. Semântica 46 / 49

47 Algoritmo de tipagem l e t r e c type_prog = f u n c t i o n [ ] ( ) Set ( x, e ) : : p l e t t = type_expr e i n add_typ x t ; type_ prog p P r i n t e : : p l e t _ = type_expr e i n type_prog p Fun ( f, l v, e ) : : p l e t l t = L i s t. map ( fun ( x, t ) add_typ x t ; t ) l v i n l e t t = type_expr e i n add_sign f ( l t, t ) ; type_prog p S. Melo de Sousa (DIUBI) A. Semântica 47 / 49

48 Operadores genéricos Certos operadores parecem não ter uma assinatura única. a condicional if b then e1 else e2 tem por tipo τ se b : bool e e1, e2 : τ. acesso a vectores, t[n] : τ se t tem por tipo τ array e n : int. Associa-se a estes operadores construtores explícitos na sintaxe abstracta I f ( b, e_1, e_2 ) l e t tb = type_ expr b and t 1 = type_ expr e1 and t 2 = type_ expr e2 i n i f eqt tb Tbool && eqt t1 t2 then t1 e l s e r a i s e TypeError Gop ( op, l e ) l e t l t = L i s t. map type_expr l e i n find_ and_ check_ sign op l t A tipagem polimórfica "à la" ocaml permite tratar este caso de forma uniforme. S. Melo de Sousa (DIUBI) A. Semântica 48 / 49

49 Notas Quando o sistema de tipo subjacente é complexo, é necessário comparar tipos, seguindo regras que dependem da linguagem. Neste caso, é cómodo dispor de uma função de comparação eqt especificamente desenhada para tal (ao contrário da igualdade estrutural como compare ou =) O algoritmo apresentado assume que a analise de porte for previamente realizada. No caso contrário, é preciso introduzir o ambiente ρ das variáveis visíveis como parâmetro da função de analise de tipos. Não existem anotações de tipo nas instruções set porque as variáveis são necessariamente inicializadas, logo o tipo é facilmente calculado com base no tipo da expressão de inicialização. Se as funções são recursivas, então é necessário também fornecer o tipo de retorno esperado. Ver ficha prática "arith" (e solução) para uma abordagem completa e alternativa. S. Melo de Sousa (DIUBI) A. Semântica 49 / 49