Analisi lessicale. Scopi Tecniche Strumenti - Lex. Introduzione ai compilatori - UNINA 1

Transcript

1 Analisi lessicale Scopi Tecniche Strumenti - Lex Introduzione ai compilatori - UNINA 1

2 L analizzatore lessicale nel compilatore Linguaggio sorgente Analizzatore lessicale token Next token Analizzatore sintattico Symbol table Introduzione ai compilatori - UNINA 2

3 Tokens Token=set di stringhe (terminali del linguaggio sorgente) es.: if, identificatore, op_rel pattern=regole per la costruzione dei token if=if; identificatore=lettera seguita da cifre o lettere; op_rel= <, >, >=, <= l analizzatore lessicale produce lo stesso output per i token che soddisfano un dato pattern lexeme=una stringa (token) che verifica i requisiti di un pattern (es IF, P123, <) Parole riservate: le keywords possono essere o meno utilizzabili dall utente anche per altri scopi (es. identificatori) Introduzione ai compilatori - UNINA 3

4 Attributi dei token Nell analisi lessicale ai token vengono spesso associate proprietà utili per le successive fasi di analisi, es.: <if, > valore superfluo <op_rel, < > <identificatore, rif. a una entry in symbol table> <numero, valore > Introduzione ai compilatori - UNINA 4

5 Analisi lessicale ed automi Gli automi finiti trovano applicazione nell analisi lessicale Sviluppo diretto degli analizzatori lessicali Tool per la generazione automatica di analizzatori lessicali (Lex) Strumenti di elaborazione di testi (es.: AWK, grep, ecc) riconoscimento espressioni regolari Introduzione ai compilatori - UNINA 5

6 Automa finito deterministico - DFA S, Σ, δ, q 0, F Insieme di stati S q 1 q 2 Insieme di simboli Σ (alfabeto di input) a,b,c Funzione di transizione o di stato δ: associa alle coppie stato simbolo uno stato δ: Σ x S S q 1 a q 2 q 0 è uno stato particolare detto lo stato iniziale F è un insieme di stati detti stati finali (o di accettazione). q Funzione di stato su una stringa x δ (q,ε) = q per ogni q in Q ; δ (q,xa)= δ(δ (q,x),a) δ (q,x) = stato in cui si trova l automa dopo aver letto tutti caratteri di x. Linguaggio accettato dall automa: L={x Σ + : δ (q 0,x) F } Introduzione ai compilatori - UNINA 6

7 Rappresentazione DFA con diagrammi di transizione Automa che riconosce stringhe con numero pari di 0 ed 1 1 q 0 1 q q 3 1 q 2 Introduzione ai compilatori - UNINA 7

8 Funzione di transizione/tabella di 0 1 transizione q 0 q 3 q 1 q 1 q 2 q 0 1 q 0 1 q q 2 q 1 q 3 q 3 1 q 2 q 3 q 0 q 2 Introduzione ai compilatori - UNINA 8

9 Algoritmo generale DFA s:=s0 c:=nextchar(); while (c!=eof) { s:=delta(s,c); c:=nextchar(); } if (s è stato finale) return Si else return No Introduzione ai compilatori - UNINA 9

10 Esempi automi finiti Automa che accetta le stringhe che contengono esattamente tre ,1 q 0 0 q 1 0 q 2 0 q 3 0 q 4 Automa che riconosce gli operatori relazionali q 0 < = q 1 = > q 2 > q 5 altro q 3 q 6 = q 7 q 4 altro q 8 Introduzione ai compilatori - UNINA 10

11 Implementazione di una tabella di transizione token nextoken() { while (1) switch (state) { case 0: c=nextchar(); if (c== c== \t c= \n ) { state=0; lexeme_beginning++; } else if (c == < ) state = 1; else if (c == = ) state = 5; else if (c == > ) state = 6; else state = fail(); break; case 1: c=nextchar(); if (c== = ) state = 2; /* LE */ else if (c == >0) state = 3; else state = 4; break; case 2: lval=le; retun(relop); break; case 3: lval=ne; retun(relop); break; case 4: retract(1); lval=eq; return (RELOP);. Introduzione ai compilatori - UNINA 11

12 Automi finiti non deterministici - NFA Automi con epsilon transizioni (possono cambiare stato spontaneamente senza leggere alcun carattere) Q è l insieme di stati Σ è un insieme di simboli (alfabeto di input) δ è la funzione d transizione o di stato dell automa ed associa alle coppie stato simbolo (o stringa vuota) un sotto insieme di stati (anche vuoto) δ: (Σ U ε)x Q 2 S. Non è univoca q 1 a q 2 Q, Σ, δ, q0, F q 1 q 2 q 0 è lo stato iniziale F è l insieme di stati detti stati finali (o di accettazione). Motivazione agli automi indeterministici: facilitano la descrizione degli algoritmi di riconoscimento e la corrispondenza con le grammatiche Introduzione ai compilatori - UNINA 12

13 Esempio di NFA Esempio automa che accetta sequenze qualsiasi di 0,1, ε ε q 0 q 1 q 2 La ε chiusura di uno stato è l insieme di tutti gli stati raggiungibili tramite solo ε transizioni dallo stato. ε-chiusura(q 0 )={ q 1, q 2 } e ε-chiusura(q 1 )= {q 2 } Introduzione ai compilatori - UNINA 13

14 Linguaggio accettato da un NFA Se P è un insiemi di stati, la ε-chiusura di P è l unione degli insiemi ε-chiusura(p) per ogni p P Funzione di transizione su stringhe: δ (q,ε) = ε-chiusura(q) δ (q,xa)= ε-chiusura ( p : r δ (q,x) e p δ (r,a) ) Insieme di tutti gli stati raggiungibili per cui esiste un percorso etichettato da un solo a e da qualsiasi numero di ε Il linguaggio accettato dall automa: L={x Σ* : δ (q 0,x) F } Introduzione ai compilatori - UNINA 14

15 Automi finiti non deterministici con indeterminazioni In corrispondenza di un dato simbolo l automa può scegliere di passare in più do uno stato. δ: Σ Q 2 S Es.: Automa che riconosce le stringhe tipo (a b)*abb a q 0 a q 1 b q 2 b q 3 b La funzione di transizione è definita da: δ (q,a) = δ (q,a) q per ogni q Q e a Σ δ (q,xa)= { p : r δ (q,x) e p δ (r,a)} (insiemi di stati) Il linguaggio accettato da un automa è: L={x Σ* : δ (q 0,x) F } 15

16 Equivalenza tra DFA e NFA Gli NFA sono utili per realizzare gli algoritmi di riconoscimento E sempre possibile passare da un automa non deterministico ad uno deterministico equivalente Introduzione ai compilatori - UNINA 16

17 Eliminazione delle ε-transizioni NFA=(Q, Σ, δ, q 0, F) è un automa finito con ε-transizioni non deterministico NFA =(Q, Σ, δ, q 0, F ) equivalente senza ε-transizioni (con indeterminazioni) F = F U {q 0 } se e-chiusura(q 0 ) contiene uno stato finale, F =F altrimenti; δ (q,a)= δ (q,a) NFA 0 a ε ε b ε d c (a+b)cd* 4 d NFA d a,b Introduzione ai compilatori - UNINA d b d 2 4 d d d 3 d c

18 Eliminazioni delle indeterminazioni subset construction Per eliminare le indeterminazioni da un automa finito, bisogna aumentare il numero degli stati. NFA=(Q, Σ, δ, q 0, F) è un automa finito con indeterminazioni, N =(Q, Σ, δ', q 0, F ) il corrispondente DFA equivalente Q =2 Q è l insieme dei sotto-insiemi di Q F è dato dagli stati di Q i cui insiemi contengono almeno un stato finale di Q: F ={p Q : p F } q 0 ={ q 0 } δ' (p,a)=r, con r={s : s δ (q,a) e q p } si possono escludere gli stati irrangiungibili ESEMPIO Introduzione ai compilatori - UNINA 18

19 {0,1},{0,1,2} non sono raggiungibili d NFA 1 a,b c 0 d b d 2 4 d d d d 3 d DFA {1} a,b c {0} a,b {4} d {0,2,3,4} d Introduzione ai compilatori - UNINA 19

20 Algoritmo per passare da un NFA ad un DFA equivalente Dato un NFA con ε transizioni (Q, Σ, δ, q 0, F), costruzione della tabella di transizione di un automa DFA equivalente (Q, Σ, δ, q 0, F ). Al massimo Q =2 Q Idea: ad ogni stato di DFA corrisponde un insieme di stati di NFA: DFA tiene conto dei possibili stati che raggiunge NFA leggendo la stessa stringa input. begin end Q ={ q 0 }=ε -chiusura(q 0 ) non marcato (ES.: STACK) while esiste uno stato t non marcato in Q do begin end marcare t per ogni simbolo a di input do begin end u = ε-chiusura(m(t,a)) /* M(T,A)=insieme di tutti gli stati raggiungibili con a dagli stati di t per NFA) */ se u non è in Q porlo in Q non marcato porre δ (t,a)=u Introduzione ai compilatori - UNINA 20

21 Esempio NFA che riconosce (a b)*abb ε ε ε q 2 a q 3 ε ε a q 0 q 1 ε q 6 q 7 q 8 q 4 b q 5 ε b q 9 b ε q 10 Introduzione ai compilatori - UNINA 21

22 1) q 0 = ε -chiusura(q 0 )={ q 0, q 1, q 2, q 4, q 7 } 2) Si ha M{ q 0, q 1, q 2, q 4, q 7 },a)={ q 3, q 8 } e ε -chiusura({ q 3, q 8 }) = { q 1, q 2, q 3, q 4, q 6, q 7, q 8 } Poniamo { q 1, q 2, q 3, q 4, q 6, q 7, q 8 } = q 1 e δ (q 0,,a)= q 1 3) M({ q 0, q 1, q 2, q 4, q 7 },b)={, q 5 } e ε -chiusura({q 5 }) = { q 1, q 2, q 4, q 5, q 6, q 7 } = q 2 Stati finali q 0 = { q0, q1, q2, q4, q7 } q 1 = { q1, q2, q3, q4, q6, q7, q8 } q 2 = { q1, q2, q4, q5, q6, q7 } q 3 = { q1, q2, q4, q5, q6, q7, q9} q 4 = { q1, q2, q4, q5, q6, q7, q10} la tabella di transizione è data da: a b q 0 q 1 q 2 q 1 q 1 q 3 q 2 q 1 q 2 q 3 q 1 q 4 q 4 q 1 q 2 Introduzione ai compilatori - UNINA 22

23 DFA finale (subset construction) b b q 2 b b q 0 a a b q 3 q 4 a a q 1 a Introduzione ai compilatori - UNINA 23

24 Espressioni regolari e automi NFA E sempre possibile costruire un automa NFA che riconosce una data espressione regolare - ε è una espressione regolare che denota {ε} - a è una espressione regolare che denota {a} (a Σ) Se r e s sono espressioni regolari che denotano L( r) e L(s): - r+s è una espr. reg che denota L(r) L(s) - rs L(r)L(s) - r* L(r) * - (r) L(r) Costruzione di Thompson per induzione sul numero di operatori presenti nella espressione regolare su linguaggio Σ. Introduzione ai compilatori - UNINA 24

25 1-2) Nel caso 0, è immediato costruire gli automi in grado di riconoscere epsilon o i simboli dell alfabeto della espressione regolare: q 0 ε q 1 q 0 a q 1 3) Nel caso di espressioni con più operatori, dato N(s) e N(t) gli automi che riconoscono le espressioni s e t, l automa che riconosce l espressione s+t è dato da: ε N(s) q 0 q f ε q 0 q f ε q N(t) 0 q f ε q 0 e q f sono risp. stati iniziali e finali di N(s) e q 0 e qf sono stati iniziali e finali di N(t). Introduzione ai compilatori - UNINA 25

26 4) Caso della concatenazione st l automa si costruisce: ε N(s) q 0 q f q N(t) 0 q f Lo stato iniziale dell automa composto è dato da q 0 mentre quello finale da qf 5) Caso della stella s* q 0 ε N(s) q 0 q f ε q f ε 6) Per le espressioni tra parentesi, si può usare N(s) stesso. Introduzione ai compilatori - UNINA 26

27 Costruzione dell automa riconoscitore Si effettua il parsing della espressione regolare, quindi si costruiscono gli stati dell automa applicando i passi 1) e 2) ai simboli dell espressione, quindi i passi 3) e 6) applicandoli secondo precedenza. Gli stati iniziali e finali degli automi intermedi vanno a costituire stadi intermedi dell automa finale. Introduzione ai compilatori - UNINA 27

28 Ottimizzazione del DFA Lemma di Nerode: Dato un linguaggio L def. la relazione di equivalenza R L nel seguente modo: x R L y se e solo se per ogni z sia xz che yz appartengono ad L, oppure nessuna delle due. Il lemma di Nerode afferma che: L è un linguaggio riconosciuto da un automa finito se e solo se R L è di indice finito L indice della classe di equivalenza è il numero di classi di equivalenza La costruzione dell automa del Lemma di Nerode è l automa minimo Introduzione ai compilatori - UNINA 28

29 Costruzione dell automa minimo Algoritmo Input Un automa DFA M (Q,S, transizioni definite per ogni stato e per ogni carattere di input -eventualmente morte, F); Output un automa M equivalente a M con il minor numero di stati possibili 1)Costruzione di una partizione iniziale Π 0 di S in due gruppi : l'insieme degli stati finali e l insieme di tutti gli altri. 2)Suddivisione di ciascun gruppo della partizione in sotto gruppi che possono essere distinti da ogni stringa input (una stringa x distingue uno stato s da uno t se δ(x,s) F e δ(x,t) F o viceversa) 3) Il processo si itera fino a che è possibile La partizione finale sarà composta da gruppi di stati che non vengono distinti da nessuna stringa input. Introduzione ai compilatori - UNINA 29

30 Procedura di suddivisione: ciascun G gruppo della partizione Π corrente viene suddiviso in sottogruppi in modo che due stati stanno nello stesso sottogruppo se e solo se, per ogni simbolo di input, portano ad uno stesso sottogruppo all interno della partizione. a a Π=(F),(Q-F) do { Πold= Π Π = procedura di suddivisione su Πold } while Πold<> Π Si eliminano gli stati morti e le transizioni che conducono ad esso. La funzione di transizione connette le coppie di stati risultanti della partizione come la funzione di transizione originaria connette qualsiasi coppia di stati rappresentativi delle partizioni. La funzione è consistente perché la scelta degli stati rappresentativi è ininfluente Introduzione ai compilatori - UNINA 30

31 Quadro riassuntivo DFA/NFA/Linguaggi regolari DFA /DFA minimo. Algoritmi di riconoscimento Linguaggi regolari E sempre possibile ottenere un DFA equivalente ad un dato NFA NFA con indeterminazioniε transizioni E sempre possibile ottenere un DFA in grado di riconoscere il linguaggio denotato da un ER Espressioni regolari E sempre possibile ottenere un NFA che riconosce il linguaggio denotato da una espressione regolare Introduzione ai compilatori - UNINA 31

32 Limiti delle espressioni regolari Le espressioni regolari non sufficienti a denotare alcuni linguaggi (CF) le parentesi bilanciate le stringhe ripetute: {wcw : w {a,b}*} Pumping Lemma L è un linguaggio regolare. Esiste una costante n tale che se z L, e z n si può scrivere z=uvw in modo che uv n e v 1 e che per ogni i 0 si ha che uv i w appartiene a L. Inoltre n è minore o uguale al più piccolo automa che accetta L. Introduzione ai compilatori - UNINA 32

33 Applicazioni Lex (costruzione diretta DFA) comandi UNIX: grep (subset construction) fgrep, egrep, diff AWK, linguaggi interrogazioni basi dati Introduzione ai compilatori - UNINA 33

34 Lex - struttura progetto dichiarazioni %% regole di transizione %% procedure ausiliarie Espressioni regolari LEX Analizzatore lessicale Introduzione ai compilatori - UNINA 34

35 Espressioni regolari in Lex 1 -Operatori: \ [ ] ^ -?. * + ( ) $ / { } % < > -Lettere e numeri del testo di ingresso sono descritti mediante se stessi: l espressione regolare ciao rappresenta la sequenza c i a o - I caratteri non alfabetici vengono rappresentati racchiudendoli tra doppi apici, per evitare ambiguità con gli operatori, oppure facendoli precedere da \: l espressione a ++ b rappresenta la sequenza a + b -Classi di caratteri operatori [], segno di intervallo -: [ ], [0-9]rappresentano una cifra nel testo di ingresso. - Per includere il carattere - in una classe di caratteri, deve essere specificato come primo o ultimo della serie:l espressione [-+0-9] rappresenta una cifra o un segno - - segno di esclusione ^ posto all inizio indica una gamma di caratteri da escludere: l espressione [^0-9] qualunque carattere che non sia una cifra Introduzione ai compilatori - UNINA 35

36 Espressioni regolari in Lex 2 -Operatori: (si riferiscono alla espressione che li precede)? espressione opzionale:.ab?c indica ac che abc. * espressione può essere ripetuta 0 o più volte:.ab*c + espressione può essere ripetuta 1 o più volte:.ab+c alternativa tra due espressioni:.ab cd indica sia ab che cd. ( ) Le parentesi tonde > priorità tra operatori: (ab cd+)?ef -- ef, abef, cdddef. / Operatore lookahead (caratteri di prospezione) r/s match r solo se seguita da s (s non è parte del match). Esprime la dipendenza dal contesto destro. Qualsiasi carattere che non sia \n: è equivalente a [^\n] Introduzione ai compilatori - UNINA 36

37 Parte regole (2) - Azioni di riconoscimento in Lex -Ad ogni espressione regolare è associabile in Lex un azione che viene eseguita all atto del riconoscimento (istruzioni in codice c, { }). Azione nulla - carattere ;. Output del riconoscitore.il testo riconosciuto viene conservato nella variabile yytext,(char *)..Il numero di caratteri riconosciuti viene memorizzato nella variabile yyleng, (int). Il testo non descritto da nessuna espressione regolare viene ricopiato in uscita, carattere per carattere. Introduzione ai compilatori - UNINA 37

38 Parte definizione (1) e procedure (3) Lex Nella parte definizione si possono definire sotto-espressioni: IDENTIFICATORE espr.regolare Ogni riga della sez. definizione il cui primo carattere non è è una definizione, es.: : number [+ -]?[0-9]+ identif [a-za-z][a-za-z0-9]* La sotto-espressione così definita può essere utilizzata racchiudendone il nome tra parentesi graffe: {number} printf( trovato numero\n ); Le righe che iniziano con spazio o tabulazione e tutti i caratteri compresi tra i delimitatori %{ e %} sono ricopiati nel file C La sezione procedure del programma sorgente sono ricopiate nel file C Introduzione ai compilatori - UNINA 38

39 Esempio riconoscimento operatori relazionali e identificatori %{ //== DEFINIZIONI c delle costanti #define LT 1 #define GT 2 %} delim [ \t\n] blanks {delim}+ letter [A-Za-z] digit [0-9] id {letter}({letter} {digit})* number {digit}+(\.{digit}+)?(e[+\-]?{digit}+)? %% Introduzione ai compilatori - UNINA 39

40 ... {blanks} /* niente da fare */; if {return(if);} then {return(then);} else {return(else);} {id} {yylval = install_id(); return(id);} {number} {yylval = install_num(); return(number); } < {yylval = LT; return(relop); } <= {yylval = LE; return(relop); } = {yylval = EQ; return(relop); } <> {yylval = NE; return(relop); } > {yylval = GT; return(relop); } >= {yylval = GE; return(relop); }. { /* regola punto ignoro tutti gli altri casi */ %% install_id () {/* inserisce l identificatore (yylval) nella symbol table */}... Introduzione ai compilatori - UNINA 40

41 Funzionamento di Lex *) LEX scandisce l input fino a trovare il più lungo prefisso che verifica una espressione regolare, quindi attiva l azione corrispondente e restituisce il controllo (al parser). *) Nel caso in cui la stessa sequenza verifica più di una espressione regolare, viene eseguita l azione di quella dichiarata prima ES.: format %% for {return FOR_CMD;} format {return FORMAT_CMD;} [a-z]+ {return GENERIC_ID;} Introduzione ai compilatori - UNINA 41

42 Contesti nell analisi lessicale Può essere utile avere più insiemi di regole lessicali da applicare in casi diversi, a seconda del contesto sinistro (ciò che si è già letto prima) variabili flag. condizioni iniziali sulle regole o stati. più analizzatori lessicali ES: variabili flag Eliminazione commenti del tipo // int flag=0; %% // {flag=1; /* begin of comment */} \n {flag=0; /* \n terminates comment */} /* ignore blanks*/ \t /* and tabs */ \$[a-za-z]+[-+] { if(flag==1) process(yytext); else REJECT;}... other rules Introduzione ai compilatori - UNINA 42

43 Stati inclusivi in Lex Una regola in Lex puo essere preceduta dal nome (<stato1>,<stato2> ) di uno più stati, ed essere attivata solo quando l analizzatore si trova in uno degli stati indicati (stati inclusivi). Si entra in uno stato quando viene eseguita l azione BEGIN(state); Si esce eseguendo BEGIN(INITIAL) (INITIAL è lo stato di default) Gli stati vanno dichiarati nella parte delle dichiarazioni con %s <nome_stato> (oppure %start <nome_stato>) %s comment %% <comment>\$[a-za-z]+[-+] {process(yytext);} // {BEGIN(comment);} \n {BEGIN(INITIAL);} /* ignore blanks*/ \t /* and tabs */... other rules Introduzione ai compilatori - UNINA 43

44 Stati esclusivi in Lex È possibile identificare un insieme di regole in uno stato esclusivo. Quando l analizzatore si trova in uno stato esclusivo le regole di default risultano disabilitate sono attive solo le regole esplicitamente attivate nello stato. In tal modo è possibile specificare più analizzatori lessicali, ciascuno per stato esclusivo (elaborazioni di commenti, stringhe). %x <nome_stato> oppure %exclusive <nome_stato> Esempio: eliminazione dei commenti C Introduzione ai compilatori - UNINA 44

45 int line_num = 1; %x comment %% \n ++line_num; "/*" BEGIN(comment); <comment>[^*\n]* ; <comment>"*"+[^*/\n]* ; <comment>\n ++line_num; <comment>"*"+"/" BEGIN(INITIAL);... other rules Modifiche possibili: eliminazione di tutti i tipi di commenti, commenti annidati Introduzione ai compilatori - UNINA 45

46 Struttura file Lex generato Lex produce un programma C, l analizzatore lessicale è dato dalla funzione int yylex(). Input file yyin (default stdin); su file output yyout (default stdout) va il testo non riconosciuto. Se non specificato diversamente termina solo quando l intero file di ingresso è stato analizzato. Al termine di ogni azione l automa si ricolloca sullo stato iniziale Quando l analizzatore incontra la fine del file di ingresso, chiama la funzione yywrap() che serve a comunicare se ci sono altri file da analizzare (se restituisce 0, re-inizia l analisi da yyin) Introduzione ai compilatori - UNINA 46

47 Uso della funzione yywrap La funzione yywrap() può essere usata per stampare tabelle e statistiche. Per default, yywrap() restituisce sempre il valore 1 (un file alla volta). La regola speciale <<EOF>> introduce le azioni da intraprendere alla fine del file quando yywrap restituisce non-zero. ES.: Uso di EOF e di stati per intercettare delimitatori non bilanciati: \ { BEGIN(quote); }... <quote><<eof>> { error( EOF in string ); } Introduzione ai compilatori - UNINA 47

48 Lex - uso e parametri lex [opzioni] file.lex output lex.yy.c.-t copia il programma generato su stdout,.-v stampa una statistica circa il programma compilato,.-p stampa informazioni sulle performance dello scanner,.-ooutput genera il file output invece di lex.yy.c,.-b(-i) genera uno scanner Batch (Interattivo),.-f ottimizza le prestazioni dello scanner,.-i genera uno scanner case insensitive,.-d attiva i messaggi di debug nello scanner. Introduzione ai compilatori - UNINA 48

49 Esempio linguaggio pascal cifra [0-9] carattere identificatore numero stringa %% [A-Za-z] {carattere}({cifra} {carattere})* {cifra}+ [\"][A-Za-z0-9 \'!][\"] [Aa][Nn][Dd] { return AND; } [Oo][Rr] { return OR; } Introduzione ai compilatori - UNINA 49