11

Implementazione di Linguaggi Implementazione di Linguaggi 22

Massimo AnconaMassimo AnconaDISI Università di GenovaDISI Università di GenovaTesto: Testo: A.V. Aho, R. Sethi, J.D.Ullman A.V. Aho, R. Sethi, J.D.Ullman Compilers Principles,Techniques and Compilers Principles,Techniques and Tools, Addison WesleyTools, Addison Wesley

22

Diagramma del processo Diagramma del processo di compilazionedi compilazione

33

Strumenti associati al Strumenti associati al compilatore: il Linkercompilatore: il Linker

44

Contesto/ambiente di un cmp Contesto/ambiente di un cmp Programming EnvironmentProgramming Environment

Un ambiente grafico interattivo per lo sviluppo, il Un ambiente grafico interattivo per lo sviluppo, il testing e la manutenzione dei programmi:testing e la manutenzione dei programmi: integra integra e gestisce gli strumenti e i meccanismi seguentie gestisce gli strumenti e i meccanismi seguenti

Strumenti e meccanismi correlati ai Strumenti e meccanismi correlati ai compilatoricompilatori

Sistemi per le compilazioni separate Sistemi per le compilazioni separate Sistemi per il controllo delle versioniSistemi per il controllo delle versioni Meccanismi per le ricompilazioni efficientiMeccanismi per le ricompilazioni efficienti Macroprocessori e PreprocessoriMacroprocessori e Preprocessori Linker loaderLinker loader

55

PROCESSO DI COMPILAZIONEPROCESSO 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.

66

FASI E PASSI (PASSATE)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, nell’ultima passata.

77

FASI DI COMPILAZIONEFASI DI COMPILAZIONE

Una fase denota il tipo di operazione effettuata. Fasi e le 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.

88

Analisi e SintesiAnalisi e Sintesi

Strumenti che eseguono l’analisi dell’inputStrumenti che eseguono l’analisi dell’input

Editori di testo, Formattatori e Sistemi Editori di testo, Formattatori e Sistemi Ipertestuali (HTML, XML, PDF, TEX) Ipertestuali (HTML, XML, PDF, TEX)

Silicon CompilersSilicon Compilers Query InterpretersQuery Interpreters Motori di Ricerca e strumenti correlatiMotori di Ricerca e strumenti correlati

99

Analisi e Sintesi Analisi e Sintesi

Analisi e SintesiAnalisi e Sintesi AnalisiAnalisi

divide il pgm sorgente nelle parti divide il pgm sorgente nelle parti costituenti creando una costituenti creando una rappresentazione intermedia.rappresentazione intermedia.

Sintesi Sintesi

costruisce il programma oggettocostruisce il programma oggetto dalla dalla rappresentazione intermedia.rappresentazione intermedia.

1010

DETTAGLIO DELLE FASIDETTAGLIO DELLE FASI ELenco completo delle possibili fasi di compilazione:

1111

RAPPRESENTAZIONI RAPPRESENTAZIONI INTERMEDIE INTERMEDIE

sorgente primo := base + 53 * delta;out lessicale id[1] <-- id[2] op= id[3] op+ ci=53 op* id[3]out sintattico op= / \ / \ id[1] op+ / \ / \ id[2] op* / \ / \ id[3] 53

1212

RAPPRESENTAZIONI RAPPRESENTAZIONI INTERMEDIE (E FINALI) INTERMEDIE (E FINALI)

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

1313

RAPPRESENTAZIONI RAPPRESENTAZIONI INTERMEDIE 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* 53.00 id[1] = id[2] op+ tmp1

1414

RAPPRESENTAZIONE RAPPRESENTAZIONE FINALE FINALE

codice macchina movf id3.off[FP],rf2 mulf 53.00,rf2 movf id[2][FP].offs,rf1 addf rf2,rf1 movf rf1,id[1].offs[FP]

1515

Tipi di CompilatoriTipi di Compilatori

Vi sono diversi tipi di compilatoriVi sono diversi tipi di compilatori Ad un sol passoAd un sol passo Multi-passoMulti-passo Load_and_goLoad_and_go DebuggingDebugging OptimizingOptimizing

1616

Introduzione alla Introduzione alla CompilazioneCompilazione

Un compilatore in due passate

1717

Le fasi di analisi del sorgente Le fasi di analisi del sorgente Sono tre: Sono tre: analisi lessicale,analisi lessicale, sintattica e semanticasintattica e semantica

Analisi lessicaleAnalisi lessicale o o linearelineare: in inglese : in inglese skanning/ skanning/ skannerskanner. Ad esempio l’istruzione:. Ad esempio l’istruzione:

alpha:=beta+gamma*100;alpha:=beta+gamma*100;viene codificata in:viene codificata in:<ID:’alpha’><OP:<ID:’alpha’><OP:><ID:’beta’><OP:><ID:’beta’><OP:><ID:’ga><ID:’ga

mma’><OP:mma’><OP:><VAL:’100’>><VAL:’100’>

Gli spazi ridondanti, i fine linea ecc. che separano Gli spazi ridondanti, i fine linea ecc. che separano i token vengono eliminati.i token vengono eliminati.

1818

Le fasi di analisi del sorgente Le fasi di analisi del sorgente Analisi sintatticaAnalisi sintattica o gerarchica: in inglese o gerarchica: in inglese parsing/ parsing/

parserparser. . Agisce dopo l’analisi lessicale. Esempio:Agisce dopo l’analisi lessicale. Esempio:<ID:’alpha’><OP:<ID:’alpha’><OP:><ID:’beta’><OP:><ID:’beta’><OP:><ID:’gam><ID:’gam

ma’><OP:ma’><OP:><VAL:’100’>><VAL:’100’>Si puo’ codificare in un Si puo’ codificare in un albero sintatticoalbero sintattico del tipo: del tipo: (<(<>)>)<EXP:ID> <EXP: <EXP:ID> <EXP: >><ID:’alpha’> <EXP:ID> <EXP: <ID:’alpha’> <EXP:ID> <EXP: >> <ID:’beta’> <EXP:ID><EXP:VAL><ID:’beta’> <EXP:ID><EXP:VAL>

<ID:’gamma’><VAL:’100’><ID:’gamma’><VAL:’100’>

2121

Relazione tra le Fasi Relazione tra le Fasi

La suddivisione tra analisi lessicale e La suddivisione tra analisi lessicale e sintattica e’ piuttosto arbitraria (come per sintattica e’ piuttosto arbitraria (come per le altre fasi della compilazione); le altre fasi della compilazione);

Uno dei metodi usati per discriminarle si Uno dei metodi usati per discriminarle si basa sulla basa sulla ricorsionericorsione:: i costrutti descrivibili senza ricorsione si i costrutti descrivibili senza ricorsione si

assegnano all’analisi lessicale;assegnano all’analisi lessicale; quelli sostanzialmente ricorsivi a quella quelli sostanzialmente ricorsivi a quella

sintattica.sintattica.

2222

Sintassi formale dei linguaggi Sintassi formale dei linguaggi di programmazione di programmazione

La si specifica tramite: La si specifica tramite: diagrammi sintattici; diagrammi sintattici; equazioni BNF EBNF;equazioni BNF EBNF; grammatiche non contestuali (context grammatiche non contestuali (context

free)free)

Sono tutte forme sostanzialmente Sono tutte forme sostanzialmente equivalenti. equivalenti.

2323

Grammatiche CFG definizione Grammatiche CFG definizione formaleformale

AlfabetoAlfabeto: formalmente un alfabeto : formalmente un alfabeto TT ( () e’ un ) e’ un insieme finito non vuoto. Gli elementi di T (insieme finito non vuoto. Gli elementi di T () ) vengono chiamati vengono chiamati simbolisimboli o o carattericaratteri. . Useremo le lettere Useremo le lettere V, T, N, V, T, N, per indicare per indicare alfabeti alfabeti

ParolaParola: una parola, di lunghezza : una parola, di lunghezza kk00, su un , su un alfabeto alfabeto TT, e’ una sequenza finita , e’ una sequenza finita w=xw=x11xx22…x…xk k

di elementi di di elementi di TT. . kk, denotata anche , denotata anche k=|w|k=|w| e’ e’ detta lunghezza di detta lunghezza di ww. La parola di lunghezza . La parola di lunghezza zerozero, detta , detta parola vuotaparola vuota, e’ indicata , e’ indicata ..

2424

Grammatiche CFG definizione Grammatiche CFG definizione formaleformale

L’ insieme delle parole su T viene indicato L’ insieme delle parole su T viene indicato T* T* Monoide libero:Monoide libero: T*T* e’ strutturato in e’ strutturato in monoide dall’operazione di monoide dall’operazione di concatenazione di parole. Date concatenazione di parole. Date ww11,w,w22TT, , con con ww11= x= x11xx22…x…xkk,w,w22= y= y11yy22…y…yll, la parola , la parola w= ww= w11.w.w22= x= x11xx22…x…xkkyy11yy22…y…yll, di lunghezza , di lunghezza k+lk+l, e’ detta concatenazione di , e’ detta concatenazione di ww11 e e ww22. .

Il monoide Il monoide (T*,.)(T*,.) e’ detto e’ detto monoide liberomonoide libero su su TT..

2525

Grammatiche CFG definizione Grammatiche CFG definizione formaleformale

In particolareIn particolare: l’operazione di concatenazione di : l’operazione di concatenazione di parole struttura l’insieme T* in monoide detto parole struttura l’insieme T* in monoide detto monoide libero su T (w.monoide libero su T (w.==.w=w). .w=w).

Grammatica CFGGrammatica CFG: formalmente e’ una : formalmente e’ una quadrupla quadrupla G=(N,T,P,S)G=(N,T,P,S) con con NNT=T= e dove: e dove:

TT e’ un alfabeto detto dei simboli terminali di e’ un alfabeto detto dei simboli terminali di GG

NN e’ un alfabeto detto dei non terminali di e’ un alfabeto detto dei non terminali di GG PP e’ un insieme finito di produzioni di e’ un insieme finito di produzioni di GG SSNN e’ detto simbolo iniziale di e’ detto simbolo iniziale di GG

2626

Grammatiche CFG definizione Grammatiche CFG definizione formaleformale

Ogni produzioneOgni produzione NNV*V*

NotazioneNotazione: : a,b,c,d,..a,b,c,d,.. Indicano elementi di Indicano elementi di TT A,B,C,…A,B,C,… indicano elementi di indicano elementi di NN U,V,X,Y,ZU,V,X,Y,Z indicano elementi di indicano elementi di V=TV=TNN u,v,x,y,zu,v,x,y,z indicano elementi di indicano elementi di T*T* ,,,,,…,,…, indicano elementi di indicano elementi di V*V* =(A,=(A,))NNV*V* e’ indicata da e’ indicata da AA

2727

Forme SentenzialiForme Sentenziali

Forma sentenzialeForma sentenziale: data : data G=(N,T,P,S)G=(N,T,P,S) una una forma sentenziale di forma sentenziale di GG e’ definita e’ definita ricorsivamente:ricorsivamente:

SS e’ una forma sentenziale di e’ una forma sentenziale di GG se se AA e’ una forma sentenziale di e’ una forma sentenziale di GG e e

AA e’ una produzione di e’ una produzione di GG allora allora e’ e’ una forma sentenziale di una forma sentenziale di GG. .

La relazione tra La relazione tra AA e e al precedente al precedente punto 2 viene indicata:punto 2 viene indicata:

AA

2828

Derivazioni dirette e non Derivazioni dirette e non

Derivazione direttaDerivazione diretta: : AA esprime che esprime che deriva direttamente da deriva direttamente da AA o che o che AA genera direttamente genera direttamente . .

Le notazioni Le notazioni * * + + indicano rispettivamente la indicano rispettivamente la chiusura transitiva-riflessiva e transitiva di chiusura transitiva-riflessiva e transitiva di

* * denota che denota che == o o ii i=1,n i=1,n

==11 22 … … nn = = e e n>0n>0, mentre, mentre + denota che denota che =1 2 … n = e e

n>0n>0..

2929

Linguaggio generato da una Linguaggio generato da una grammatica: linguaggi CFG grammatica: linguaggi CFG

Linguaggio generato da G: Linguaggio generato da G:

L(G)=L(G)=wwT*| S T*| S * w* w

Un linguaggio Un linguaggio L L T*T* e’ libero da contesto e’ libero da contesto se esiste se esiste G=(N,T,P,S) CFGG=(N,T,P,S) CFG tale che tale che L=L(G)L=L(G)

3030

Derivazioni canoniche, parsing Derivazioni canoniche, parsing tree, ambiguita’ tree, ambiguita’

Una derivazione Una derivazione * e’ detta e’ detta canonica canonica destradestra, indicata , indicata rm

* se per ogni i si ha se per ogni i si ha ii==iiAAiixxii, , i+1i+1==iiiixxii, , Ai i, , =1 2 … n = i=1,…,n

Una derivazione Una derivazione * e’ detta e’ detta canonica canonica sinistrasinistra, indicata , indicata lm

* se per ogni se per ogni i i si si ha ha ii=x=xiiAAi i ii, , i+1=xii i, Ai i, =1 2 … n = i=1,…,n

3131

Esempio Esempio

Sia G=({E,T,P},{(,),a,b,c,*,+,-},P,E) doveSia G=({E,T,P},{(,),a,b,c,*,+,-},P,E) doveP={EP={EE+T|E-T|T, T E+T|E-T|T, T T*P|P, P T*P|P, P (E)|a|b} (E)|a|b}NotazioneNotazione: E: EE+T|E-T|T, T E+T|E-T|T, T T*P|P e P T*P|P e P (E)|a|b (E)|a|b

abbreviano le produzioniabbreviano le produzioni E E E+T, E E+T, E E-T, E E-T, E T, T T, T T*P, T T*P, T P, P P, P (E), P (E), P

a, P a, P b, P b, P c}c}La derivazioneLa derivazione

EE 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

e’ e’ canonica sinistracanonica sinistra, ,

3232

Esempio Esempio Sia G=({E,T,P},{(,),a,b,c,*,+,-},P,E) doveSia G=({E,T,P},{(,),a,b,c,*,+,-},P,E) doveP={EP={EE+T|E-T|T, T E+T|E-T|T, T T*P|P, P T*P|P, P (E)|a|b} (E)|a|b}Mentre la derivazione:Mentre la derivazione:

EE 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’ e’ canonica destracanonica destra, Confrontandola con la , Confrontandola con la sinistrasinistra: : EE 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 Si vede che differiscono solo per l’ordine di applicazione delle produzioni. delle produzioni. Entrambe applicano le stesse Entrambe applicano le stesse produzioni alle stesse istanze di non terminaliproduzioni alle stesse istanze di non terminali

3333

Parsing Tree Parsing Tree

Tutte le derivazioni che differiscono solo Tutte le derivazioni che differiscono solo per l’ordine di applicazione delle per l’ordine di applicazione delle produzioni sono sostanzialmente produzioni sono sostanzialmente equivalenti e possono essere equivalenti e possono essere rappresentate da un’unica derivzione rappresentate da un’unica derivzione canonica destra, un’ unica derivazione canonica destra, un’ unica derivazione canonica sinistra o da un unico albero canonica sinistra o da un unico albero etichettato detto etichettato detto Parsing TreeParsing Tree definito definito come segue:come segue:

3434

Parsing Tree Parsing Tree

La radice e’ etichettata da S Ogni nodo terminale dell’albero e’

etichettato da o da un simbolo di T (terminale)

Ogni nodo interno e’ etichettato da un simbolo di N (non terminale)

Se A etichetta un nodo interno e X1,X2,…, Xn sono le etichette dei figli, allora AX1X2…Xn

3535

Esempio di Parsing Tree e Esempio di Parsing Tree e deriv. canonica associataderiv. canonica associata

EE 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

3636

Esempio di Parsing Tree Esempio di Parsing Tree

EE 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

3737

Esempio di Parsing Tree Esempio di Parsing Tree

Ambiguita’Ambiguita’ Una grammatica G e’ ambigua se esiste wUna grammatica G e’ ambigua se esiste wL(G) con due L(G) con due

parsing tree diversi (con due derivazioni canoniche parsing tree diversi (con due derivazioni canoniche destre o sinistre distinte).destre o sinistre distinte).

Un linguaggio e’ inerentemente ambiguo se per ogni G Un linguaggio e’ inerentemente ambiguo se per ogni G tale che L=L(G) si ha che G e’ ambigua. tale che L=L(G) si ha che G e’ ambigua.

3838

Esempio di GRM G ambigua Esempio di GRM G ambigua

S S if b then S | if b then S else S| s if b then S | if b then S else S| s G=({S},{if,then,else,s}, P={S G=({S},{if,then,else,s}, P={S if b then S | if b then S if b then S | if b then S

else S|s}, S)else S|s}, S)

SSrmrm if b then if b then SS rmrm if b then if b then if b then S else if b then S else S S rmrm if b then if b then if b then if b then SS else else s s rmrm if b then if b then if b then if b then s s else selse s

S S rmrm if b then if b then SS else else S S rmrm if b thenif b then SS else else s s rmrm if b then if b then if if b thenb then SS else else ss rmrm if b then if b then if b then if b then ss else s else s

Grammatica equivalente non ambigua (due non terminali)Grammatica equivalente non ambigua (due non terminali)

SSSS11 SS11if b then Sif b then S11 | if b then S | if b then S22 else S else S11| s | s SS22if b then Sif b then S22 else S else S11| s | s

3939

Esempio di G ambigue e non con Esempio di G ambigue e non con proprieta’ opportune proprieta’ opportune

Di seguito si mostrano solo le produzioniDi seguito si mostrano solo le produzioni Grammatica di espressioniGrammatica di espressioni non ambiguanon ambigua con con

priorita’ di operatori e associativita’priorita’ di operatori e associativita’ cablatecablateEEE+T | E-T | TE+T | E-T | TTTT*F | T/F | F T*F | T/F | F FFP^F | PP^F | PP P (E) | I | N(E) | I | NI I a|b|c|d a|b|c|dN N 0 | 1 | 2 0 | 1 | 2G G per espressioni, semplice maper espressioni, semplice ma ambiguaambiguaEEEOE|(E)|a|b|c|dEOE|(E)|a|b|c|dOO+|-|*|^ +|-|*|^

4040

Altri esempi di grammaticheAltri esempi di grammatiche

Di seguito si presentano solo le produzioniDi seguito si presentano solo le produzioni Grammatica GGrammatica G00 di espressioni non ambigua con di espressioni non ambigua con

priorita’ di operatori e associativita’ priorita’ di operatori e associativita’ cablatecablateEEE+T | E-T | TE+T | E-T | T|-T|+T|-T|+TTTT*F | T/F | F T*F | T/F | F F F (E) | I | N(E) | I | NI I a|b|c|d a|b|c|dN N 0 | 1 | 2 0 | 1 | 2GG11 per espressioni, semplice, non ambigua ma per espressioni, semplice, non ambigua ma flatflatEEEOT|TEOT|T|-T|+T|-T|+TT T (E)|a|b|c|d|0|1|2(E)|a|b|c|d|0|1|2OO+|-|*|/ +|-|*|/

4141

Due derivazioni canoniche di G0 e Due derivazioni canoniche di G0 e G1 G1

DataData a-b*c a-b*c abbiamoabbiamoGG00: : EErmrmE-E-TT rmrmE-E-T*T*FF rmrmE-T*E-T*II rmrmE-E-TT**c c rmrmE-E-

FF*c *c rmrmE-E-II*c *c rmrmEE--bb*c*c rmrmTT-b*c -b*c rm rm FF-b*c-b*c rmrmII-b*c -b*c rmrmaa-b*c -b*c

GG11: : EErmrmEOEOTT rmrmEEOOc c rmrmEE**cc rmrmEOEOTT*c *c rm rm EE--bb*c*c rmrmTT-b*c -b*c rmrmaa-b*c-b*c

Esercizio: studiareEsercizio: studiare G G22 EEFOT|T ; FOT|T ; F F FOTFOT|T||T| ;; T T (E)|a|b|c|d|0|1|2 ;(E)|a|b|c|d|0|1|2 ;OO+|-|*|^ +|-|*|^

4242

I relativi parse tree (GI relativi parse tree (G00) )

EEEE -- TTTT T*F T*FFF F I F III I c I c

aa b bGG00: : EErmrmE-E-TT rmrmE-E-T*T*FF rmrmE-T*E-T*II rmrmE-E-TT**c c rmrmE-E-

FF*c *c rmrmE-E-II*c *c rmrmEE--bb*c*c rmrmTT-b*c -b*c rm rm FF-b*c-b*c rmrmII-b*c -b*c rmrmaa-b*c-b*c

4343

I relativi parse tree (GI relativi parse tree (G11) )

EEEE OO TT

E O TE O T ** cc T - bT - b a a

GG11: : EErmrmEOEOTT rmrmEEOOc c rmrmEE**cc rmrmEOEOTT*c *c rm rm

EE--bb*c*c rmrmTT-b*c -b*c rmrmaa-b*c-b*c

4444

Operazioni sui Linguaggi Operazioni sui Linguaggi Dati due linguaggi L,MDati due linguaggi L,MT* definiamo T* definiamo

prodotto di L ed M indicato LM o Lprodotto di L ed M indicato LM o LM M l’insieme l’insieme

LLM ={uv|uM ={uv|uL&vL&vM} M} Definiamo chiusura di Kleene di L, indicata Definiamo chiusura di Kleene di L, indicata

L* l’operazione:L* l’operazione:LL00={={}}LL11=L=LLLii=L=LLLi-1i-1 i>0 i>0L*=L*=ii00 L Lii

LL++==i>0i>0 L Lii

4545

Esempio di G ambigue e non con Esempio di G ambigue e non con proprieta’ opportune proprieta’ opportune

Proprieta’: supponiamo T terminale e Proprieta’: supponiamo T terminale e vediamo le produzioni di Evediamo le produzioni di E

GG00=({E},{t,+,-},P0,E)=({E},{t,+,-},P0,E)PP00={E={EE+t | E-t | tE+t | E-t | t|-t|+t}|-t|+t}L(GL(G00)={-t,+t,t}({+,-}t)*)={-t,+t,t}({+,-}t)*eeGG11=({E,O},{t,+,-},P1,E)=({E,O},{t,+,-},P1,E)PP11={E={EEOt|tEOt|t|-t|+t,|-t|+t,OO+|-}+|-}OO+|- +|- L(GL(G11)=L(G)=L(G00))

4646

Un esempio di LNG inerentemente Un esempio di LNG inerentemente ambiguo e uno di LNG non CFL ambiguo e uno di LNG non CFL

L={aL={aiibbjjcckk| i=j OR j=k; i,j,k| i=j OR j=k; i,j,k0} 0}

SSSS11SS22 | S | S33SS44

SS11aSaS11b |b | S S22 S S22 c| c| SS44bSbS44c |c | S S33 S S33 a| a|

L={aL={annbbnnccnn| n>(| n>() 0} non e’ un CFL ) 0} non e’ un CFL

4747

Syntax Tree (albero sintattico) e Syntax Tree (albero sintattico) e Parsing Tree Parsing Tree

Albero SintatticoAlbero Sintattico Una delle rappresentazioni intermedie piu’ usate. Piu’ astratto del parsing Una delle rappresentazioni intermedie piu’ usate. Piu’ astratto del parsing

tree,tree,

dipende solo dal linguaggio (non dalla grammatica)dipende solo dal linguaggio (non dalla grammatica)

4848

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

4949

EBNF Esempio (Espressioni) EBNF Esempio (Espressioni)

Expression = SimpleExpression [ Relation Expression = SimpleExpression [ Relation SimpleExpression ].SimpleExpression ].

Relation = "=" | "<>" | "<" | "<=" | ">" | ">=" | IN.Relation = "=" | "<>" | "<" | "<=" | ">" | ">=" | IN.

SimpleExpression = [ "+" | "-" ] Term { AddOperator SimpleExpression = [ "+" | "-" ] Term { AddOperator Term }.Term }.

AddOperator = "+" | "-" | OR.AddOperator = "+" | "-" | OR.

Term = Factor { MulOperator Factor }.Term = Factor { MulOperator Factor }.

MulOperator = "*" | "/" | DIV | MOD | ANDMulOperator = "*" | "/" | DIV | MOD | AND

5050

EBNF Espressioni (cont.) EBNF Espressioni (cont.) Designator [ ActualParameters ] | "(" Expression ")" | NOT Factor.Designator [ ActualParameters ] | "(" Expression ")" | NOT Factor.

Set = "[" [ Element { "," Element } ] "]".Set = "[" [ Element { "," Element } ] "]".

Element = OrdinalConstant [ ".." OrdinalConstant].Element = OrdinalConstant [ ".." OrdinalConstant].

OrdinalConstant= Char | Integer.OrdinalConstant= Char | Integer.

ActualParameters = ["(" [ ExpressionList ] ")"].ActualParameters = ["(" [ ExpressionList ] ")"].

Ident = IdChar { IdChar | Digit }.Ident = IdChar { IdChar | Digit }.

IdChar = Letter | "_".IdChar = Letter | "_".

Number = Integer | Real.Number = Integer | Real.

5151

EBNF Espressioni (cont. 2) EBNF Espressioni (cont. 2) Integer = Digit { Digit } | Digit { HexDigit } "H".Integer = Digit { Digit } | Digit { HexDigit } "H".

Real = Digit { Digit } "." { Digit } [ ScaleFactor ].Real = Digit { Digit } "." { Digit } [ ScaleFactor ].

ScaleFactor = "E" [ "+" | "-" ] Digit { Digit }.ScaleFactor = "E" [ "+" | "-" ] Digit { Digit }.

HexDigit = Digit | "A" | "B" | "C" | "D" | "E" | "F".HexDigit = Digit | "A" | "B" | "C" | "D" | "E" | "F".

Digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9".Digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9".

CharConstant = "'" Char "'" | Digit { HexDigit } "X".CharConstant = "'" Char "'" | Digit { HexDigit } "X".

String = ' { CharN | "''" } '.String = ' { CharN | "''" } '.

Char = CharN | "'".Char = CharN | "'".