1 Implementazione di Linguaggi 2 PARTE 2 Implementazione di Linguaggi 2 PARTE 2 Massimo Ancona DISI Università di Genova Testo: A.V. Aho, R. Sethi, J.D.Ullman Compilers Principles,Techniques and Tools, Addison Wesley

2 Analisi semantica: Traduzione Guidata dalla Sintassi Analisi semantica: Traduzione Guidata dalla Sintassi Si basa sull’associazione di: attributi semantici alle componenti sintattiche del linguaggio, e di attributi semantici alle componenti sintattiche del linguaggio, e di regole semantiche alle produzioni della grammatica per calcolare i valori degli attributi. regole semantiche alle produzioni della grammatica per calcolare i valori degli attributi.

3 Esempio di traduzione guidata dalla sintassi Esempio di traduzione guidata dalla sintassi Esempio: conversione da notazione infissa a postfissa. Formalmente definita da: se E e’ una variabile allora post(E)=E se E e’ una variabile allora post(E)=E E=E 1 opE 2  post(E 1 opE 2 )=post(E 1 )post(E 2 )op E=E 1 opE 2  post(E 1 opE 2 )=post(E 1 )post(E 2 )op E=(E 1 )  post(E)=post(E 1 ). E=(E 1 )  post(E)=post(E 1 ).

4 Definizione Guidata dalla Sintassi Definizione Guidata dalla Sintassi Una DGS (DDS) e’ dafinita da: definizione di una CFG G=(N,T,P,S) per specificare la struttura sintattica del linguaggio, definizione di una CFG G=(N,T,P,S) per specificare la struttura sintattica del linguaggio, associazione di attributi ai simboli di G (elementi di V=N  T), associazione di attributi ai simboli di G (elementi di V=N  T), associazione ad ogni elemento di P di un insieme di regole per valutare gli attributi di V=N  T. associazione ad ogni elemento di P di un insieme di regole per valutare gli attributi di V=N  T.

5 Algoritmo di traduzione Guidata dalla Sintassi Algoritmo di traduzione Guidata dalla Sintassi Per ogni input I: costruire il parse tree T di I, costruire il parse tree T di I, per ogni nodo n etichettato da X  V si denota X.a il valore dell’attributo a di x in n. Il valore di X.a viene calcolato in base alle regole semantiche per la valutazione di a associate alla produzione di X usata nel nodo n. per ogni nodo n etichettato da X  V si denota X.a il valore dell’attributo a di x in n. Il valore di X.a viene calcolato in base alle regole semantiche per la valutazione di a associate alla produzione di X usata nel nodo n. Un parse-tree che evidenzi i valori degli attributi e’ detto annotato. Un parse-tree che evidenzi i valori degli attributi e’ detto annotato.

6 Attributi sintetizzati Attributi sintetizzati E’ un attributo il cui valore nel parse tree viene calcolato tramite i vlori degli attributi dei figli in una visita bottom-up dell’albero. Esempio expr  expr1+term expr.t:=expr1.t||term.t||’+’ expr  expr1-term expr.t:=expr1.t||term.t||’-’ expr  term expr.t:=term.t term  a|b|c|d. term.t:=‘a’|’b’|’c’|’d’

7 Analisi e Traduzione Analisi e Traduzione expr expr expr1 + term expr1 + term expr1 - term c expr1 - term c term b term b a expr.t=‘ab-c+’ expr.t=‘ab-c+’ expr1.t=‘ab-’ + term.t=‘c’ expr1.t=‘ab-’ + term.t=‘c’ expr1.t=‘a’ - term.t=‘b’ c expr1.t=‘a’ - term.t=‘b’ c term.t=‘a’ b term.t=‘a’ b a

8 Schemi di Traduzione Schemi di Traduzione Uno schema di traduzione e’ DGS nelle cui produzioni sono inseriti frammenti di codice detti azione semantiche. Le azioni semantiche vengono inserite nelle parti destre delle produzioni e vengono eseguite da un parser esteso quando le incontra. Esempio: rest +term{print(‘+’)}rest1

9 Schemi di Traduzione Schemi di Traduzione Un DGS generalmente non impone un ordine specifico di valutazione degli attributi. Negli esempi piu’ semplici si usa una visita depth-first del parsing tree. proc visit(n: node) begin for each child m of n from-left-to-right do visit(m); for each child m of n from-left-to-right do visit(m); eval semantic rules at n eval semantic rules at nend Le traduzioni DGS viste finora sono semplici cioe’ la traduzione delle regole ass. alla parte sinistra di una regola e’ la concatenazione di quelle della relativa parte destra Le traduzioni DGS viste finora sono semplici cioe’ la traduzione delle regole ass. alla parte sinistra di una regola e’ la concatenazione di quelle della relativa parte destra

10 Parsing Parsing Il processo che stabilisce se una stringa di token apprartiene al linguaggio generato da una grammatica G. Per ogni CFG esiste un parser (con back-tracking) di complessita’ O(n 3 ) (in teoria O(n 2.7 )) che analizza una stringa di n token e costruisce un parse tree di essa. I linguaggi di programmazione hanno algoritmi di complessita’ O(n) che leggono l’input una sola volta da sinistra a destra leggendo “avanti” un solo token per volta, detto look-ahead token

11 Parsing Parsing I parser si dividono in due categorie TOP-DOWN BOTTOM-UP TOP-DOWN BOTTOM-UP A seconda di come costruiscono il parse tree. I primi costruiscono una derivazione canonica sinistra, i secondi una destra. I primi sono molto popolari perche’ intuitivi e usabili in compiler costruiti a mano. I secondi si applicano a classi di linguaggi piu’ generali.

12 Parser top-down Parser top-down Metodo (applicato alla G seguente): 1. type  simple| 2. ^id| 3. array[simple] of type 4. simple  integer | char | num dotdot num A partire dalla radice etichettata dal simbolo iniziale (type) si applicano i seguenti passi: 1. Nel nodo n etichettato A selezionare una produzione A  e costruire da  i figli di n 2. Determinare il nodo successivo cui associare un sotto albero

13 Parser top-down Parser top-down Input: ‘ array[num dotodot num] of integer ‘ type array[num dotodot num] of integer type array[num dotodot num] of integer array [ simple ] of type array [ simple ] of type type array[num dotodot num] of integer type array[num dotodot num] of integer array [ simple ] of type array [ simple ] of type num dotodot num num dotodot num type array[num dotodot num] of integer type array[num dotodot num] of integer array [ simple ] of type array [ simple ] of type num dotodot num simple num dotodot num simple type array[num dotodot num] of integer type array[num dotodot num] of integer array [ simple ] of type array [ simple ] of type num dotodot num simple num dotodot num simple integer integer

14 Parser a Discesa Ricorsiva Parser a Discesa Ricorsiva Metodo top-down formato da un insieme di procedure ricorsive. Si associa una procedura ad ogni non terminale della grammatica. Per la G seguente: 1. type  simple| 2. ^id| 3. array[simple] of type 4. simple  integer | char | num dotdot num Si scrive una proc. per type ed una per simple

15 Parser a Discesa Ricorsiva Parser a Discesa Ricorsiva proc match(t: token); /* scanner*/ begin if lookahead = t then next_token else error; end;

16 Proc type Proc type proc type; /* */ begin if lookahead in {‘integer’,’char,’num’} then simple else if lookahead =‘^’ then begin match(‘^’); match(id) end else if lookahead = ‘array’ then begin match(‘array’); match(‘[‘); simple; match(‘]’); match(‘array’); match(‘[‘); simple; match(‘]’); match(‘of’); type match(‘of’); typeend else error end;

17 Proc simple Proc simple proc simple; /* */ begin if lookahead =‘integer’ then match(‘integer’) else if lookahead = ‘char’ then match(’char’) else if lookahead = ‘char’ then match(’char’) else if lookahead =‘num’ then begin match(‘num’);match(‘dotdot’); match(‘num’) end end else error end;

18 C odice completo in Io (1) C odice completo in Io (1) MODULE PostFix(TABLES); VAR ch: CHAR; PROCEDURE Find; PROCEDURE Find; BEGIN BEGIN DO DO READ(ch) READ(ch) UNTIL (ch<>' ')AND NOT EOLN UNTIL (ch<>' ')AND NOT EOLN END; (* Find*) END; (* Find*)

19 C odice completo in Io (2) C odice completo in Io (2) PROCEDURE Expression; VAR Op: CHAR; VAR Op: CHAR; PROCEDURE Term; PROCEDURE Term; PROCEDURE Factor; PROCEDURE Factor; BEGIN BEGIN IF ch='(' THEN Find; Expression; (* ch=) *) IF ch='(' THEN Find; Expression; (* ch=) *) ELSE ELSE WRITE(ch) WRITE(ch) FI; Find FI; Find END; (* Factor *) END; (* Factor *)

20 C odice completo in Io (3) C odice completo in Io (3) BEGIN (*Term*) BEGIN (*Term*) Factor; Factor; WHILE ch='*' WHILE ch='*' DO DO Find; Factor; WRITE('*') Find; Factor; WRITE('*') OD; OD; END; (*Term*) END; (*Term*)

21 C odice completo in Io (4) C odice completo in Io (4) BEGIN (* Expression*) Term; Term; WHILE (ch='+') OR (CH='-') WHILE (ch='+') OR (CH='-') DO DO Op:=ch;Find; Term; WRITE(Op) Op:=ch;Find; Term; WRITE(Op) OD; OD; END; (* Expression*) END; (* Expression*)

22 C odice completo in Io (5) C odice completo in Io (5) BEGIN (* Main*) Find; Find; DO DO WRITE(' '); WRITE(' '); Expression; Expression; WRITELN WRITELN UNTIL Ch='.' UNTIL Ch='.'END.

23 Parser Predittivo: teoria Parser Predittivo: teoria Lo sviluppo si basa sulla conoscenza dei primi simboli generabili nella parte destra di una produzione A  insieme indicato: FIRST k (  )={w  T*| |w|<k &  *w or |w|=k &  x  T*  *wx} FIRST(  )=FIRST 1 (  ) FIRST 1 (  )={a  T  {  }|a=  &  *  OR  x  T*  *ax} Se A  e A  sono due produzioni di G allora esiste un parser a discesa ricorsiva senza backtraking se: FIRST(  )  FIRST(  )=  Le produzioni A  richiedono un trattamento speciale

24 Parser Predittivo: ricorsione sinistra Parser Predittivo: ricorsione sinistra Un parser a discesa ricorsiva puo’ entrare in loop quando incontra una produzione (o un set di produzioni) che originano una ricorsione sinistra. Ad esempio le produzioni: E  E+T | E-T | T Sono entrambe ricorsive a sinistra (in E). Questo fa parte di un caso generale A  A  |  In cui  =+T (-T) e  =T. Questo problema e’ eludibile sostituendo le produzioni precednti con: A  R R  R|  A  R R  R| 

25 PARTE APPROFONDITA PARTE APPROFONDITA FINE PARTE DI SURVEY INIZIO LUCIDI DETTAGLIATI

26 ANALISI LESSICALE ANALISI LESSICALE

27 ANALISI LESSICALE ANALISI LESSICALE

28 ANALISI LESSICALE ANALISI LESSICALE Motivazioni: 1.Semplificazione progettuale 2.Efficienza 3.Portabilita’ Token pettern lexemi b2a  Xyw  letter{(letter|digit)}  ident Zz23  Lexemipattern token

29 ANALISI LESSICALE ANALISI LESSICALE In certi linguaggi l’analisi lessicale non e’ semplice (es. Fortran): 1.Ammette keyword come identificatori 2. E’ position dependent 3.Fa uso troppo libero degli spazi DO 1 I=1,10 istruzione do (tipo for loop) DO 1 I=1.10 assegnamento 100 FORMAT(X7H)=(3-2) ambigua

30 ATTRIBUTI ASSOCIATI AI TOKEN Quando piu’ di un lexema soddisfano un pattern lo scanner deve associare attributi ai singoli lexemi per distinguerli: 1.zx12 ident ‘zx12’ la stringa che identifica uno specifico lexema float ‘12.45 in codice float’ Se la corrispondenza lexema token e’ 1-1 non occorrono attributi. Esempio WHILE whiletoken

31 ERRORI LESSICALI Pochi errori sono identificabili a questo livello. Il recupero di errori si basa sulla panic rule 1.Si scartano i caratteri successivi a quello errato finche’ non e’ possibile riconoscere un nuovo token

32 INSIEMI REGOLARI Dato un alfabeto T, la famiglia degli insiemi regolari su T e’ la famiglia piu’ piccola di insiemi di T* che: contiene gli insiemi finiti 1.e’ chiusa rispetto alle operazioni 1.unione (  ), 2. concatenazione (.) 3. star (*)

33 ESPRESSIONI REGOLARI Una sintassi comoda per esprimere insiemi regolari:  e’ un’espressione regolare che denota l’insieme  1.  e’ un’espressione regolare che denota  2.per ogni a  T a e’ un’espressione regolare che denota  a 

34 ESPRESSIONI REGOLARI Se p e q sono espressioni regolari che denotano gli insiemi regolari P e Q rispettivamente, allora: p+q e un’ E.R. che denota l’I.R. P  Q (a volte usiamo anche p|q). pq (o p.q) un’E.R. che denota P.Q p* e’ un’E.R. che denota P*

35 ESPRESSIONI REGOLARI ESEMPI Un identificatore e’ una sequenza di lettere o cifre, la prima delle quali e’ una cifra: digit=0+1+…+9 letter = a+b+c+…+x+y+z allora: ident = letter(digit+letter)* int = digit(digit)* espon=(  +’E’(‘+’|’-’|  )digitdigit)

36 ESPRESSIONI REGOLARI ESEMPI int = digit(digit)* espon=(  +’E’(‘+’+’-’+  )int) float=int(‘.’int)espon

37 ESPRESSIONI REGOLARI E CFG Definizione Una CFG G=(N,T,P,S) e’ lineare a destra (risp. sinistra) se ogni A  ha forma A  xB|y A,B  N x,y  T (rispettivamente A  Bx|y). Teorema Un sottoinsieme L  T* e’ regolare sse esiste CFG G lineare a destra (sinistra) tale che L=L(G).

38 ESPR. REGOLARI E AUTOMI Definizione Un automa finito non- deterministico e’ una quintupla A=(Q,T, , q 0,F) dove: Q e’ un insieme finito detto degli stati T e’ un alfabeto dei simboli in input  e’ la funzione di transizione  : Q  T  (Q) dove  (Q)=2 Q e’ l’insieme delle parti di Q. q 0  Q e’ detto stato iniziale F e’ l’insieme degli stati finali di accettazione

39 ESPR. REGOLARI E AUTOMI Spiegazione L’automa opera leggendo sequenzialmente da un nastro in input simboli di T partendo dallo stato iniziale. Ad ogni input A esegue una transizione pilotata da , l’input viene accettato se l’automa termina la lettura in uno stato di F, non accettato se qualunque sequenza di transizioni non porta mai ad uno stato di F. Piu’ esattamente:

40 ESPR. REGOLARI E AUTOMI Definizione Ogni coppia (q,w)  Q  T* e’ detta una configurazione di A. Definizione una mossa di A, denotata ├ o├ A e’ definita  w  T* tra 2 configurazioni da: (q,aw) ├ A (q’,w)   a  T: q’  (q,a) Se C e C’ sono configurazioni di A allora: C ├ 0 C’ sse C=C’; C ├ n C’ sse C=C 1 ├ C 2 ├ … ├ C n =C’ C ├ * C’ sse  n  0: C ├ n C’

41 LINGUAGGIO ACCETTATO DA UN AUTOMA Definizione L(A)=  w  T*|(q 0,w) ├ *(q,  ) & q  F  e’ detto linguaggio accettato da A. Teorema Un linguaggio L  T* e’ regolare se e solo se esiste un automa A tale che L=L(A). Ne segue che gli insiemi regolari sono caratterizzati equivalentemente da espressioni regolari, automi finiti o grammatiche lineari a destra (sinistra)

42 DETERMINISMO non DETERMINISMO Definizione Un automa A=(Q,T, , q 0,F) e’ detto deterministico se per ogni q  Q e a  T si ha |  (q,a)|  1. Inoltre A e’ detto completamente specificato se |  (q,a)|=1 Teorema Sia L  T* un linguaggio accettato da un automa non deterministico A (L=L(A)) allora esiste un automa deterministico A’ tale che L=L(A’).

43 DETERMINISMO non DETERMINISMO Definizione Se A=(Q,T, , q 0,F) e’ un automa deterministico, si indica  (q,a)=q’ in luogo di  (q,a)=  q’ , l’unico valore associato a  (q,a). Essendo gli insiemi regolari definibili sia da espressioni regolari che da automi, usiamo le prime per definire lo scanner e i secondi per implementarlo.

44 DETERMINISMO non DETERMINISMO Definizione Dato A=(Q,T, , q 0,F) automa deterministico, da  (q,a)=q’ si deduce che per ogni configurazione C=(q,aw) e’ unico lo stato q’ e la mossa o transizione (q,aw) ├ (q’,w)=C’ per cui  (q,a)=q’. Per questo, gli automi deterministici sono piu’ efficienti di quelli non deterministici e piu’ adatti per implementare scanner.

45 IMPLEMENTAZIONE DI SCANNER Scanner: costruzione. Si definisce un insieme di espressioni regolari che date in input ad uno ‘scanner constructor’ costruisce un automa finito deterministico ottimizzato che implementa la scanner richiesto. Noi mostrimo i seguenti passaggi: Esp.Reg  NFA  DFA  DFA ottimale la costruzione del NFA e’ ridodndante

46 DA NFA a DFA Scanner: costruzione. Se L=L(M) per NFA A=(Q,T, , q 0,F) allora il DFA equivalente e’ A’=(Q’,T,  ’, q’ 0,F’) con: Q’=  (Q)=2 Q q 0 ’=  q 0 ,  S  Q  ’(S,a)=  p|  q  S: p  (q,a)  =  (S,a) F’=  S  Q | S  F 

47 DA NFA a DFA NFA  DFA: e’ facile mostrare che: A(S,w) ├ i A’ (S’,  )   S’={p|  q  S: (q,w) ├ i A (p,  )}

48 DIAGRAMMI DI TRANSIZIONE E’ un flowchart stilizzato di un analizzatore lessicale. Permette di tener traccia dei caratteri letti dallo scanner. Si possono avere diagrammi deterministici e non. Grafo di transizione e’ un grafo orientato con vertici etichettati da sinboli di Q e gli archi etichettati da simboli in T. I diagrammi di transizione modellano DFA i

49 DIAGRAMMI DI TRANSIZIONE Diagramma di transizione: flowchart stilizzato di un analizzatore lessicale. Permette di tener traccia dei caratteri letti dallo scanner. Si possono avere diagrammi deterministici e non. Grafo di transizione e’ un grafo orientato con vertici etichettati da sinboli di Q e gli archi etichettati da simboli in T. I diagrammi di transizione modellano DFA

50 DIAGRAMMI DI TRANSIZIONE I diagrammi di transizione sono deterministici, gli archi uscenti dallo stesso vertice hanno etichette distinte. I grafi di transizione sono in generale non deterministici: dallo stesso vertice possono uscire archi con la stessa etichetta.

51 DIAGRAMMA DI TRANSIZIONE

52 GRAFO DI TRANSIZIONE

53 DA ESPRESSIONE REGOLARE A NFA Si usa un metodo guidato dalla sintassi (algoritmo di Thompson): esso usa la struttura sintattica dell’espressione regolare per guidare il processo di costruzione: Input: un’esoressione regolare r su T Output: un NFA N eche accetta r

54 DA ESPRESSIONE REGOLARE A NFA Metodo: Si esegue il parsing di r per isolarne le sottoespressioni. Usando le regole 1 e 2 seguenti si costruisce un NFA per ogni simbolo di r. Visitando bottom-up l’albero sintattico di r si combinano i singoli NFA mediante la regola 3.

55 DA ESPRESSIONE REGOLARE A NFA R1- riconoscimento di  : R2- riconoscimento di a  T:

56 DA ESPRESSIONE REG. A NFA R3- dati N(s) e N(t) costruiti da s e t allora a) per s+t costruire l’ NFA N(s+t) b) per s.t costruire l’ NFA N(s.t)

57 DA ESPRESSIONE REG. A NFA R3- dati s e N(s) allora c) per s* costruire l’ NFA N(s*)

58 ESPR. REGOLARI ESEMPIO

59 ESEMPIO (a+b)*abb R1- riconoscimento di a  T : R2- riconoscimento di b  T:

60 ESEMPIO (a+b)*abb R3 a)- riconoscimento di a+b R3 c)- riconoscimento di (a+b)*

61 ESEMPIO (a+b)*abb R3 a)- riconoscimento di (a+b)*a R3 a)- riconoscimento di (a+b)*abb

62 ESPR. REGOLARI E AUTOMI

63 ESPR. REGOLARI E AUTOMI

64 DA NFA a DFA

65 CONVERSIONE DA NFA A DFA CONVERSIONE DA NFA A DFA INPUT NFA N OUTPUT DFA D che accatta lo stesso linguaggio Operazioni usate  -chiusura(s)=  s’| s’ raggiungibile da s con  -transizioni   -chiusura(S)=  s  S  -chiusura(s) move(S,a)=  s’| (s,s’,a)  grafo trans. & a  T  Gli stati di D sono insiemi di stati di N costruiti come segue (usa algoritmo di marcatura)

66 CONVERSIONE DA NFA A DFA CONVERSIONE DA NFA A DFA Dstates :=  -chiusura(s 0 )  non marcato while  S  Dstates non marcato do do mark(S) for each a  T do U:=  -chiusura(move(S,a)); Dstate:=Dstate  U; Dtran[S,a]:=U od

67 NFA  A DFA esempio NFA  A DFA esempio T*amo con T={a,m,o,…} Dstates :=  -chiusura(1)  ={1} (non ci sono  -transizioni,  -chiusure) move({1},a)= {1,2}; move({1},T-{a})= {1}; move({1,2},a)={1,2};move({1,2},m)={1,3}; move({1,2},T-{a,m})={1}; move({1,3},a)={1,2}; move({1,3},o)={1,4}; move({1,3},T-{a,o})={1};move({1,4},a)={1,2}; move({1,4},T-{a})={1}

68 NFA  A DFA esempio NFA  A DFA esempio T*amo con T={a,m,o,…} (non ci sono  -transizioni,  -chiusure) Dstates :=  1  ; move({1},a)= {1,2}; move({1},T-{a})= {1}; move({1,2},a)={1,2};move({1,2},m)={1,3}; move({1,2},T-{a,m})={1}; move({1,3},a)={1,2}; move({1,3},o)={1,4}; move({1,3},T-{a,o})={1};move({1,4},a)={1,2}; move({1,4},T-{a})={1}

69 CALCOLO DI  -CHIUSURA CALCOLO DI  -CHIUSURA  -close(T); PROC  -close(T); -closure(T):=T; PUSH all states  T:  -closure(T):=T; while stack  do pop t; for each u:  (t,u,  )  E do if u   -chiusura(t) then INCL(  -chiusura(t),u); push u fi od

70 MINIMIZZAZIONE di DFA MINIMIZZAZIONE di DFA A=(Q,T, , q 0,F) ; INPUT: un DFA A=(Q,T, , q 0,F) ; OUTPUT: un DFA M tale che L(M)=L(A) e |Q M | minimo METODO: Si costruisce una partizione iniziale di Q  0 =  F,Q-F  Si applica la procedura Split seguente a  ottenendo  ’ Se  ’   :=  ’ e ripetere il passo Usare  come insieme degli stati di M.  ha la proprieta’ che   a  T  :  q   (q,a)  per cui  M ( ,a)=  e’ ben definita. L(M)=L(A) E’ facile dimostrare che L(M)=L(A)

71 MINIMIZZAZIONE Proc. Split MINIMIZZAZIONE Proc. Split ; PROC Split( ,VAR  ’); begin for each G   do if  s,t  G&  a  T&  G’,G’’  :  (s,a)  G’&  (t,a)  G’’ then G:=G1  G2; G1  G2=  ; s  G1 t  G2;  ’:=  -  G  G1,G2  ; return  ’ fi od end;

72 MINIMIZZAZIONE Esempio MINIMIZZAZIONE Esempio  1 =  A,B,C,D ,  E   (D,b)=E  A,B,C,D  per cui  A,B,C,D  si sdoppia in  A,B,C ,  D  e la nuova partizione e’  2 =  A,B,C ,  D ,  E   (B,b)=D  A,B,C  per cui  A,B,C  si sdoppia in  A,C ,  B  e la partizione finale diviene  3 =  A,C ,  B ,  D ,  E 

73 MINIMIZZAZIONE Input MINIMIZZAZIONE Input

74 MINIMIZZAZIONE Output MINIMIZZAZIONE Output

75 MINIMIZZAZIONE COMPLETA MINIMIZZAZIONE COMPLETA ; PROC Min( ,VAR  ’); begin new:=TRUE; ; new:=TRUE;  ’:=  ; WHILE new DO new:=FALSE; for each a  T DO FOR EACH G   ’ DO partition G into {G1,G2,..,Gk} such that  i 1  i  k  Hi  ’  s,t  Gi  (s,a)  Hi&  (t,a)  Hi OD IF k>1 THEN  ’:=  ’-  G  G1,G2,…,Gk}; new:=TRUE FI OD end;

76 MINIMIZZAZIONE FINE MINIMIZZAZIONE FINE FINE SCANNER Ignorare le slide seguenti: sono un pattern per sviluppi futuri

77 RAPPRESENTAZIONI INTERMEDIE RAPPRESENTAZIONI INTERMEDIE analisi op= semantica / \ / \ id[1] op+ / \ id[2] op* / \ id[3] float | 53

78 RAPPRESENTAZIONI INTERMEDIE RAPPRESENTAZIONI INTERMEDIE codice intermedio tmp1 = float(53) tmp2 = id[3] op* tmp1 tmp3 = id[2] op+ tmp2 id[1] = tmp3 Ottimizzazione di codice (intermedio) tmp1 = id[3] op* id[1] = id[2] op+ tmp1

79 Esempio Sia G=({E,T,P},{(,),a,b,c,*,+,-},P,E) dove P={E  E+T|E-T|T, T  T*P|P, P  (E)|a|b} Mentre la derivazione: E E  E-T  E-P  E-c  T-c  P-c  (E)-c  (E-T)-c  (E-P)-c  (E-b)-c  (T-b)-T  (P-b)-c  (a-b)-c e’ canonica destra, Confrontandola con la sinistra: E E  E-T  T-T  P-T  (E)-T  (E-T)-T  (T-T)-T  (P-T)-T  (a-T)-T  (a-P)-T  (a-b)-T  (a-b)-P  (a-b)-c Si vede che differiscono solo per l’ordine di applicazione delle produzioni. Entrambe applicano le stesse produzioni alle stesse istanze di non terminali

80 Esempio di G espressioni Esempio di G espressioni Grammatica di espressioni non ambigua con priorita’ di operatori e associativita’ cablate E  E+T | E-T | T T  T*F | T/F | F F  P^F | P P  (E) | I | N I  a|b|c|d N  0 | 1 | 2

81 Esempio di LNG inerentemente ambiguo e di LNG non CFL Esempio di LNG inerentemente ambiguo e di LNG non CFL L={a i b j c k | i=j OR j=k; i,j,k>0} S  S 1 S 2 | S 3 S 4 S 1  aS 1 b |  S 2  S 2 c|  S 4  bS 4 c |  S 3  S 3 a|  L={a n b n c n | n>0} non e’ un CFL

82 MINIMIZZAZIONE COMPLETA MINIMIZZAZIONE COMPLETA ; PROC Min( ,VAR  ’); begin new:=TRUE; ; new:=TRUE;  ’:=  ; WHILE new DO new:=FALSE; for each a  T DO FOR EACH G   ’ DO partition G into {G1,G2,..,Gk} such that  i 1  i  k  Hi  ’  s,t  Gi  (s,a)  Hi&  (t,a)  Hi OD IF k>1 THEN  ’:=  ’-  G  G1,G2,…,Gk}; new:=TRUE FI OD end;