La presentazione è in caricamento. Aspetta per favore

La presentazione è in caricamento. Aspetta per favore

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

Presentazioni simili


Presentazione sul tema: "Implementazione di Linguaggi 2 Massimo Ancona Testo: A.V. Aho, R. Sethi, J.D.Ullman Compilers Principles,Techniques and Tools, Addison Wesley."— Transcript della presentazione:

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

2 2 Diagramma del processo di compilazione

3 3 Strumenti associati al compilatore: il Linker

4 4 Contesto/ambiente di un cmp Programming Environment Un ambiente grafico interattivo per lo sviluppo, il testing e la manutenzione dei programmi: integra e gestisce gli strumenti e i meccanismi seguenti Strumenti e meccanismi correlati ai compilatori Sistemi per le compilazioni separate Sistemi per le compilazioni separate Sistemi per il controllo delle versioni Sistemi per il controllo delle versioni Meccanismi per le ricompilazioni efficienti Meccanismi per le ricompilazioni efficienti Macroprocessori e Preprocessori Macroprocessori e Preprocessori Linker loader Linker loader Interpreti debugger profiler Interpreti debugger profiler

5 5 Processo Di Compilazione Processo Di Compilazione Nella sua forma piu' astratta il processo di compilazione e' descritto nella figura seguente: il compiler e' una funzione che mappa un programma in linguaggio sorgente in un programma equivalente in linguaggio oggetto.

6 6 Fasi e Passi (Passate) Sono due concetti ortogonali: Le fasi denotano trasformazioni sul programma eseguite da tutti i compilatori. I passi si riferiscono al numero di processi successivi, in cui e' suddiviso un compilatore (il loro numero dipende in parte dal linguaggio). Il compilatore in una passata, legge il codice sorgente o una sua forma intermedia equivalente, raffinando il processo di treduzione e producendo una nuova rappresentazione intermedia, fino ad arrivare al codice target, nellultima passata.

7 7 Fasi Di Compilazione Fasi Di Compilazione Una fase denota il tipo di operazione effettuata. Fasi e passate sono concetti ortogonali anche se una struttura canonica del compilatore tende ad incapsulare una (o piu') fasi, in una specifica passata. La divisione piu' grossolana prevede due fasi: analisi e sintesi. Con la prima il programma sorgente viene suddiviso nelle parti costituenti ottenendone una rappresentazione intermedia. Nella seconda si costruisce il programma target nel linguaggio oggetto.

8 8 Analisi e Sintesi Strumenti che eseguono lanalisi dellinput Editori di testo, Formattatori e Sistemi Ipertestuali (HTML, XML, PDF, TEX) Editori di testo, Formattatori e Sistemi Ipertestuali (HTML, XML, PDF, TEX) Silicon Compilers (sintetizzatori di circuiti e componenti Hardware) Silicon Compilers (sintetizzatori di circuiti e componenti Hardware) Query Interpreters Query Interpreters Motori di Ricerca e strumenti correlati Motori di Ricerca e strumenti correlati

9 9 Analisi e Sintesi Analisi Analisi divide il pgm sorgente nelle parti costituenti creando una rappresentazione intermedia. Sintesi Sintesi costruisce il programma oggetto dalla rappresentazione intermedia.

10 10 Dettaglio Delle Fasi Dettaglio Delle Fasi ELenco completo delle possibili fasi di compilazione:

11 11 Rappresentazioni Intermedie sorgente primo := base + 53 * delta; out lessicale id[1] op= id[2] op+ ci=53 op* id[3] out sintattico op= id[1] op+ id[2] op* 53 id[3]

12 12 Rappresentazioni Intermedie (e Finali) out semantica op= id[1] op+ id[2] op* float id[3] 53

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

14 14 Rappresentazione Finale codice macchina: movf id3, rf2 mulf #53.00, rf2 movf id[2], rf1 addf rf2, rf1 movf rf1, id[1] Supponiamo di utilizzare solamente due registri rf1 e rf2.

15 15 Tipi di Compilatori Vi sono diversi tipi di compilatori Ad un sol passo Ad un sol passo Multi-passo Multi-passo Load_and_go Load_and_go Debugging Debugging Optimizing Optimizing Compiler-Interpreter Compiler-Interpreter

16 16 Introduzione alla Compilazione Un compilatore in due passate

17 17 Le fasi di analisi del sorgente Analisi Lessicale. I caratteri del codice sorgente vengono letti left-to-right e raggruppati in Token. Analisi Lessicale. I caratteri del codice sorgente vengono letti left-to-right e raggruppati in Token. Analisi Sintattica. I caratteri o token sono raggruppati in frasi grammaticali. Analisi Sintattica. I caratteri o token sono raggruppati in frasi grammaticali. Analisi Semantica. Vengono effettuati controlli per trovare errori semantici e raccogliere informazioni per la generazione di codice. Analisi Semantica. Vengono effettuati controlli per trovare errori semantici e raccogliere informazioni per la generazione di codice.

18 18 Le fasi di analisi del sorgente Analisi Lessicale. Source Program Lexical analyzer Parser Token Get next Token Symbol Table

19 19 Le fasi di analisi del sorgente Analisi Lessicale. Ad esempio listruzione: alpha:=beta+gamma*100; viene codificata nei seguenti TOKEN: Gli spazi ridondanti, i fine linea ecc. che separano i token vengono eliminati. Eseguita dallo Scanner

20 20 Le fasi di analisi del sorgente Analisi Sintattica. Ogni linguaggio di programmazione ha delle regole che descrivono la struttura sintattica di un programma ben formato. Ogni linguaggio di programmazione ha delle regole che descrivono la struttura sintattica di un programma ben formato. La sintassi di un linguaggio di programmazione può essere descritta da una grammatica libera da contesto La sintassi di un linguaggio di programmazione può essere descritta da una grammatica libera da contesto

21 21 Le fasi di analisi del sorgente Analisi Sintattica. Source Program Lexical analyzer Parser Token Get next Token Symbol Table Parse Tree

22 22 Le fasi di analisi del sorgente Analisi Sintattica. Agisce dopo lanalisi lessicale. Raggruppa i token in frasi grammaticali che si rappresentano con un parse tree. Parse tree di: alpha := beta + gamma * 100 ( ) ( ) Eseguita dal Parser

23 23 Le fasi di analisi del sorgente Analisi Semantica. Controlla il codice sorgente alla ricerca di errori semantici e raccoglie informazioni sui tipi per la fase di generazione di codice Type checking è la componente più importate di questa fase: Controlla che gli operatori abbiano operandi permessi dalla specifica del linguaggio. Controlla che gli operatori abbiano operandi permessi dalla specifica del linguaggio.

24 24 Relazione tra le Fasi La suddivisione tra analisi lessicale e sintattica è piuttosto arbitraria (come per le altre fasi della compilazione); Uno dei metodi usati per discriminarle si basa sulla ricorsione: i costrutti descrivibili senza ricorsione si assegnano allanalisi lessicale; i costrutti descrivibili senza ricorsione si assegnano allanalisi lessicale; quelli sostanzialmente ricorsivi a quella sintattica. quelli sostanzialmente ricorsivi a quella sintattica.

25 25 Sintassi Formale dei Linguaggi di Programmazione La si specifica tramite: diagrammi sintattici; diagrammi sintattici; equazioni BNF EBNF; equazioni BNF EBNF; grammatiche non contestuali (context free) grammatiche non contestuali (context free) Tutte forme sostanzialmente equivalenti.

26 26 Grammatiche Libere da Contesto (CFG) Le Context Free Grammar sono una notazione per specificare la sintassi di un linguaggio. Le Context Free Grammar sono una notazione per specificare la sintassi di un linguaggio. Una CFG ha 4 componenti: Una CFG ha 4 componenti: Un insieme di token, detti simboli terminali Un insieme di token, detti simboli terminali Un insieme di non-terminali Un insieme di non-terminali Un insieme di produzioni, dove ogni produzione consiste di un non-terminale (left side), una freccia e una sequenza di token e/o non-terminali (right side) Un insieme di produzioni, dove ogni produzione consiste di un non-terminale (left side), una freccia e una sequenza di token e/o non-terminali (right side) Lindicazione di un non-terminale come simbolo iniziale Lindicazione di un non-terminale come simbolo iniziale

27 27 Grammatiche Libere da Contesto Esempio Vediamo un esempio di produzioni che definiscono semplici espressioni aritmetiche: Vediamo un esempio di produzioni che definiscono semplici espressioni aritmetiche: expr expr op expr expr ( expr ) expr id op + op + op - op - op * op * op / op / op op ( ( Simboli terminali: id + - * / ( ( Simboli non-terminali: expr op Simbolo iniziale: expr

28 28 Grammatiche Libere da Contesto Esempio Scrivere la grammatica context free per esprimere zero o più volte il simbolo (terminale) thing. Scrivere la grammatica context free per esprimere zero o più volte il simbolo (terminale) thing. List List List thing List List List List List List thing List List List List List thing

29 29 Grammatiche Libere da Contesto (CFG): Definizione Formale Alfabeto T ( ) : Alfabeto T ( ) : è un insieme finito non vuoto, e è un insieme finito non vuoto, e gli elementi di T ( ) vengono chiamati simboli o caratteri. gli elementi di T ( ) vengono chiamati simboli o caratteri. Useremo le lettere V, T, N, per indicare alfabeti Useremo le lettere V, T, N, per indicare alfabeti

30 30 Grammatiche Libere da Contesto (CFG): Definizione Formale Parola di lunghezza k 0, su un alfabeto T: Parola di lunghezza k 0, su un alfabeto T: è una sequenza finita w=x 1 x 2 …x k di elementi di T, è una sequenza finita w=x 1 x 2 …x k di elementi di T, k, denotata anche k=|w| è detta lunghezza di w, e k, denotata anche k=|w| è detta lunghezza di w, e la parola di lunghezza zero, detta parola vuota, e indicata. la parola di lunghezza zero, detta parola vuota, e indicata.

31 31 Grammatiche Libere da Contesto (CFG): Definizione Formale Linsieme delle parole su T (linguaggio), indicato con T* monoide: Linsieme delle parole su T (linguaggio), indicato con T* monoide: con legge di composizione concatenazione di parole con legge di composizione concatenazione di parole Date w 1,w 2 T, Date w 1,w 2 T, w 1 = x 1 x 2 …x k,w 2 = y 1 y 2 …y l w= w 1.w 2 = x 1 x 2 …x k y 1 y 2 …y l, di lunghezza k+l, è detta concatenazione di w 1 e w 2. Il monoide (T*,.) è detto monoide libero su T.

32 32 Parentesi Algebrica: Monoide Un monoide è un insieme M munito di una singola operazione binaria, chiamata prodotto, che ad ogni coppia di elementi a, b di M associa un elemento ab, rispettando i seguenti assiomi: Un monoide è un insieme M munito di una singola operazione binaria, chiamata prodotto, che ad ogni coppia di elementi a, b di M associa un elemento ab, rispettando i seguenti assiomi: per ogni a, b appartenenti a M, il loro prodotto ab appartiene ancora a M, vale a dire, M è chiuso rispetto al prodotto. per ogni a, b appartenenti a M, il loro prodotto ab appartiene ancora a M, vale a dire, M è chiuso rispetto al prodotto. Il prodotto è associativo: dati a, b, c appartenenti a M, vale (ab)c = a(bc). Il prodotto è associativo: dati a, b, c appartenenti a M, vale (ab)c = a(bc). Esiste in M un (unico) elemento neutro e tale che ae = ea = a. Esiste in M un (unico) elemento neutro e tale che ae = ea = a.

33 33 Grammatiche Libere da Contesto (CFG): Definizione Formale Una CFG formalmente è una quadrupla G=(N,T,P,S) con N T= e V=N T, dove: T è un alfabeto di simboli terminali di G. T è un alfabeto di simboli terminali di G. N è un alfabeto di simboli non-terminali di G. N è un alfabeto di simboli non-terminali di G. P è un insieme finito di produzioni di G. P è un insieme finito di produzioni di G. S N è detto simbolo iniziale di G. S N è detto simbolo iniziale di G.

34 34 Grammatiche Libere da Contesto (CFG): Definizione Formale Notazione utilizzata per le produzioni N V*: a,b,c,…,+,-,…,0,1,…,(,[,{,… indicano elementi di T (= terminali) a,b,c,…,+,-,…,0,1,…,(,[,{,… indicano elementi di T (= terminali) A,B,C,… indicano elementi di N (= non-terminali) A,B,C,… indicano elementi di N (= non-terminali) U,V,X,Y,Z indicano elementi di V=T N U,V,X,Y,Z indicano elementi di V=T N u,v,x,y, indicano elementi di T*(= stringhe di terminali) u,v,x,y, indicano elementi di T*(= stringhe di terminali),,,…, indicano elementi di V* (= stringhe di simboli grammaticali),,,…, indicano elementi di V* (= stringhe di simboli grammaticali) =(A, ) N V* è indicata da A =(A, ) N V* è indicata da A

35 35 Linguaggi Context Free Linguaggio generato da G: L(G)= w T*| S * w L(G)= w T*| S * w Un linguaggio L T* è libero da contesto se esiste G=(N,T,P,S) CFG tale che L=L(G)

36 36 Forme Sentenziali Data G=(N,T,P,S) una forma sentenziale di G è definita ricorsivamente, come segue: S è una forma sentenziale di G, S è una forma sentenziale di G, se A è una forma sentenziale di G e A è una produzione di G allora è una forma sentenziale di G. se A è una forma sentenziale di G e A è una produzione di G allora è una forma sentenziale di G. La relazione tra A e al punto precedente viene indicata: A (Derivazione) A (Derivazione)

37 37 Derivazioni Dirette e Non A esprime che deriva direttamente da A o che A genera direttamente. A esprime che deriva direttamente da A o che A genera direttamente. Le notazioni * + indicano rispettivamente la chiusura transitiva-riflessiva e transitiva di Le notazioni * + indicano rispettivamente la chiusura transitiva-riflessiva e transitiva di * denota che = oppure * denota che = oppure i i=1..n = 1 2 … n = e n>0. i i=1..n = 1 2 … n = e n>0. denota che e n>0. + denota che = 1 2 … n = e n>0.

38 38 Derivazioni - Esercizio La stringa – ( id + id ) è una sentenza della grammatica G? E E - E - ( E ) - ( E + E ) - ( id + E ) - ( id + id ) G: E E + E E E * E E ( E ) E - E E id E * - ( id + id )

39 39 Derivazioni canoniche Una derivazione e detta canonica destra e indicata, se ad ogni passo di derivazione si espande il simbolo non-terminale più a destra. Una derivazione * e detta canonica destra e indicata rm *, se ad ogni passo di derivazione si espande il simbolo non-terminale più a destra. se i si ha i = i A i x i, i+1 = i i x i,, rm * se i si ha i = i A i x i, i+1 = i i x i, A i i, = 1 2 … n = i=1,…,n

40 40 Derivazioni canoniche Una derivazione e detta canonica sinistra e indicata, se ad ogni passo di derivazione si espande il simbolo non-terminale più a sinistra. Una derivazione * e detta canonica sinistra e indicata lm *, se ad ogni passo di derivazione si espande il simbolo non-terminale più a sinistra. se i si ha i =x i A i i, lm * se i si ha i =x i A i i, i+1 =x i i i, A i i, = 1 2 … n = i=1,…,n

41 41 Derivazioni Canoniche Esempio G=({E,T,P}, {(,),a,b,c,*,+,-}, P, E) P={E E +T |E -T |T, T T *P |P, T T *P |P, P (E ) | a | b | c} P (E ) | a | b | c} Data (a-b) – c la derivazione: E E -T T -T P -T E )-T E - T )-T E E -T T -T P -T (E )-T (E - T )-T T - T )-T P - T )-T a - T )-T a - P )-T (T - T )-T (P - T )-T (a - T )-T (a - P )-T a - b )-T a - b )-P a - b ) - c (a - b )-T (a - b )-P (a - b ) - c È canonica sinistra. Non-terminali terminali

42 42 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 |c} 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 è canonica destra, confrontandola con la canonica 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 lordine di applicazione delle produzioni. Entrambe applicano le stesse produzioni alle stesse istanze di non terminali

43 43 Parsing Tree Tutte le derivazioni che differiscono solo per lordine di applicazione delle produzioni sono sostanzialmente equivalenti e possono essere rappresentate da ununica derivazione canonica destra, un unica derivazione canonica sinistra o da un unico albero etichettato detto Parsing Tree.

44 44 Parsing Tree - Definizione La radice è etichettata da S Ogni foglia dellalbero è etichettato da o da un simbolo di T (terminale) Ogni nodo interno è etichettato da un simbolo di N (non terminale) Se A etichetta un nodo interno e X 1,X 2,…, X n sono le etichette dei figli, allora A X 1 X 2 …X n P

45 45 Parsing Tree - Esempio Derivazione: - (id + id) E - E - E ( E ) ( E ) E + E E + E id id id id G: E E + E E E * E E ( E ) E - E E id

46 46 Esempio di Parsing Tree Esempio di Parsing Tree Derivazione di: (a – b ) – c (a – b ) – c Grammatica: E E +T |E -T |T T T *P |P, P (E ) | a | b | c}

47 47 Classificazione di Chomsky È una classificazione dei linguaggi basata sulla complessità delle produzioni delle grammatiche che li generano. I linguaggi di tipo 0 sono generati da grammatiche a struttura di frase. I linguaggi di tipo 1 sono generati da grammatiche dipendenti dal contesto. I linguaggi di tipo 2 sono generati da grammatiche libere dal contesto. I linguaggi di tipo 3 sono generati da grammatiche lineari (o regolari).

48 48 Classificazione di Chomsky Grammatiche a struttura di frase. Le produzioni sono del tipo A Grammatiche dipendenti dal contesto. Le produzioni sono del tipo A dove, V*, A N e V*. Grammatiche libere dal contesto. Le produzioni sono del tipo A, dove V*. Grammatiche lineari (o regolari). Le produzioni sono del tipo A uB oppure A u, dove u * e A, B N.

49 49 Classificazione di Chomsky Ogni grammatica di tipo n è anche una grammatica di tipo n 1. Un linguaggio è di tipo n se è generato da una grammatica di tipo n, ma non di tipo n + 1. Esempi: - Linguaggio di tipo 3: L = {a m b n : m, n 0}. - Linguaggio di tipo 2: L = {a n b n : n 0}. - Linguaggio di tipo 1: L = {a n b n c n : n 0}. - Linguaggio di tipo 0: L = {a n : n è numero primo}.

50 50 Grammatiche e Linguaggi Ambigui Una grammatica G è ambigua se: w L(G) con due parsing tree diversi w L(G) con due parsing tree diversi Un linguaggio è inerentemente ambiguo se per ogni G tale che L=L(G) si ha che G e ambigua.

51 51 Tecniche per Disambiguare Inserire regole di precedenza per gli operatori. Inserire regole di precedenza per gli operatori. Utilizzare associatività a sinistra o a destra. Utilizzare associatività a sinistra o a destra. Manipolare la grammatica. Manipolare la grammatica.

52 52 Grammatica Ambigua Esempio G=({S}, {if, then, else, s, b}, P={S if b then S | if b then S else S | s}, S) S rm if b then S rm if b then if b then S else S rm if b then if b then S else s rm if b then if b then s else s S rm if b then S else S rm if b then S else s rm if b then if b then S else s rm if b then if b then s else s if b then if b then s else s

53 53 Grammatica Ambigua Esempio Grammaticha ambigua: G=({S}, {if, then, else, s, b}, P={S if b then S | if b then S else S | s}, P={S if b then S | if b then S else S | s}, S) S) Grammatica disambiguata: G=({S, S 1, S 2 }, {if, then, else, s, b}, P={S S 1, S 1 if b then S 1 | P={S S 1, S 1 if b then S 1 | if b then S 2 else S 1 | s, if b then S 2 else S 1 | s, S 2 if b then S 2 else S 1 | s}, S 2 if b then S 2 else S 1 | s}, S) S)

54 54 Grammatica non ambigua con proprietà opportune Nota: la gramamtica è context free, e mostriamo solo le produzioni. Grammatica di espressioni non ambigua con priorità di operatori e associatività 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 G per espressioni, semplice ma ambigua E EOE|(E)|a|b|c|d O +|-|*|^

55 55 Altri esempi di grammatiche Altri esempi di grammatiche G 0 di espressioni non ambigua con priorità di operatori e associatività cablate E E+T | E-T | T |-T|+T T T*F | T/F | F F (E) | I | N I a|b|c|d N 0 | 1 | 2 G 1 per espressioni, semplice, non ambigua ma flat E EOT|T|-T|+T T (E)|a|b|c|d|0|1|2 O +|-|*|/

56 56 Derivazione canonica di G 0 Derivazione canonica di G 0 Data a-b*c e G 0 abbiamo: E rm E-T rm E-T*F rm E-T*I rm E-T*c rm E-T*I rm E-T*c rm E-F*c rm E-I*c rm E-F*c rm E-I*c rm E-b*c rm T-b*c rm E-b*c rm T-b*c rm F-b*c rm I-b*c rm F-b*c rm I-b*c rm a-b*c rm a-b*c E E+T | E-T | T |-T|+T T T*F | T/F | F F (E) | I | N I a | b | c | d N 0 | 1 | 2

57 57 Parse tree (G 0 ) Parse tree (G 0 ) Derivazione Canonica: E rm E-T rm E-T*F rm E-T*I rm E-T*c rm E-T*I rm E-T*c rm E-F*c rm E-I*c rm E-F*c rm E-I*c rm E-b*c rm T-b*c rm E-b*c rm T-b*c rm F-b*c rm I-b*c rm F-b*c rm I-b*c rm a-b*c rm a-b*cE E-T T T * F F F I I I c a b a b

58 58 Derivazione canonica di G 1 Data a-b*c e G 1 abbiamo: E rm EOT rm EOc rm E*c rm EOT*c rm E*c rm EOT*c rm EOb*c rm rm EOb*c rm rm E-b*c rm rm E-b*c rm rm T-b*c rm T-b*c rm a-b*c rm a-b*c E EOT|T|-T|+T T (E)|a|b|c|d|0|1|2 O +|-|*|/

59 59 Parse tree (G 1 ) Derivazione Canonica: E rm EOT rm EOc rm E*c rm EOT*c rm E*c rm EOT*c rm EOb*c rm rm EOb*c rm rm E-b*c rm rm E-b*c rm rm T-b*c rm T-b*c rm a-b*c rm a-b*c E E O T E O T E O T * c T - b a

60 60 Esercizio Studiare G 2 : E FOT | T F FOT | T | F FOT | T | T (E)| a | b | c | d | 0 | 1 | 2 O + | - | * | ^

61 61Esempio Documenti HTML XML: D Ps B Pd Ps Ps Pd Pd B L B L L E L | E | L E L | E | E R E R R rest

62 62Esempio Documenti HTML XML: D Ps B Pd Ps Ps Pd Pd B L B L L E L | E | L E L | E | E R E R R rest

63 63Esempio Documenti HTML XML: D Ps B Pd Ps Ps Pd Pd B L B L L E L | E | L E L | E | E R E R R rest

64 64 Esempio Documenti HTML XML: D Ps L Pd Ps Ps Pd Pd L E L | E | L E L | E | E R R rest

65 65 Operazioni sui Linguaggi Dati due linguaggi L, M * definiamo prodotto di L e M, indicato LM o L. M, linsieme: L M ={uv | u L & v M}

66 66 Operazioni sui Linguaggi Definiamo chiusura di Kleene di L, indicata con L*, loperazione: L 0 ={ } L 0 ={ } L 1 =L L 1 =L L i =L L i-1 i>0 L i =L L i-1 i>0 L*= i 0 L i L*= i 0 L i L + = i>0 L i L + = i>0 L i

67 67 Operazioni sui Linguaggi - Esempi Proprieta: supponiamo T terminale e vediamo le produzioni di E G 0 =({E},{t,+,-},P 0,E) P 0 ={E E+t | E-t | t|-t|+t} L(G 0 )={-t,+t,t}({+,-}t)* e G 1 =({E,O},{t,+,-},P1,E) P 1 ={E EOt|t|-t|+t,O +|-} O +|- L(G 1 )=L(G 0 )

68 68 Linguaggi - Esempi Esempio di linguaggio inerentemente ambiguo Esempio di linguaggio inerentemente ambiguo L={a i b j c k | i=j OR j=k; i,j,k 0} 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 S 1 S 2 | S 3 S 4 S 1 aS 1 b | S 2 S 2 c| S 1 aS 1 b | S 2 S 2 c| S 4 bS 4 c | S 3 S 3 a| S 4 bS 4 c | S 3 S 3 a| Esempio di linguaggio non context free. Esempio di linguaggio non context free. L={a n b n c n | n>( ) 0} non e un CFL L={a n b n c n | n>( ) 0} non e un CFL

69 69 Syntax Tree (albero sintattico) e Parsing Tree Syntax Tree (albero sintattico) e Parsing Tree Albero Sintattico Una delle rappresentazioni intermedie più usate. Più astratto del parsing tree, Una delle rappresentazioni intermedie più usate. Più astratto del parsing tree, dipende solo dal linguaggio (non dalla grammatica)

70 70 EBNF EBNF Usa i simboli metalinguistici = | [ ] {. }. Usa i simboli metalinguistici = | [ ] {. }. […] significa opzionalita {…} significa ripetizione: 0 o piu volte (…) significa raggruppamento | indica alternativa. termina una produzione I simboli terminali vengono racchiusi tra I simboli terminali vengono racchiusi tra Esempio Expression = SimpleExpression [ Relation SimpleExpression ]. Relation = "=" | "<>" | " " | ">=" | "IN". SimpleExpression = [ "+" | "-" ] Term { AddOperator Term }. AddOperator = "+" | "-" | "OR". Term = Factor { MulOperator Factor }. MulOperator = "*" | "/" | "DIV"| "MOD" | "AND"

71 71 EBNF Esempio (Espressioni) EBNF Esempio (Espressioni) Expression = SimpleExpression [ Relation SimpleExpression ]. Relation = "=" | "<>" | " " | ">=" | "IN". SimpleExpression = [ "+" | "-" ] Term { AddOperator Term }. AddOperator = "+" | "-" | "OR". Term = Factor { MulOperator Factor }. MulOperator = "*" | "/" | "DIV" | "MOD" | "AND"

72 72 EBNF Espressioni (cont.) EBNF Espressioni (cont.) Designator [ ActualParameters ] | "(" Expression ")" | NOT Factor. Set = "[" [ Element { "," Element } ] "]". Element = OrdinalConstant [ ".." OrdinalConstant]. OrdinalConstant= Char | Integer. ActualParameters = ["(" [ ExpressionList ] ")"]. Ident = IdChar { IdChar | Digit }. IdChar = Letter | "_". Number = Integer | Real.

73 73 EBNF Espressioni (cont. 2) EBNF Espressioni (cont. 2) Integer = Digit { Digit } | Digit { HexDigit } "H". Real = Digit { Digit } "." { Digit } [ ScaleFactor ]. ScaleFactor = "E" [ "+" | "-" ] Digit { Digit }. HexDigit = Digit | "A" | "B" | "C" | "D" | "E" | "F". Digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9". CharConstant = "'" Char "'" | Digit { HexDigit } "X". String = ' { CharN | "''" } '. Char = CharN | "'".


Scaricare ppt "Implementazione di Linguaggi 2 Massimo Ancona Testo: A.V. Aho, R. Sethi, J.D.Ullman Compilers Principles,Techniques and Tools, Addison Wesley."

Presentazioni simili


Annunci Google