Il lessico descrive le parole o elementi lessicali che compongono le frasi. Nei linguaggi artificiali gli elementi lessicali possono essere assegnati

Transcript

1 Il lessico descrive le parole o elementi lessicali che compongono le frasi. Nei linguaggi artificiali gli elementi lessicali possono essere assegnati alle seguenti classi: Parole chiave: sono particolari parole fisse che caratterizzano vari tipi di frasi o strutture. Ad es.: if, begin, subprogram, write. Le parole chiave sono indeclinabili. Delimitatori, operatori e caratteri compositi: come i precedenti sono delle parole fisse composte però di caratteri anche non alfabetici. Ad es. i commenti sono preceduti nel linguaggio Ada dai due trattini -- ; l operatore maggiore o eguale è scritto come >= ed in altri linguaggi come.gte., acronimo di greater or equal Classi lessicali aperte: queste comprendono un numero illimitato di elementi lessicali, che devono avere la struttura di un linguaggio regolare ossia a stati finiti. Sono esempi tipici di classi aperte i seguenti: nomi o identificatori di variabili, di sottoprogrammi, o in generale di varie entità del linguaggio; ad es. gli dentificatori di molti linguaggi sono definiti dalla espressione regolare: identificatore = lettera (lettera cifra)* costanti quali i numeri interi o reali o le stringhe alfanumeriche. 1

2 Vi è una importante differenza tra le parole chiave e le classi lessicali aperte: le prime non hanno altra informazione che il proprio nome. Invece tanto gli identificatori quanto le costanti denotano delle entità che hanno un valore o certe altre proprietà chiamate degli attributi semantici. Le classi lessicali sono solitamente delle stringhe appartenenti ad un linguaggio formale di tipo regolare pertanto riconoscibili dagli automi a stati finiti (o macchine sequenziali). L analizzatore lessicale (scanner) è un algoritmo che realizza la funzione di transizione di un automa finito. L analizzatore lessicale deve verificare se una sottostringa del testo sorgente corrisponde ad un elemento lessicale valido Tradurre la sottostringa in una opportuna codifica che faciliti la successiva elaborazione da parte del traduttore. La codifica deve contenere due informazioni: l identificativo della classe lessicale cui l elemento appartiene e l attributo semantico (nel caso ve ne sia uno associato a tale classe). Ad es. la stringa è riconosciuta come costante numerica reale e tradotta nella coppia ( costante_reale,valore_della_costante). 2

3 Token: unità lessicale restituita dall analizzatore lessicale e fornita come ingresso al parser (e.g., num, id, relop) Lessico: stringa di caratteri che rappresentano un particolare token Pattern - una descrizione del lessico che corrisponde al token Fornisce un modo per isolare le regole di basso livello dalle strutture che costituiscono la sintassi del linguaggio Suddividere la frase in ingresso in elementi lessicali (detti tokens ) da fornire al parser Eliminare gli spazi bianchi e i commenti Inserire i simboli nella tabella dei simboli Non esiste nessuna necessità di separare analisi lessicale da analisi sintattica se non la maggiore semplicità di gestione dei moduli in modo separato 3

4 L analizzatore lessicale legge il programma sorgente carattere per carattere e produce I tokens. Spesso un analizzatore lessicale non ritorna una lista di tokens, ma ritorna in token quando il parser richiede un token. source program Scanner token get next token Parser source program Scanner lista di token Parser 1. Keywords (e.g., IF) 2. Segni di punteggiatura (e.g., ;) 3. Operatori costituiti da caratteri singoli e multipli (e.g., =, ==, <=) 4. Identificatori 5. Numeri Interi Reali 6. Commenti 4

5 Il token rappresenta un insieme di stringhe descritte da un pattern. Identificatore representa un insieme di stringhe che iniziano con una lettera e continuano con lettere e cifre La stringa reale (newval) è chiamata lessico. Tokens: identificatore, numero, addop, delimeter, Dato che un token può corrispondere ad uno o più elementi lessicali altre informazioni possono essere aggiunte per specificarlo. Queste informazioni addizionali sono chiamati attributi. Implementativamente un token può avere un singolo attributo che ragruppa tutte le informazioni Per gli identificatori questo attributo e un puntatore alla tabella dei simboli, e la tabella dei simboli contiene I reali attributi del token x = indice + 2 TOKEN_ID(6) TOKEN_ASSEGN TOKEN_ID(5) TOKEN_SOMMA TOKEN_NUM(7) 5

6 Il risultato dell analisi lessicale è una sequenza di tokens dove un token è una 3-tuple: 1. Tipo del Token (id, keyword, etc.) 2. Attributo del token (può essere un valore o un puntatore alla tabella dei simboli) 3. Posizione del token [optional] Per esempio, la stringa 123 è il valore di un token il cui tipo è intero la stringa A1 è il valore di un token il cui tipo è identificatore Qualche volta il valore è ignorato, per esempio una keyword può essere completamente specificata dal suo tipo. 1. Realizzazione procedurale o a controllo di programma (hard-coded): un programma ad-hoc per la grammatica G 1. grammatica regolare programma ad hoc 2. Espressione regolare programma ad hoc 2. Realizzazione tabulare interpretata: una struttura dati rappresenta DFA riconoscitore della grammatica G e un programma indipendente dalla grammatica G 1. grammatica regolare DFA 2. Espressione regolare DFA 3. Automaticamente con uno SCANNER GENERATOR 6

7 Si scrive Espressione regolare Codice per l analisi del linguaggio una sequenza per ogni concatenazione un test per ogni unione un ciclo per ogni stella di kleen if (CurrentChar == c'){ read(currentchar) while(currentchar == c CurrentChar == 0 ) read(currentchar) return ok if (read(currentchar) == 0 ) return ok return errore 7

8 if (CurrentChar == '/'){ read(currentchar) if (CurrentChar == '/') do read(currentchar) while (!CurrentChar in {eol, eof) else //Signal lexical error else // Signal lexical error if (CurrentChar == eol) // Process valid token else //Signal lexical error Grammatica regolare Codice per l analisi della grammatica Si scrive una funzione per ogni non terminale Si scrive un test per ogni alternativa Si richiama la funzione per ogni nonterminale che compare in RHS 8

9 V = {S, A T = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9 P = { S 0 S 1 A 2 A 3 A 4 A 5 A 6 A 7 A 8 A 9A A 0 A 1 A 2 A 3 A 4 A 5 A 6 A 7 A 8 A 9A int S () { leggi(carattere) if (carattere == 0) { leggi(carattere) if (carattere == ) return OK return ERRORE else if (carattere == 1..9) return A rerturn ERRORE int A () {leggi(carattere) if (carattere == ) return OK if (carattere == 0..9) return A rerturn ERRORE 9

10 Espressione regolare Automa a stati finiti non deterministico Automa a stati finiti deterministico Implementazione di un DFA s s 0 { inizializzazione stato iniziale c nextchar {legge il successivo carattere while (c!= eol) do { do until la fine della stringa begin s move(s,c) { funzione di transizione c nextchar end if (s in F) then { se s è uno stato finale return yes else return no 10

11 Implementazione di un DFA State = StartState while (true){ if (CurrentChar == eof) break NextState = T[State][CurrentChar] if(nextstate == error) return errore State = NextState read(currentchar) if (State in F) return ok // token valido else return errore // errore lessicale La maggior parte di linguaggi utilizza reserved words (if, while, switch, etc). In tal caso lo scanner deve decidere se una sequenza di caratteri è un identificatore o una parola riservata. Questa distinzione è essenziale in quanto le parole riservate e identificatori hanno token differenti e vengono analizzate in modo diverso. Come può uno scanner decidere quali token sono identificatori quali parole riservate? Si puo procedere effettuando la scansione utilizzando il modello degli identificatori e poi cercare il token in una speciale tabella delle "parole riservate". E possibile definire gli identificatori come stringhe complementari delle espressioni regolari rappresentanti le parole riservate. Dato che gli scanner generetor di norma non favoriscono tale approccio. Si definiscone espressioni regolari per ogni parola riservata, e per gli identificatori. Dato che le definizioni si sovrappongono si definiscono delle priorita. Questo approccio è quello usualmente utilizzato. 11

12 Per alcuni tokens è necessario una forma numerica o binaria. Per esempio per gli interi è necessario trasformare una stringa di cifre in una rappresentazione interna (binaria) che rispetta la codifica. Sappiamo che il formato del token è valido (lo scanner verifica cio in modo preliminare), ma: La stringa può essere rapresentata utilizzando 32 o 64 bit. Cosa accade quando viene ragiunta la fine del file di input? Può essere creado pseudocarattere per EOF In Java, ad esempio, InputStream.read(), che legge un singolo byte, restituisce -1 quando viene raggiunta la fine file. Ciò carattere permette la definizione di un token EOF che può essere passatp al parser. Un token Eof è utile perché permette al parser di verificare che la fine logica di un programma corrisponde con la fine fisica. Molti parser richiedono l esistenza di un tale token. Gli scanner generator (Lex e Jlex) creano automaticamente un token Eof 12

13 Possiamo permettere agli automi di leggere oltre il successivo carattere di input. Questa caratteristica può essere necessaria in alcuni casi paeticolari Ad esempio questa caratteristica è necessaria in uno scanner per FORTRAN. DO 10 J = 1,100 specifica un loop. DO 10 J = è una istruzione di assegnazione. (attenzione i caratteri bianchi sono insignificanti e quindi il nome della variabile e DO10J) Lo scanner FORTRAN decide se la O è l utlimo cararrere del DO token solo dopo aver letto la virgola (o il punto). Ad esempio in PASCAL e possono essere distinti solo dopo il carattere successivo al secondo punto. Una sequenza di caratteri per la quale non esiste un token valido è un errore lessicale. Gli errori lessicali non sono comuni ma devono comunque essere gestiti dallo scanner. Non è opportuno bloccare il processo di compilazione per un tale errore. Gli approcci alla gestione degli errori lessicali sono: Cancellare i caratteri letti fino al momento dell errore e ricominciare le operazioni di scanning Eliminare il primo carattere letto dallo scanner e riprendere la scansione in corrispondenza del carattere successivo. Spesso un errore lessicale è causato dalla comparsa di qualche carattere illegale, soprattutto all'inizio di un token In questo caso i due approcci sono equivalenti 13

14 Lex/Flex/JLex Poiché la trasformazione di espressioni regolari in automi a stati finiti deterministici e la implementazione di questi ultimi sono processi meccanici (e noiosi), spesso si utilizza un generatore automatico di analizzatori lessicali. Lex è un noto generatore di scanner di Unix. Costruisce uno scanner in C da un insieme di espressioni regolari che definiscono i token. Flex è una versione più recente e più veloce di Lex. JLex è una versione Java di Lex. Si genera uno scanner Java (le espressioni regolari sono molto simili a quelle utilizzati da Lex e Flex). Lex, Flex e JLex sono in gran parte nonprocedurali Non c'è bisogno di dire come gli strumenti devono eseguire la scansione. Tutto ciò che serve è dire ciò che si vuole scandire dando la definizione dei token validi. Questo approccio semplifica notevolmente la costruzione di uno scanner, dal momento che la maggior parte dei dettagli di scansione (I/O, buffering,, ecc), sono gestiti automaticamente. 14

15 Lex è un generatore che accetta in ingresso un insieme di espressioni regolari e di azioni associate a ciascuna espressione e produce in uscita un programma che riconosce tali espressioni. Espressioni regolari LEX Programma C Lex produce un programma C, privo di main() il cui punto di accesso è dato dalla funzione int yylex(). Tale funzione legge dal file yyin e ricopia sul file yyout il testo non riconosciuto. Se non specificato diversamente nelle azioni (tramite l istruzione return), tale funzione termina solo quando l intero file di ingresso è stato analizzato. Al termine di ogni azione l automa si ricolloca sullo stato iniziale pronto a riconoscere nuovi simboli. Per default, i file yyin e yyout sono inizializzati rispettivamente a stdin e stdout. Il programmatore può alterare questa situazione re-inizializzando tali variabili globali. 15

16 Un file sorgente per lex è composto di tre sezioni distinte separate dal simbolo %%. La prima sezione contiene le definizioni e può essere vuota. La seconda sezione contiene le regole sotto forma di coppie espressione_regolare azione. Le azioni devono iniziare sulla stessa riga in cui termina l espressione regolare e ne sono separate tramite spazi o tabulazioni. La terza sezione contiene le procedure di cui il programmatore intende servirsi: se è vuota, il separatore %% viene omesso. Per semplificare la gestione di espressioni regolari complesse o ripetitive, è possibile definire identificatori che designano sotto-espressioni regolari. Ogni riga della prima sezione il cui primo carattere non sia di spaziatura è una definizione: numero [+-]?[0-9]+ La sotto-espressione così definita può essere utilizzata inserendo il nome tra parentesi graffe: {numero printf( trovato numero\n ); 16

17 Le righe che iniziano con spazio o tabulazione sono ricopiate identiche nel file di codice C generato dall esecuzione di Lex. Lo stesso avviene per tutti i caratteri compresi tra i delimitatori %{ e %. Tutte le righe presenti nella sezione delle procedure (la terza) del programma sorgente sono ricopiate nel file C generato da Lex. Esempio Scrivere un programma LEX che dato in ingresso un programma C ne produca in uscita uno equivalente ma privo dei commenti. Si modifichi il programma dell esercizio precedente in modo che riconosca le direttive #include e, quando le incontra, segnali un errore e termini l analisi. Si tenga conto che: possono comparire degli spazi o tabulazioni, non interessa verificare la correttezza del path: è un controllo che dovrebbe essere effettuato ad un livello superiore. Le espressioni regolari descrivono sequenze di caratteri ASCII ed utilizzano un certo numero di operatori: \[]^-?.*+ ()$/{%<> Lettere e numeri del testo di ingresso sono descritti mediante se stessi: l espressione regolare val1 rappresenta la sequenza v a l 1 nel testo di ingresso I caratteri non alfabetici vengono rappresentati in Lex racchiudendoli tra doppi apici, per evitare ambiguità con gli operatori: l espressione xyz ++ rappresenta la sequenza x y z + + nel testo di ingresso I caratteri non alfabetici possono essere anche descritti facendoli precedere dal carattere \ l espressione xyz\+\+ rappresenta la sequenza x y z + + nel testo di ingresso. 17

18 Le classi di caratteri vengono descritte mediante gli operatori [] l espressione [ ] rappresenta una cifra nel testo di ingresso. Nel descrivere classi di caratteri, il segno - indica una gamma di caratteri: l espressione [0-9] rappresenta una cifra nel testo di ingresso Per includere il carattere - in una classe di caratteri, questo deve essere specificato come primo o ultimo della serie: l espressione [-+0-9] rappresenta una cifra o un segno nel testo di ingresso. Nelle descrizioni di classi di caratteri, il segno ^ posto all inizio indica una gamma di caratteri da escludere: l espressione [^0-9] rappresenta un qualunque carattere che non sia una cifra nel testo di ingresso L insieme di tutti i caratteri eccetto il fine riga (new line) viene descritto mediante il simbolo. Il carattere di fine riga viene descritto dal simbolo \n Il carattere di tabulazione viene descritto dal simbolo \t L operatore? indica l espressione precedente è opzionale: ab?c indica sia la sequenza ac che abc L operatore * indica l espressione precedente può essere ripetuta 0 o più volte: ab*c indica tutte le sequenze che iniziano per a, terminano per c e hanno all interno un numero qualsiasi di b L operatore + indica l espressione precedente può essere ripetuta 1 o più volte: ab+c indica tutte le sequenze che iniziano per a, terminano per c e hanno all interno almeno un b. 18

19 L operatore indica un alternativa tra due espressioni: ab cd indica sia la sequenza ab che la sequenza cd Le parentesi tonde consentono di esprimere la priorità tra operatori: (ab cd+)?ef indica sequenze tipo ef, abef, cdddef. Ad ogni espressione regolare è associata in Lex un azione che viene eseguita all atto del riconoscimento. Le azioni sono espresse sotto forma di codice C: se tale codice comprende più di una istruzione o occupa più di una linea deve essere racchiuso tra parentesi graffe. L azione più semplice consiste nell ignorare il testo riconosciuto: si esprime un azione nulla con il carattere ;. Il testo riconosciuto viene accumulato nella variabile yytext, definita come puntatore a caratteri. Operando su tale variabile, si possono definire azioni più complesse. Il numero di caratteri riconosciuti viene memorizzato nella variabile yyleng, definita come intero. Esiste un azione di default che viene eseguita in corrispondenza del testo non descritto da nessuna espressione regolare: il testo non riconosciuto viene ricopiato in uscita, carattere per carattere. 19

20 Esistono due tipi di ambiguità lessicali: la parte iniziale di una sequenza di caratteri riconosciuta da un espressione regolare è riconosciuta anche da una seconda espressione regolare. La stessa sequenza di caratteri è riconosciuta da due espressioni regolari distinte. Nel primo caso verrà eseguita l azione associata all espressione regolare che ha riconosciuto la sequenza più lunga. Nel secondo caso sarà eseguita l azione associata all espressione regolare dichiarata per prima nel file sorgente di lex. Dato il file %% for {return FOR_CMD; format {return FORMAT_CMD; [a-z]+ {return GENERIC_ID; e la stringa di ingresso format, la procedura yylex ritorna il valore FORMAT_CMD, preferendo la seconda regola alla prima - perché descrive una sequenza più lunga, e la seconda regola alla terza -perché definita prima nel file sorgente. 20

21 Date le regole di risoluzione dell ambiguità, è necessario definire prima le regole per le parole chiave e poi quelle per gli identificatori. Il principio di preferenza per le corrispondenze più lunghe può essere pericoloso:.* {return QUOTED_STRING; cerca di riconoscere il secondo apice il più lontano possibile: cosi, dato il seguente ingresso first quoted string here, second here riconoscerà 36 caratteri invece di 7 Una regola migliore è la seguente: [^ \n]+ {return QUOTED_STRING; Può essere necessario limitare la validità di un espressione regolare all interno di un determinato contesto. Esistono meccanismi diversi per specificare la dipendenza dal contesto destro (cioè ciò che segue la sequenza di caratteri che si sta riconoscendo) rispetto alla dipendenza dal contesto sinistro (ciò che la precede). Fa eccezione la gestione del contesto di inizio e Fine riga. Contesto di inizio e fine riga Il carattere ^ all inizio di un espressione regolare indica che la sequenza descritta deve essere posta all inizio di riga. Ciò significa che o si è posizionati all inizio del file di ingresso o che l ultimo carattere letto è stato un carattere di fine riga. Il carattere $ al termine di un espressione regolare indica che la sequenza descritta deve essere seguita da un carattere di fine riga. Tale carattere non viene incluso nella sequenza riconosciuta, deve essere riconosciuto da un altra regola. 21

22 L operatore binario / separa un espressione regolare dal suo contesto destro. Pertanto, l espressione ab/cd indica la stringa ab, ma solo se seguita da cd. I caratteri che formano il contesto destro vengono letti dal file di ingresso ma non introdotti nel testo riconosciuto. A tale scopo viene utilizzato un apposito buffer fornito da Lex. L espressione ab$ è equivalente a ab/\n. È utile poter avere diversi insiemi di regole lessicali da applicare in porzioni diverse del file di ingresso, in genere in funzione di ciò che precede, ovvero del contesto sinistro. Esistono tre approcci distinti per affrontare il problema: uso di variabili flag. uso di condizioni iniziali sulle regole o stati. uso congiunto di più analizzatori lessicali. Per esprimere la dipendenza dal contesto sinistro è possibile utilizzare variabili flag nelle azioni delle regole. Tali variabili devono essere state precedentemente dichiarate come variabili globali. La funzione REJECT può essere utilizzata per evitare corrispondenze non volute: redirige lo scanner alla seconda miglior regola che riconosce lo stesso input, oppure ad una regola che riconosca un prefisso dello stesso input. 22

23 jlex specification xxx.jlex xxx.jlex.java input program test.sim JLex.Main (java) javac P2.main (java) generated scanner xxx.jlex.java Yylex.class Output of P2.main Yylex.class 23

24 Questo software, scritto interamente in java, produce in uscita delle classi java che mplementano i metodi per effettuare l analisi lessicale di una stringa in ingresso. La classe principale che è prodotta è Yylex, la quale contiene i seguenti metodi Token yylex() che è il reale scanner. Il costruttore Yylex tprende il file che vogliamo scannerizzare (Esempio new Yylex(System.in). Token è la classe token che vogliamo restituita dallo scanner; noi possiamo dire a JLex come è fatta la classe che vogliamo restituita. String yytext() ritorna il testo riconosciuto da yylex(). Il JLex per funzionare, ha bisogno in ingresso un file di specifica, contenente tutti i dettagli relativi all analisi lessicale che si vuole realizzare. public class P2 { public static void main(string[] args) { FileReader infile = new FileReader(args[0]); Yylex scanner = new Yylex(inFile); Symbol token = scanner.next_token(); while (token.sym!= sym.eof) { switch (token.sym) { case sym.intliteral: System.out.println("INTLITERAL (" + ((IntLitTokenVal)token.value).intVal \ + ")"); break; token = scanner.next_token(); 24

25 user code %% Jlex directives %% regular expression rules Usercode: codice java scritto dall utente, che implementa le classi da questi definite, eventualmente richiamate nelle azioni compiute a seguito del riconoscimento dei tokens. Ad esempio si possono scrivere classi che gestiscono la visualizzazione dei messaggi d errore ecc. user code %% Jlex directives %% regular expression rules Jlex directives: contiene tutta una serie di direttive previste nel manuale, impostabili dall utente e danno la possibilità di personalizzare l analizzatore secondo le esigenze attuali. Consente di definire delle macro 25

26 user code %% Jlex directives %% regular expression rules regular expression rules: contiene tutte le espressioni regolari definite in precedenza nel lessico. A ciascuna può essere associata un azione da compiere, ogni volta che il token corrente è riconosciuto. Ogni azione deve essere scritta di seguito all espressione regolare e racchiusa tra parentesi graffe. Contiene classi di utilità. Pertanto, se si desidera restituire una classe IntlitToken (per i letterali integer che vengono scannerizzati), si inserice la la sua definizione nella sezione Codice Utente Le direttive JLex sono varie istruzioni che permettono possono essere date a JLex per castomizzare lo scanner generato. Le piu importanti sono: %{nella classe Yylex class (metodi e attributi extra) il codice è copiato % %eof{il codice Java è esegutio quando e raggiunta la fine del file %eof %type classname classname is the return type you want for the scanner method, yylex() 26

27 Costituisce il secondo blocco di xxx.jlex. Può anche specificare Il valore di ritorno alla fine del file Che lo scanere sarà utilizzato con il parser generator java cup. Le direttive includono le definizioni di macro: name = regular-expression Qualsiasi identificatore Java valido DIGIT= [0-9] LETTER= [a-za-z] WHITESPACE= [ \t\n] Per usare una macro, utilizzaremo il suo nome fra parentesi graffe {LETTER({LETTER {DIGIT)* %% DIGIT= [0-9] LETTER= [a-za-z] WHITESPACE= [ \t\n] // spazio,tab, newline // per renderlo compatibile con java CUP %implements java_cup.runtime.scanner %function next_token %type java_cup.runtime.symbol 27

28 regular-expression { action pattern che deve essere eseguito riconosciuto codice che deve essere quando è riconosciuto il pattern Quando il metodo next_token() viene chiamato, le seguenti azioni vengono eseguite: Trova la sequenza di caratteri più lunga nella stringa di ingresso (iniziando dal carattere corrente) che matches il pattern. Esegue le azioni associate Se diversi patterns possono corrispondere alla stessa sequenza di caratteri viene scelta la strategia longest pattern, cioè viene scelta la stringa più lunga fra quelle possibili. Se diversi patterns possono corrispondere alla stessa sequenza più lunga viene seguite la strategia first such pattern, cioè viene scelto il primo pattern che è stato definito. Pertanto l ordine di definizione dei patterns può essere importante! Se un carattere di input non matched alcun pattern viene lanciata una exception 28

29 Hanno la struttura di una espressione regolare. abc == while Stringhe di caratteri fra apici, incluso I caratteri speciali corrispondono alla stringa stessa a b matches a b not a or b a\ \ \tb matches a \tb not a <TAB>b Per costruire le espressioni regolari si usano I seguenti operatori unione * Stella di Kleen + Significa una o piu istanze? Significa zero o una o una istanza () 29

30 ^ inizio linea ^main significa che la stringa main deve comparire all inizio della linea. $ fine linea main$ significa che la stringa main deve comparire alla fine della linea. [abc] Significa a b c) [a-z] Significa qualsiasi carattere fra a e z, inclusi [^abc] Qualsiasi carattere esclusi a, b, e c. ^ ha il significato di 1 a posizione in [ ] [\t\\] Signitica tab o \ [a bc] è equivalente a a " " b c 30

31 import java_cup.runtime.*; class Token { int linenum; int colnum; Token(int line,int col){linenum=line;colnum=col;; class IntLitToken extends Token { int intvalue; IntLitToken(int val,int line,int col){ super(line,col); intvalue=val; class IdentifierToken extends Token { String identifiertext; IdentifierToken(String text,int line,int col){ super(line,col); identifiertext=text;; class CharLitToken extends Token { char charvalue; CharLitToken(char val,int line,int col){ super(line,col); charvalue=val;; class StringLitToken extends Token { String stringtext; StringLitToken(String text,int line,int col){ super(line,col); stringtext=text; ; column numbers 31

32 class Pos { static int linenum = 1; // numero della linea corrente static int colnum = 1; // numero della colonna static int line = 1; static int col = 1; static void setpos() { linenum = line; colnum = col; // numero linea dopo la scansione del token //numero colonna dopo la scansione del token %% Digit=[0-9] %type Symbol // dice cosa JLex ritorna quando viene raggiunto eof %eofval { return new Symbol(sym.EOF,new Token(0,0)); %eofval %% "+" {Pos.setpos(); Pos.col +=1; return new Symbol(sym.PLUS,new Token(Pos.linenum,Pos.colnum)); 32

33 "!=" {Pos.setpos(); Pos.col +=2; return new Symbol(sym.NOTEQ, new Token(Pos.linenum,Pos.colnum)); ";" {Pos.setpos(); Pos.col +=1; return new Symbol(sym.SEMI, new Token(Pos.linenum, Pos.colnum)); {Digit+ {// This def doesn t check // for overflow Pos.setpos(); Pos.col += yytext().length(); return new Symbol(sym.INTLIT, new IntLitToken( newinteger(yytext()).intvalue(), Pos.linenum,Pos.colnum)); \n {Pos.line +=1; Pos.col = 1; " " {Pos.col +=1; class P { public static void main(string args[]) throws java.io.ioexception { if (args.length < 1) {System.out.println("Error: manca il nome del file" ); System.exit(-1); java.io.fileinputstream yyin = null; try {yyin =new java.io.fileinputstream(args[0]); catch (FileNotFoundException notfound){ System.out.println("Error: impossibile aprire file "); System.exit(-1); Yylex lex = new Yylex(yyin); System.out.println( inizio dello scanner."); Symbol token = lex.yylex(); 33

34 while ( token.sym!= sym.eof ) { System.out.print(((Token) token.value).linenum + ":"+ ((Token)token.value).colnum + " "); switch (token.sym) { case sym.intlit: System.out.println("\tinteger literal(" +((IntLitToken)token.value).intValue + ")"); break; case sym.plus: System.out.println("\t+"); break; case sym.noteq:system.out.println("\t!="); break; default: throw new RuntimeException(); token = lex.yylex(); // get next token System.out.println("End test scanner."); 34