Implementazione di Linguaggi 2 PARTE 6 Testo: A.V. Aho, R. Sethi, J.D.Ullman Compilers...

Implementazione di Implementazione di Linguaggi 2Linguaggi 2

PARTE 6PARTE 6

Testo: A.V. Aho, R. Sethi, Testo: A.V. Aho, R. Sethi, J.D.Ullman Compilers J.D.Ullman Compilers

Principles,Techniques and Tools, Principles,Techniques and Tools, Addison WesleyAddison Wesley

Type CheckingType Checking

Si divide in statico se eseguito durante la compilazione e dinamico se eseguito durante l’esecuzione del programma.

È affiancato da altri controlli: Flow-of-control: goto return exit … Unicità di definizione: identificatori nello

stesso scope, label di switch/case stat. controlli contestuali dei nomi es. (Modula)

PROCEDURE P;…END P;

Ruolo del Type CheckerRuolo del Type Checker

Sostanzialmente controllare che le Sostanzialmente controllare che le operazioni vengano applicate a tipi operazioni vengano applicate a tipi compatibili.compatibili.

Type Expressions (TE)Type Expressions (TE)

Sono espressioni che servono per Sono espressioni che servono per definire i tipi di dato di un linguaggio.definire i tipi di dato di un linguaggio.

usano operatori detti usano operatori detti type type constructorsconstructors e operandi detti e operandi detti tipi tipi basebase..

Le TE denotano i tipi di un linguaggio Le TE denotano i tipi di un linguaggio e sono fortemente dipendenti da e sono fortemente dipendenti da esso.esso.


Formalmente:Formalmente: Un tipo base (int, float, integer, real, Un tipo base (int, float, integer, real,

complex, …) è una complex, …) è una type expressiontype expression;; Un tipo può avere un Un tipo può avere un nomenome, per cui il , per cui il

nome di un tipo è una nome di un tipo è una type type expressionexpression;;

Un Un costruttore di tipocostruttore di tipo applicato ad una applicato ad una type expressiontype expression genera una nuova genera una nuova type expressiontype expression::


Costruttori di tipoCostruttori di tipo1.1. ArrayArray: se : se TT è una TE allora è una TE allora array(I,T)array(I,T) è una TE che è una TE che

denota un tipo array con tipo base denota un tipo array con tipo base TT e tipo indice e tipo indice II

2.2. Prodotti cartesianiProdotti cartesiani: se : se TT11 e e TT22 sono TE allora sono TE allora TT11TT22 è è una TE che denota l’insieme delle coppie una TE che denota l’insieme delle coppie (t(t11,t,t22)) con con tt11TT11 e e tt22TT22 ( ( associa a sinistra) associa a sinistra)

3.3. RecordRecord: il prodotto del tipo dei suoi : il prodotto del tipo dei suoi campicampi, differisce , differisce dal prodotto per la commutativitò degli elementi dal prodotto per la commutativitò degli elementi dovuta alla selezione mediante nome (field label)dovuta alla selezione mediante nome (field label)

ES. ES. {f1: 1;…; fn: n} un record con campi fi di tipo i


4.4. PuntatoriPuntatori: se : se TT è una TE allora è una TE allora pointer(T)pointer(T) è una TE che denota un riferimento è una TE che denota un riferimento (puntatore) ad un oggetto di tipo T(puntatore) ad un oggetto di tipo T

5.5. FunzioniFunzioni: è il tipo di una funzione che : è il tipo di una funzione che mappa un mappa un tipo dominio Dtipo dominio D in un in un tipo tipo rango Rrango R e denotato e denotato DDRR..

6.6. ClassClass: è un misto tra il concetto di : è un misto tra il concetto di modulomodulo e di tipo. È modellabile come un e di tipo. È modellabile come un record con campi di tipo procedura e di record con campi di tipo procedura e di tipo funzione detti tipo funzione detti metodimetodi..

Type SystemType System

Un Un Type SystemType System è una collezione di regole è una collezione di regole per assegnare TE alle parti di un programma.per assegnare TE alle parti di un programma. È interessante implementare type system con È interessante implementare type system con

DGDSDGDS

Un Un Type CheckerType Checker ( (TCTC) è un programma che ) è un programma che implementa un implementa un Type SystemType System.. Ogni TC può essere applicato a Ogni TC può essere applicato a run timerun time purché il purché il

codice oggetto contenga informazioni che codice oggetto contenga informazioni che specificano il tipo di ogni dato.specificano il tipo di ogni dato.

Type SystemType System

Un Un Type SystemType System è detto è detto soundsound se se elimina la necessità di type checking a elimina la necessità di type checking a

run time, cioè se il TC assegna un run time, cioè se il TC assegna un tipotipotype-errortype-error ad ogni dato del ad ogni dato del programma, programma,

allora nessun errore di tipo si può allora nessun errore di tipo si può verificare durante l’esecuzione.verificare durante l’esecuzione.

Type checking: Schema di Type checking: Schema di traduzione DStraduzione DS

Aggiungo il tipo base Aggiungo il tipo base type_errortype_error::P P D ; E D ; E

D D D ; D D ; D

D D id : T id : T addtype(id.entry,T.type)addtype(id.entry,T.type)T T char char T.type:=charT.type:=charT T integer integer T.type:=integerT.type:=integerTTarray[num] of Tarray[num] of T11

T.type:=array(1..num.val,TT.type:=array(1..num.val,T11.type).type)

T T ^T ^T11 T.type:=pointer(TT.type:=pointer(T11.type).type)

Type Checking di Type Checking di EspressioniEspressioni

E E literal literal E.type:=charE.type:=char

E E num num E.type:=integerE.type:=integer

E E id id E.type:=lookup(id.entry)E.type:=lookup(id.entry)

EEEE11 mod E mod E22 E.type:= E.type:= ifif E E11.type=integer .type=integer && EE22.type=integer .type=integer thenthen integer integer

elseelse type_error type_error

Type Checking di Type Checking di EspressioniEspressioni

E E E E1 1 [E[E22] ] {E.type:= {E.type:= ifif E E22.type=integer .type=integer && E E11.type=array(s,t) .type=array(s,t) thenthen t t

else else type_error} type_error}

E E E E11^ ^ {E.type:= {E.type:= ifif E E11.type=pointer(t) .type=pointer(t) thenthen t t

else else type_error} type_error}

Type Checking di IstruzioniType Checking di Istruzioni

S S id := E id := E S.type:= S.type:= if if id.type=E.type id.type=E.type then then void void elseelse type_error type_error

S S if E then S if E then S1 1 S.type:= S.type:= ifif E.type =boolean E.type =boolean thenthen S S11.type .type elseelse type_error type_error

S S while E do S while E do S1 1 S.type:= S.type:= ifif E.type=boolean E.type=boolean thenthen S S11.type .type elseelse type_error type_error

S S S S1 1 ; S; S22 S.type:= S.type:= ifif S S11.type=void .type=void & & SS22.type=void .type=void thenthen S.type=void S.type=void

elseelse type_error type_error

Type Checking di FunzioniType Checking di Funzioni

TT T T1 1 ’’’ T’ T2 2 T.type:=TT.type:=T11.type.typeTT22.type.type

E E E E1 1 (E(E22) ) E.type:=E.type:=if if EE22.type= s .type= s & & EE11.type= s.type= st t thenthen t t elseelse type_error type_error

Le funzioni n-arie f(tLe funzioni n-arie f(t11:T:T11,t,t22:T:T22,…,t,…,tnn:T:Tnn) vengono ) vengono assimilate a funzioni unarie di tipo T=Tassimilate a funzioni unarie di tipo T=T11TT22……TTnn

root: (real root: (real real) real) real real real real

Equivalenza di TipoEquivalenza di Tipo

I linguaggi usano diversi modi e I linguaggi usano diversi modi e definizioni per stabilire se due tipo sono definizioni per stabilire se due tipo sono equivalentiequivalenti..

Gli approcci principali sono:Gli approcci principali sono: Equivalenza strutturaleEquivalenza strutturale (Fortran, C, C++, (Fortran, C, C++,

…)…) Equivalenza per nomeEquivalenza per nome (Modula, Oberon, (Modula, Oberon,

Ada, Pascal, …)Ada, Pascal, …) Misti.Misti.

Equivalenza di TipoEquivalenza di Tipo

Esempio in Modula-2.Esempio in Modula-2. Dati: Dati: TYPE A=ARRAY[0..n] OF REAL; TYPE A=ARRAY[0..n] OF REAL;

B=ARRAY[0..n] OF REAL; B=ARRAY[0..n] OF REAL;

Definiscono due Definiscono due tipi non equivalentitipi non equivalenti, , perché dotati di perché dotati di nome diversonome diverso (equivalenza per nome). Tuttavia, A e B (equivalenza per nome). Tuttavia, A e B sono identici e quindi sono identici e quindi strutturalmente strutturalmente equivalenti.equivalenti.

Equivalenza di Tipo: per Equivalenza di Tipo: per NomeNome

Due variabili hanno tipo Due variabili hanno tipo equivalente per nomeequivalente per nome: :

1.1. se appartengono alla stessa se appartengono alla stessa dichiarazione, dichiarazione,

2.2. se appaiono in dichiarazioni diverse ma se appaiono in dichiarazioni diverse ma abbinate allo stesso identificatore di tipo.abbinate allo stesso identificatore di tipo.

3.3. nei linguaggi Oberon-like si ha che due nei linguaggi Oberon-like si ha che due nomi di tipo nomi di tipo TT e e T’T’ dichiarati uguali dichiarati uguali denotano due tipi denotano due tipi TT e e T’T’ identici. identici.

NOTA:NOTA: Linguaggi come PL/M considerano i tipi Linguaggi come PL/M considerano i tipi TT e e T’T’ definiti in 3. non definiti in 3. non equivalenti.equivalenti.


Esempi:Esempi:1.1. VAR a, b: ARRAY[1..n] OF REAL; VAR a, b: ARRAY[1..n] OF REAL;

(*a(*ab stessa dichiarazione*)b stessa dichiarazione*)

2.2. PROCEDURE O(a:T); PROCEDURE O(a:T); VAR b:TVAR b:T

(* a e b sono equivalenti perché usano lo stesso type (* a e b sono equivalenti perché usano lo stesso type id T*)id T*)

3.3. TYPE T’ = TTYPE T’ = T(* T e T’ denotano due tipi identici perché dichiarati (* T e T’ denotano due tipi identici perché dichiarati uguali *)uguali *)


Due tipi sono Due tipi sono compatibilicompatibili se: se: sono sono identiciidentici, oppure, oppure uno è uno è sottorangosottorango dell’altro, oppure dell’altro, oppure entrambi sono entrambi sono sottorangosottorango di uno stesso tipo. di uno stesso tipo.

Un Un sottorangosottorango è definito restringendo ad un è definito restringendo ad un intervallointervallo l’insieme dei valori possibili di un l’insieme dei valori possibili di un tipotipo ordinaleordinale discretodiscreto (es. integer o elencazione). (es. integer o elencazione).

Il concetto di sottorango è un caso particolare di Il concetto di sottorango è un caso particolare di sottotiposottotipo, un concetto che vedremo in seguito., un concetto che vedremo in seguito.


Esempi.Esempi.TYPE link = ^cell;TYPE link = ^cell;VAR next : link;VAR next : link; last : link;last : link; p : ^cell;p : ^cell; q : ^cell;q : ^cell;

Equivalenza per nome: Equivalenza per nome: 1.1. nextnext e e last last hanno lo stesso tipo perché sono hanno lo stesso tipo perché sono

associati alla stessa type expression, associati alla stessa type expression, 2.2. pp,, q q,, r r hanno lo stesso tipo,hanno lo stesso tipo,3.3. p p ee next next non sono equivalenti perché associati non sono equivalenti perché associati

a type expression diverse.a type expression diverse.

Compatibilità per Compatibilità per AssegnamentoAssegnamento

Un’espressione Un’espressione EE di tipo di tipo TT22 è detta è detta compati-bile rispetto all’assegnamentocompati-bile rispetto all’assegnamento ad un tipo ad un tipo TT11 sse: sse:

1.1. TT11 e T e T22 sono identici e nessuno è di tipo file, sono identici e nessuno è di tipo file,

2.2. TT1 1 è real e Tè real e T22 integer, integer,

3.3. TT11 e T e T22 sono tipi ordinali compatibili e il sono tipi ordinali compatibili e il valo-re di E appartiene all’intervallo chiuso valo-re di E appartiene all’intervallo chiuso speci-ficato da Tspeci-ficato da T1 1 ,,

4.4. TT11 e T e T22 sono tipi stringa compatibili. sono tipi stringa compatibili.

Equivalenza di Tipo: Equivalenza di Tipo: StrutturaleStrutturale

Due type expression EDue type expression E11 e E e E22 sono sono struttural-struttural-mente equivalentimente equivalenti se: se:

1.1. EE11 e E e E22 sono lo stesso tipo base, oppure sono lo stesso tipo base, oppure

2.2. EE11 e E e E22 sono ottenute applicando lo stesso sono ottenute applicando lo stesso costruttore di tipo a tipi strutturalmente costruttore di tipo a tipi strutturalmente equivalenti.equivalenti.

Quindi due tipi sono strutturalmente Quindi due tipi sono strutturalmente equivalenti se sonoequivalenti se sono identici. identici.


Esempi.Esempi.1.1. la type expression la type expression integerinteger è è

equivalente solo a equivalente solo a integerinteger

2.2. Pointer(integer) è equivalente solo a Pointer(integer) è equivalente solo a pointer(integer)pointer(integer)


Spesso è possibile codificare le type Spesso è possibile codificare le type expression in modo da semplificare expression in modo da semplificare la verifica di equivalenza la verifica di equivalenza strutturale.strutturale.

Famosa è quella adottata nel Famosa è quella adottata nel compilatore C di Ritchie e Johnson.compilatore C di Ritchie e Johnson.

Costruttori di tipo: Costruttori di tipo: pointer(t)pointer(t), , freturns(t)freturns(t) e e array(t)array(t)..

Codifica delle type Codifica delle type expression.expression.

Poiché tutti i costruttori di tipo considerati Poiché tutti i costruttori di tipo considerati sono operatori unari le type expression sono operatori unari le type expression formate applicando questi costruttori ai tipi formate applicando questi costruttori ai tipi base hanno una struttura molto uniforme:base hanno una struttura molto uniforme:

charchar

freturns(char)freturns(char)

pointer(freturns(char))pointer(freturns(char))

array(pointer(freturns(char)))array(pointer(freturns(char)))

Codifica delle type Codifica delle type expression.expression.

Type Type

constructorconstructorEncodingEncoding

pointerpointer 0101

array array 1010

freturns freturns 1111

Basic TypeBasic Type EncodingEncoding

booleanboolean 00000000

char char 00010001

integer integer 00100010

real real 00110011

Type ExpressionType Expression EncodingEncoding

charchar 000000 0001000000 0001

freturns(char)freturns(char) 000011 0001000011 0001

pointer(freturns(char)) pointer(freturns(char)) 000111 0001000111 0001

array(pointer(freturns(char))array(pointer(freturns(char))))

100111 0001100111 0001

Algoritmo Ricorsivo per Algoritmo Ricorsivo per Equivalenza StrutturaleEquivalenza Strutturale

FUNCTION SEQ(s,t):BOOLEAN;FUNCTION SEQ(s,t):BOOLEAN;BEGINBEGIN IF s & t are the same basic type THEN RETURN TRUEIF s & t are the same basic type THEN RETURN TRUE ELSIF s=array(s1,s2) & t=array(t1,t2) THEN ELSIF s=array(s1,s2) & t=array(t1,t2) THEN RETURN SEQ(s1,t1) & SEQ(s2,t2)RETURN SEQ(s1,t1) & SEQ(s2,t2) ELSIF s=s1ELSIF s=s1s2 & t=t1s2 & t=t1t2 THEN t2 THEN RETURN SEQ(s1,t1) & SEQ(s2,t2)RETURN SEQ(s1,t1) & SEQ(s2,t2) ELSIF s=pointer(s1) & t=pointer(t1) THEN ELSIF s=pointer(s1) & t=pointer(t1) THEN RETURN SEQ(s1,t1)RETURN SEQ(s1,t1) ELSIF s=s1ELSIF s=s1s2 & t=t1s2 & t=t1t2 THEN t2 THEN RETURN SEQ(s1,t1) & SEQ(s2,t2) RETURN SEQ(s1,t1) & SEQ(s2,t2) ELSE RETURN FALSEELSE RETURN FALSEENDEND

Cicli nelle rappresentazioni di Cicli nelle rappresentazioni di tipitipi

Molte strutture dati sono definite Molte strutture dati sono definite ricorsivamente:ricorsivamente:

Esempio. Esempio. LLinguaggi che permette di inguaggi che permette di assegnare un nome a un tipo.assegnare un nome a un tipo.

TYPE link= ^cell:TYPE link= ^cell:

cell= RECORDcell= RECORD

info:INTEGER;info:INTEGER;

next: linknext: link

END;END;


I nomi di tipo definiti ricorsivamente possono I nomi di tipo definiti ricorsivamente possono esse-re sostituiti se siamo disposti ad esse-re sostituiti se siamo disposti ad introdurre i cicli nel type graph.introdurre i cicli nel type graph. Sostituendo Sostituendo linklink con con pointer(cell)pointer(cell)

cell = record

x

x x

info integer next pointer

cell


Possiamo eliminare il riferimento a Possiamo eliminare il riferimento a cellcell nel nel type graph:type graph:

cell = record

x

x x

info integer next pointer


Esempio. Esempio. Il C evita i cicli nei type graph Il C evita i cicli nei type graph usando l’equivalenza strutturale per usando l’equivalenza strutturale per tutti i tipi tranne i recordtutti i tipi tranne i record..

Struct cell{Struct cell{

int info;int info;

struct cell *next;struct cell *next;

};};

Conversioni di TipoConversioni di Tipo

Consideriamo l’espressione:Consideriamo l’espressione:

x +x + ii con con xx di tipo di tipo realreal e e ii di tipo di tipo integerinteger i i e e xx hanno rappresentazioni diverse, hanno rappresentazioni diverse, le istruzioni macchina usate per le istruzioni macchina usate per realreal e e integerinteger

sono diverse,sono diverse, il compilatore deve convertire gli operandi del + il compilatore deve convertire gli operandi del +

per renderli dello stesso tipo.per renderli dello stesso tipo.

Il type checker può inserire le conversioni nella Il type checker può inserire le conversioni nella rappresentazione intermedia del rappresentazione intermedia del programma.programma.

Conversioni di TipoConversioni di Tipo

La conversione da un tipo ad un altro è La conversione da un tipo ad un altro è detta detta implicitaimplicita se è fatta in modo se è fatta in modo auto-matico dal compilatore.auto-matico dal compilatore.

Le conversioni implicite vengono Le conversioni implicite vengono anche dette anche dette coercionscoercions..

La conversione è detta La conversione è detta esplicitaesplicita se il se il programmatore deve scrivere programmatore deve scrivere qualcosa per causare la conversione.qualcosa per causare la conversione.

Monomorfismo e Monomorfismo e PolimorfismoPolimorfismo

In molti In molti linguaggi tipati staticamentelinguaggi tipati staticamente (es. (es. Modula) una variabile Modula) una variabile TT può ricevere valori può ricevere valori solo di tipo solo di tipo TT..

I tipi sottorango di Modula verificano I tipi sottorango di Modula verificano banalmente questa proprietà detta banalmente questa proprietà detta monomorfismomonomorfismo..

I linguaggi object-oriented sono I linguaggi object-oriented sono polimorfipolimorfi, nel , nel senso che le variabili possono ricevere valori di senso che le variabili possono ricevere valori di più di un tipo.più di un tipo.

Generi di PolimorfismoGeneri di Polimorfismo

Cardelli e Wegner hanno classificato il polimorfismo in

• Universale suddiviso in Parametrico (generici) Inclusione (object-oriented)

• Ad Hoc suddiviso in • OverloadingOverloading• CoercionCoercion

Polimorfismo Parametrico e Ad Polimorfismo Parametrico e Ad HocHoc

Nel polimorfismo parametrico una funzione opera uniformemente su un insieme di tipi che hanno una struttura comune

Nel polimorfismo ad hoc una funzione opera su tipi distinti e su ciascuno si comporta in maniera indipendente dagli altri

Polimorfismo ParametricoPolimorfismo Parametrico

Nel polimorfismo parametrico l’uniformità è ottenuta mediante parametri di tipo. Il polimorfismo universale opera, in generale, su un insieme potenzialmente infinito di tipi.

Nel polimorfismo di inclusione un oggetto appartiene a molte classi diverse ma legate tra loro da ua relazione di inclusione.

Sottotipazione Sottotipazione

E’ un concetto legato a quello di tipo e di E’ un concetto legato a quello di tipo e di polimorfismo che definisce molti aspetti del polimorfismo che definisce molti aspetti del type checking. E’ una relazione di preordine type checking. E’ una relazione di preordine su tipi basata sul principio di su tipi basata sul principio di subsumptionsubsumption: se : se èè un sottotipo di allora un valore di tipo allora un valore di tipo è è accettato in ogni contesto in cui è previsto un accettato in ogni contesto in cui è previsto un valore di tipo valore di tipo . In formule:. In formule:

⊦ ⊦ e:e: <:: ______________________

⊦ ⊦ e:e:

Sottotipazione strutturale e per Sottotipazione strutturale e per nome nome

L’equivalenza di tipo adottata influisce anche sulla L’equivalenza di tipo adottata influisce anche sulla sottotipazione. Strutturalmente diciamo che sottotipazione. Strutturalmente diciamo che 11 22 è un sottotipo di è un sottotipo di 11 22 se se 11<::11 e e 22<::22. . Come detto per i record e le classi si adotta in Come detto per i record e le classi si adotta in genere una sottotipazione per nome basato genere una sottotipazione per nome basato sull’ idea di sull’ idea di type extensiontype extension: una classe C2 : una classe C2 estende C1 se C2 ha i tutti i campi di C1 e ne estende C1 se C2 ha i tutti i campi di C1 e ne cambia i tipi cambia i tipi in modo compatibilein modo compatibile

((ii)(i[1,n]i<:i) __________________________________________________

{f1: 1;…; fn: n}<: {f1: 1;…; fn: n}

Sottotipazione strutturale e per Sottotipazione strutturale e per nome 2 nome 2

(ii)(i[1,n]i<:i)

__________________________________________________

{f1: 1;…; fn: n}<: {f1: 1;…; fn: n}

n<m

____________________________________________________

{f1: 1;…; fm: m}<: {f1: 1;…; fn: n}

Conversioni (coercions) Conversioni (coercions) Coercion: data l’espressione:Coercion: data l’espressione:

x + ix + iCon Con xx reale e reale e ii intero, essendo le rappresentazioni interne intero, essendo le rappresentazioni interne

di di xx e e ii diverse e diversi gli algoritmi aritmetici, occorre diverse e diversi gli algoritmi aritmetici, occorre effettuare una conversione dal tipo piu’ ristretto a effettuare una conversione dal tipo piu’ ristretto a quello piu’ generale. In notazione postfissa quello piu’ generale. In notazione postfissa l’espressione diviene:l’espressione diviene:

x i inttoreal real+x i inttoreal real+Le conversioni sono Le conversioni sono impliciteimplicite se effettuate dal compilatore, se effettuate dal compilatore,

espliciteesplicite se comandate dall’utente. se comandate dall’utente.FOR i:=1 TO N DO x[i]:=float(1)FOR i:=1 TO N DO x[i]:=float(1)FOR i:=1 TO N DO x[i]:=1.0FOR i:=1 TO N DO x[i]:=1.0Possono avere una differenza di 8.96 unità di tempo per Possono avere una differenza di 8.96 unità di tempo per

iterazioneiterazione

Conversioni (coercions) 2 Conversioni (coercions) 2

EEnumnum E.type:=integerE.type:=integer

E E num . num num . num E.type:=realE.type:=real

EEidid E.type:=lookup(id.entry)E.type:=lookup(id.entry)

E E EE11 op E op E22

E.type:=IF EE.type:=IF E11.type=int&E.type=int&E22.type=int THEN .type=int THEN intint

ELSIF EELSIF E11.type=int & E.type=int & E22.type=real THEN real.type=real THEN real

ELSIF EELSIF E11.type=real&E.type=real&E22.type=int THEN real.type=int THEN real

ELSIF EELSIF E11.type=real&E.type=real&E22.type=real THEN real.type=real THEN real

ELSE type.errorELSE type.error

Overloading 2Overloading 2

L’espressioneL’espressione a+b a+b può indicare somma tra può indicare somma tra interi, reali, doppia precisione, interi, reali, doppia precisione, complessi, matrici o unione tra dati di complessi, matrici o unione tra dati di tipo tipo SET. SET.

In questo caso si dice che il simbolo + è In questo caso si dice che il simbolo + è overloadedoverloaded. Un overloading è detto . Un overloading è detto risolvibilerisolvibile se è possibile dedurre un se è possibile dedurre un unico tipo per una data espressione.unico tipo per una data espressione.

Overloading Overloading Ovviamente, questo non è sempre possibileOvviamente, questo non è sempre possibile

function “*” (i,j:integer) return complex;function “*” (i,j:integer) return complex;function”*”(x,y:integer) return complex; function”*”(x,y:integer) return complex;

Da cui si deducono I possibili tipi di “Da cui si deducono I possibili tipi di “**”:”: intintintintintint

intintintintcomplexcomplex complexcomplexcomplexcomplexcomplexcomplex

Dati 2,3 e 5, il valore di 3*5 puo’ essere sia Dati 2,3 e 5, il valore di 3*5 puo’ essere sia intint che che complexcomplex es: es:

2*(3*5)2*(3*5)3*5:int3*5:int; mentre ; mentre (3*5)*z & z:complex (3*5)*z & z:complex 3*5:complex3*5:complex

Overloading di funzioniOverloading di funzioniType checking di funzioni overloadedType checking di funzioni overloaded

E’ E’ E E E’.types:=E.type E’.types:=E.typeE E id id E.types:=lookup(id.entry) E.types:=lookup(id.entry)

E E E E11(E(E22) E.types:={t| ) E.types:={t| ssEE22.types: s.types: st t EE11.types} .types}

La terza regola asserisce che se La terza regola asserisce che se ss è un tipo di è un tipo di EE22 e uno dei tipi di e uno dei tipi di EE11 mappa mappa ss in in tt, allora , allora tt è uno è uno dei tipi di dei tipi di EE11..

Qualora si riscontri una incompatibilità che porti Qualora si riscontri una incompatibilità che porti a a E.types=E.types= si avrà un messaggio di errore. si avrà un messaggio di errore.

Overloading di funzioni 2Overloading di funzioni 2

Type checking di funzioni overloadedType checking di funzioni overloadedE:{I,c}E:{I,c}

E:{i}E:{i} *:{i *:{iiii, ii, iiic, cc, cccc} c} E:{i}E:{i}3:{i}3:{i} 5:{i} 5:{i} Come restringere l’insieme dei tipi possibiliCome restringere l’insieme dei tipi possibiliAda e altri linguaggi richiedono un unico Ada e altri linguaggi richiedono un unico

tipo per ogni espressione completa. Se tipo per ogni espressione completa. Se questo non e’ possibile si dichiara un questo non e’ possibile si dichiara un errore. Si usa un attributo errore. Si usa un attributo typestypes che un che un set di tipi possibili (set di tipi possibili (feasiblefeasible))

Overloading di funzioni 3Overloading di funzioni 3Type checking di funzioni overloadedType checking di funzioni overloadedE E E E E’.types:=E.typesE’.types:=E.types

E.uniq:=IF E’.types={t} THEN t ELSE typerrE.uniq:=IF E’.types={t} THEN t ELSE typerrE’.cod:=E.codE’.cod:=E.cod

EEid id E.types:=lookup(id.entry)E.types:=lookup(id.entry)E.cod:=gen(id.lexeme’:’ E.uniq)E.cod:=gen(id.lexeme’:’ E.uniq)

EEE1(E2)E1(E2) E.types:={s’|E.types:={s’|ssE2.types & sE2.types & ss’s’E1.types}E1.types}t:=E.uniq; S:={s|st:=E.uniq; S:={s|sE2.types& sE2.types& sttE1.types}E1.types}E2.uniq:=IF S={s} THEN s ELSE typerr;E2.uniq:=IF S={s} THEN s ELSE typerr;E1.uniq:=IF S={s} THEN s E1.uniq:=IF S={s} THEN s t t ELSE typerr;ELSE typerr;E.cod:=E1.cod||E2.cod||gen(‘apply’)’:’,E.uniq); E.cod:=E1.cod||E2.cod||gen(‘apply’)’:’,E.uniq);

L’attributo erditato L’attributo erditato uniquniq (unique) e’ usato con l’attributo sintetizzato (unique) e’ usato con l’attributo sintetizzato codecode..

La definizione e’ implementata da due visite depth-first dell’albero La definizione e’ implementata da due visite depth-first dell’albero sintatticosintattico

• nella prima si calcola nella prima si calcola typestypes bottom up bottom up• nella seconda si propaga verso il basso nella seconda si propaga verso il basso uniquniq e al ritorno della visita e al ritorno della visita

si genera si genera codcod..

Ereditarietà e sottotipazione Ereditarietà e sottotipazione

La procedura seguente implementa il La procedura seguente implementa il concetto di concetto di recordrecord type extensiontype extension di di Wirth (Oberon)Wirth (Oberon)

PROCEDURE RecordType(VAR typ: Struct)PROCEDURE RecordType(VAR typ: Struct)

VAR adr,sise:INTEGER;fld,fld0,fld1:Object;VAR adr,sise:INTEGER;fld,fld0,fld1:Object;

ftyp,btyp:Struct;base:Item;ftyp,btyp:Struct;base:Item;

BEGINBEGIN

adr:=0; typ:=NewStr(record);adr:=0; typ:=NewStr(record);

typ.BaseTyp:=NIL; typ.n:=0;typ.BaseTyp:=NIL; typ.n:=0;

Ereditarietà e sottotipazione 2Ereditarietà e sottotipazione 2

IF sym=lparen THEN Get(Sym); (*record extension*)IF sym=lparen THEN Get(Sym); (*record extension*) IF sym=ident THEN qualident(base);IF sym=ident THEN qualident(base); IF (base.mode=Typ) & (base.typ.form=Record) IF (base.mode=Typ) & (base.typ.form=Record)

THENTHEN typ.BaseTyp:=base.typ;typ.n:=base.typ.n+1typ.BaseTyp:=base.typ;typ.n:=base.typ.n+1 adr:=base.typ.sizeadr:=base.typ.size ELSE Error(..)ELSE Error(..) END;END; ELSE Error(..);ELSE Error(..); END;END; CheckSym(rparen)CheckSym(rparen)END;END;


OpenScope(0); fld:=NIL; fld1:=topScope;OpenScope(0); fld:=NIL; fld1:=topScope; LOOPLOOP IF sym=ident THEN IF sym=ident THEN LOOPLOOP IF sym=ident THENIF sym=ident THEN IF typ.BaseTyp # NIL THEN FindField(typ.BaseTyp, fld0);IF typ.BaseTyp # NIL THEN FindField(typ.BaseTyp, fld0); IF fld0 # NIL THEN Error(..) ENDIF fld0 # NIL THEN Error(..) END END;END; Insert(OCS.name,fld); CheckMark(fld.marked);Insert(OCS.name,fld); CheckMark(fld.marked); fld.mode:=Fldfld.mode:=Fld ELSE Error(..)ELSE Error(..) END;END; IF sym=comma THEN Get(sym) IF sym=comma THEN Get(sym) ELSIF sym=ident THEN Error(..)ELSIF sym=ident THEN Error(..) ELSE E XITELSE E XIT END; END; END;END;


CheckSym(colon); Type(ftyp); CheckSym(colon); Type(ftyp); size:=ftyp.size; btyp:=ftyp;size:=ftyp.size; btyp:=ftyp; WHILE btyp.form=Array DO btyp:=btyp.BaseTyp WHILE btyp.form=Array DO btyp:=btyp.BaseTyp

END;END; IF btyp.size>=4 THEN INC(adr, (-adr)MOD 4)IF btyp.size>=4 THEN INC(adr, (-adr)MOD 4) ELSIF btyp.size=2 THEN INC(adr, adr MOD 2)ELSIF btyp.size=2 THEN INC(adr, adr MOD 2) END;END;WHILE fld1.next #NIL DOWHILE fld1.next #NIL DO fld1:=fld1.next; fld1.typ:=ftyp;fld1:=fld1.next; fld1.typ:=ftyp; fld1.a0:=adr; INC(adr,size)fld1.a0:=adr; INC(adr,size) END END END;END;


IF sym=semicolon THEN Get(sym)IF sym=semicolon THEN Get(sym) ELSIF sym=ident THEN Error(..)ELSIF sym=ident THEN Error(..) ELSE EXITELSE EXIT ENDENDEND;END;typ.size:=(-adr) MOD 4 + 4; typ.size:=(-adr) MOD 4 + 4;

typ.link:=topScope.next;typ.link:=topScope.next;CheckUndefPointerTypes; CloseScope;CheckUndefPointerTypes; CloseScope;END RecordType;END RecordType;

Fine Type checkingFine Type checking

Proseguire con gli argomenti del seminario Proseguire con gli argomenti del seminario sul type checkingsul type checking

Implementazione di Linguaggi 2 PARTE 6 Testo: A.V. Aho, R. Sethi, J.D.Ullman Compilers...

Documents

Transcript of Implementazione di Linguaggi 2 PARTE 6 Testo: A.V. Aho, R. Sethi, J.D.Ullman Compilers...