capıtulo: analise semântica

Analise Semântica

Simão Melo de Sousa

RELEASE - RELiablE And SEcure Computation GroupComputer Science Department

University of Beira Interior, [email protected]

http://www.di.ubi.pt/˜desousa/

S. Melo de Sousa (DIUBI) A. Semântica 1 / 49

mailto:[email protected]

http://www.di.ubi.pt/~desousa/

Este documento é uma tradução adaptada do capítulo "Analyse Sémantique" dasebenta "Cours de Compilation" de Christine Paulin (http://www.lri.fr/˜paulin).


http://www.lri.fr/~paulin

Plano

1 Introdução

2 Tabelas de símbolos e analise de porte

3 Analise de Tipos


Papel da analise semântica

Entrada: Uma árvore de sintaxe abstracta

Saída: uma árvore de sintaxe abstracta decorada: resultado dacompreensã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 desintaxe abstracta.


Plano

1 Introdução

2 Tabelas de símbolos e analise de portePrincípiosExemploImplementação

3 Analise de Tipos


Objectivos e princípios da analise de porte

Detectar e localizar a declaração de objectos inerentes à linguagem desuporte (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 emfases posteriores.

Localizar e exibir a utilização de objectos não declarados.


Tabela dos símbolos

Várias informações devem ser calculadas e extraídas para cada identificadorintroduzido:

I Natureza/qualidade do objecto: variáveis, procedimento, tipo... para asvariáveis, se estas são globais ou locais, qual é o porte, etc...

I Tipo duma variável, assinatura de uma função, etc.I 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çõesarquivadas.


Á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 umatabela anexa que contém informação sobre as declarações.

Neste caso, é possível utilizar várias tabelas, consoante utilidade e a fase decompilação considerada.

A analise de porte (scope) subjacente permitirá construir uma novarepresentação da árvore de sintaxe.


Verificar o porte

Entrada: a árvore de sintaxe proveniente da analise sintáctica

Saída: uma nova árvore de sintaxe abstracta com identificadores únicos euma tabela de símbolos que arquiva as informações sobre osidentificadores (e.g. onde estão as variáveis, se estas são locais ouglobais etc.)

Erro: Se uma variável foi utilizada sem ser previamente declarada, ouentão fora do seu âmbito/porte (scope)

Técnica utilizar uma lista de associações intermédias entre nomes visíveis edeclarações de ambiente identificadas por um nome único.


Arith extendido com funçõestype i d e n t = s t r i n gtype b inop = Sum | D i f f | Prod | Quottype unop = Negtype exp 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 b inop ∗ exp r ∗ exp r| UOp o f unop ∗ exp r| L e t i n o f i d e n t ∗ exp r ∗ exp r| App o f i d e n t ∗ exp r l i s t

type i n s t r =Set o f i d e n t ∗ exp r

| P r i n t o f exp r| Fun o f i d e n t ∗ i d e n t l i s t ∗ exp 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 tabelaidentificando cada declaração.


(Um exemplo de programa

s e t x = 4fun f ( x , y ) = 2 ∗ x + ys 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"))))]


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:I o nome original,I a natureza do nome, a sua localização,I 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)))]

x0 Global(1) xx1 Param(1) xy2 Param(2) yf3 Fun(1) fy4 Local(1) yxx5 Global(2) xxS. Melo de Sousa (DIUBI) A. Semântica 12 / 49

Regras para a análise de porte

ρ ` e ok significa: no ambiente em que os identificadores de ρ são visíveis , aexpressão e respeita as regras de porte.

ρ ` e1 ok ρ ` e2 okρ ` Op (e1, op, e2) ok

ρ ` e1 okρ ` UOp (op, e1) ok

x ∈ ρρ ` Var (x) ok

ρ ` e1 ok ρ+ x ` e2 okρ ` Letin (x , e1, e2) ok

(ρ ` ei ok)i=1...n f ∈ ρρ ` App (f , [e1; . . . ; en]) 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


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 noprograma, a sua natureza (função, variável local, variável global, parâmetroetc...) )


Regras de decoração

ρ ` e e ′, d

ρ ` e1 e′1, d1 ρ ` e2 e′

2, d2

ρ ` Op(op, e1, e2) Op(op, e′1, e

′2), d1 ∪ d2

ρ ` e1 e′1, d

ρ ` UOp(op, e1, ) UOp(op, e′1), d

(x n) ∈ ρρ ` Var(x) Var(n), ∅

(ρ ` ei e′i , di ) (f f ′) ∈ ρ

ρ ` App(f , [e1; . . . ; en]) App(f ′, [e′1; . . . ; e

′n]),∪idi

ρ ` e1 e′1, d1 (n, d) = new(x , LOC) ρ+ (x n) ` e2 e′

2, d2

ρ ` Letin(x , e1, e2) Letin(x , e′1, e

′2), {d} ∪ d1 ∪ d2


Regras de decoração

ρ ` p p′, d

ρ ` e e′, d1 ρ ` p p′, d2

ρ ` Print(e) :: p Print(e′) :: p′, d1 ∪ d2

ρ ` e e′, d1 (n, d) = new(x ,GLOB) ρ(x n) ` p p′, d2

ρ ` Set(x , e) :: p Set(n, e′) :: p′, {d} ∪ d1 ∪ d2

((ni , di ) = new(xi ,PAR))i ρ+ (xi ni )i ` e e′, de

(f ′, df ) = new(f ,FUNC) ρ+ (f f ′) ` p p′, dp

ρ ` Fun(f , [x1; . . . ; xp], e) :: p Fun(f ′, [n1; . . . ; np], e′) :: p′, (∪idi ) ∪ de ∪ df ∪ dp


Algumas notas sobre a analise de porte

É preciso distinguir claramente:

a tabela dos símbolos que contém, o conjunto das declarações locais eglobais 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 particularde um programa e que deixa de ser utilizada após a analise de porte.


Funções de análises - estruturas de dados e assinaturas

Tabela dos símbolos: pode ser global

excep t i on ScopeEr ro rtype annot = GLOB | LOC | PAR | FUNC(∗ s t o r e d e c l a r a t i o n i n t ab l e ,

r e t u r n s un ique 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 ummódulo em OCaml) que associa um inteiro a uma string

type tv a l empty_vis : tv a l add_vis : i d e n t → i d e n t → t → t(∗ r a i s e ScopeEr ro r i f not found ∗)v a l f i n d_v i s : i d e n t → t → i n t


Implementação

Gerar novos nomes:

l e t new_name = l e t i = r e f 0 i nfun 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 = Hashtb l . c r e a t e 97l e t add_decl x a = l e t x ’ = new_name x i n

Hashtb l . add tsymb x ’ ( x , a ) ; x ’


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 tl e t compare = compareend

module Vi s = Map .Make( I d e n t )type t = i d e n t V i s . tl e t ( empty_vis : t ) = Vi s . emptyl e t ( add_vis : i d e n t → i d e n t → t → t ) = Vi s . addl e t f i n d_v i s ( x : i d e n t ) ( v i s : t ) =

t r y Vi s . f i n d x v i s with Not_found > r a i s e ScopeEr ro r


Função de análise de expressões

l e t r ec scope_expr v i s = f u n c t i o nVar 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 LOCi n l e t v i s ’ = add_vis x x ’ v i si 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 nl e t l e ’ = L i s t .map ( scope_expr v i s ) l e i n App ( f ’ , l e ’ )


Função de análise de programas

l e t r ec 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 nl e t v i s ’ = add_vis x x ’ v i s i nSet ( 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 nl e t v ’ = add_vis x x ’ v i n( v ’ , x ’ : : l ) )

l v ( v i s , [ ] ) i nl e t f ’ = add_decl f FUNC i nl 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


Algumas notas

A tabela dos símbolos é global. Engloba todas as declarações do programae será utilizada nas fases seguintes da compilação

O ambiente das variáveis visíveis é uma estrutura temporária que variaconsoante o ponto do programa analisado. A implementação funcional(persistente) do ambiente permite uma gestão facilitada da junção eremoção de elementos. Na realidade, quando bem utilizada, nunca é precisoremover elementos do ambiente. Basta utilizar o ambiente prévio à junçãodos elementos por remover.


Algumas notas

Por exemplo:

l e t rec v e r i f i c a env = funct ion( . . . )

| L e t i n ( v , e1 , e2 ) →l e t new_e1 = v e r i f i c a env e1 inl e t new_e2 = v e r i f i c a ( ( v , ( e x t r a c t_type 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)) :: envquando a associação (v , (extract_typenew_e1)) não for mais precisa, bastare-utilizar env


Algumas variantes

Podemos optar por definir construtores diferentes GVAR, LVAR, PVAR paradiscriminar variáveis locais, globais e os parâmetros.

Podemos introduzir tabelas diferentes em função da natureza dasdeclarações (variáveis, funções, tipos, . . .) se a implementação permitefacilmente escolher a tabela certa por utilizar.

A analise de porte pode também ser realizada em mesmo tempo que aanalise da tipagem (por exemplo, por enquanto, verificar que o número deargumentos na chamada de uma função corresponde à declaração). É o casoda fase de analise semântica implementada na linguagem artih.


analise de porte e de tipo

l e t rec typecheck_expr env = f unc t i on| 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 , Hashtb l . f i n d tcgenv v )with _ → r a i s e ( VarUndef v ) )

| Op ( op , e1 , e2 , t ) →l e t new_e1 = typecheck_expr env e1 i nl e t new_e2 = typecheck_expr env e2 i nl e t ( t1 , t2 )=( ex t r a c t_type 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 ( TypeEr ror (∗ . . . ∗) " )

| UOp ( op , e , t ) →l e t new_e = typecheck_expr env e i nUOp ( 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 nl e t n_e2 = typecheck_expr ( ( v , ( e x t r a c t_t n_e1 ) ) : : env ) e2 i nL e t i n ( v , n_e1 , n_e2 , ( e x t r a c t_t n_e2 ) )


Algumas variantes (continuação)

Nos contextos de analise até agora encontrados as analises de porte podemser realizadas de forma independente das analises de tipos. Esta situaçãonem sempre acontece. Por exemplo, quando a linguagem de programaçãoautoriza sobrecarga de operadores, as informações oriundas da analise detipos são importantes para poder realizar a analise de porte.


Plano

1 Introdução

2 Tabelas de símbolos e analise de porte

3 Analise de TiposPrincípiosRegras de tipagemVerificação de tipos


A tipagem

Dividir o espaço dos valores em colecções: um tipo de dados é uma colecçãode 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), otipo 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 – ounão, verificada

I no momento dea execução (tipagem dita dinâmica)I no momento da compilação (tipagem estática)


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 deexcepções, efeitos colaterais, segurança do código, etc.)


Tipagem estática vs. dinâmica

A tipagem dinâmica é mais precisa ( if B then 1 else 2 + "a") comB = 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 detipos diferentes sem riscos de confusão na execução, e.g.:

I representar true e false por inteiros;I em ocaml, representar os constructores de valores de tipos indutivos

por inteiros consecutivos.


Propriedades esperadas da tipagem

A tipagem estática deve ser conservativa:

Se um programa é bem tipado estaticamente então não são esperados errosde tipos (de representação....) durante a execução

Well types programs cannot go wrong (R. Milner, 1978)

Mais precisamente:

θ : τ o programa θ termina normalmenteθ v ∈ [τ ]

Contra exemplo (em C...):un ion t e s t { i n t campo1 ; f l o a t campo2 ; } ;main ( ) { un ion 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 naexecução.


Algumas notas

Nas linguagens tipadas modernas, o desafio é encontrar sistemas de tiposos 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


Vocabulário

O que é um tipo?

um tipo é uma expressão de uma linguagem de tiposdeclarar um tipo = introduzir um nome de tipoExemplo: declaração de struct ou de enumDefinir um tipo = associar um nome a uma expressão de tipoExemplo: utilização de typedef

Tipificar uma expressão:

Tipificar = associar um tipo a uma expressãoTipagem forte = qualquer expressão tem um tipo principal


Verificação vs. Inferência

Verificação dos tiposO programa associa um tipo a cada declaração de identificador e ocompilador 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 ousintetizados) pelo compilador por uma analise dita por restriçãodas 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>


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 cadasub-expressão desta.


Regras de tipagemAxiomas: P : ty ou ainda

P : tyRepresentam factos triviais sobre tipagem (por exemplo, qualquer valor inteiro tempor tipo int)Regras de inferência:

P1 : ty1 . . . Pn : tyn

C(P1, . . . ,Pn) : ty

Representam a seguinte política de tipos:Se se verifica que P1 tem por tipo ty1, . . ., se verifica que Pn tem por tipo tyn

então a construção C(P1, . . . ,Pn) tem por tipo ty .Outra leitura possível: Para garantir que a construção C(P1, . . . ,Pn) tenha portipo ty , basta verificar que P1 tenha por tipo ty1, . . ., que Pn tenha por tipo tyn.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(P1, . . . ,Pn) é bem tipado quando se consegue construir umaárvore desta forma

......

P1 : ty1 . . . Pn : tyn

C(P1, . . . ,Pn) : ty


Algumas regras

Axiomas:

I i : int true : bool false : bool F r : float

Uma regra de inferência:

e1 : int e2 : int op ∈ {Plus,Minus,Mult,Div}Op(op, e1, e2) : int


Alguns exemplos

tipagem de 2 + ( 4 * 5)

+

2 *

4 5

2 : int4 : int 5 : int

4 ∗ 5 : int2+ (4 ∗ 5) : int

tipagem de 2 + ( true * 5)

+

2 *

true 5

2 : inttrue : bool 5 : int

true ∗ 5 : int2+ (true ∗ 5) :?


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 dasvariá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íveisutilizada na analise de porte.

Contém associações (identificador , tipo)

No presente exemplo: env =< (y , int); (x : int) >


Notações

No ambiente Env , o programa P tem por tipo ty

Notação: Env ` P : tyAmbiente de tipagem:

Um conjunto de associações < (x1 : ty1), . . . , (xn, tyn) >

Uma função de acesso access tal que access(x , < (x1 : ty1), . . . , (xn, tyn) >)

=

{ty1 se x = x1access(x , < (x2 : ty2), . . . , (xn, tyn) >) senao

A analise de porte terá previamente assegurada a unicidade dosidentificadores


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 | T int | 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 peloutilizador, classes, etc...

gestão da igualdade de tipos, de tabelas de simbolos de tipos.


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 tiposdos 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


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 → un i tv a l f i nd_typ : 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 → un i tv a l f i n d_s i gn : i d e n t → s i g n


Algoritmo de tipagem

l e t r ec type_expr = f u n c t i o nCte c → type_cte c

| Var x → f i nd_typ x| Op( op , l e ) → l e t ( l t , t ) = f i nd_s i gn op i n

check_lexpr 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 t1 ; type_expr e2and check_lexpr = f u n c t i o n

[ ] , [ ] → ( )| t : : l t , e : : l e →

i f eqt ( type_expr e ) t then check_lexpr l t l ee l s e r a i s e TypeEr ror

| _,_ → r a i s e TypeEr ror


Algoritmo de tipagem

l e t r ec type_prog = f u n c t i o n[ ] → ( )

| Set ( x , e ) : : p → l e t t = type_expr e i nadd_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 nl e t t = type_expr e i n

add_sign f ( l t , t ) ; type_prog p


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 band t1 = type_expr e1 and t2 = type_expr e2i 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

f ind_and_check_sign op l t

A tipagem polimórfica "à la" ocaml permite tratar este caso de forma uniforme.


Notas

Quando o sistema de tipo subjacente é complexo, é necessário comparartipos, seguindo regras que dependem da linguagem. Neste caso, é cómododispor de uma função de comparação eqt especificamente desenhada paratal (ao contrário da igualdade estrutural como compare ou =)

O algoritmo apresentado assume que a analise de porte for previamenterealizada. No caso contrário, é preciso introduzir o ambiente ρ das variáveisvisí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ãonecessariamente inicializadas, logo o tipo é facilmente calculado com baseno tipo da expressão de inicialização.

Se as funções são recursivas, então é necessário também fornecer o tipo deretorno esperado.

Ver ficha prática "arith" (e solução) para uma abordagem completa ealternativa.


capıtulo: analise semântica

Documents