LEXICAL ANALYSIS LEXICAL ANALYSIS - SCANNING 30/10/2013. Symbol Table. Tokens described formally Breaks input into tokens White space.

Transcript

1 LEXICAL ANALYSIS 1 LEXICAL ANALYSIS - SCANNING Source langua ge Scanner (lexical analysis) tokens Parser (syntax analysis) Semantic Analysis (IC generator) Code Generator 2 Code Optimizer Tokens described formally Breaks input into tokens White space Symbol Table CS 540 Sprin g 2013 GM U 1

2 LEXICAL ANALYSIS INPUT: sequence of characters OUTPUT: sequence of tokens Next_char() Next_token () Input character Scanner token Parser A lexical analyzer is generally a subroutine of parser: Simpler design Efficient Portable Symbol Table 3 DEFINITIONS token set of strings defining an atomic element with a defined meaning pattern a rule describing a set of string lexeme a sequence of characters that match some pattern 4 2

3 EXAMPLES Token Pattern Sample Lexeme while while while relation_op =!= < > < CS 540 Spring 2013 GMU integer (0-9)* 42 string Characters between hello 5 INPUT STRING: SIZE := R * 32 + C <token,lexeme> pairs: <id, size> <assign, :=> <id, r> <arith_symbol, *> <integer, 32> <arith_symbol, +> <id, c> 6 3

4 ATTRIBUTES OF TOKENS y := *x Lexical analyzer <id, y > <assign, > <num, 31> < +, > <num, 28> < *, > <id, x > token (lookahead) tokenval (token attribute) Parser 7 8 TOKENS, PATTERNS, AND LEXEMES A token is a classification of lexical units For example: id and num Lexemes are the specific character strings that make up a token For example: abc and 123 Patterns are rules describing the set of lexemes belonging to a token For example: letter followed by letters and digits and non-empty sequence of digits 4

5 9 SPECIFICATION OF PATTERNS FOR TOKENS The following shorthands are often used: r + = rr * r? = r [a-z] = abc z Examples: digit [0-9] num digit + (. digit + )? ( E (+-)? digit + )? REGULAR DEFINITIONS AND GRAMMARS Grammar stmt if expr then stmt if expr then stmt else stmt expr term relop term term term id num Regular definitions if if then then else else relop < <= <> > >= = id letter ( letter digit ) * num digit + (. digit + )? ( E (+-)? digit + )? 10 5

6 COME REALIZZARE UNO SCANNER 1. Realizzazione procedurale o a controllo di programma (hard-coded): un programma adhoc 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 REALIZZAZIONE PROCEDURALE Espressione regolare Codice per l analisi del linguaggio Si scrive una sequenza per ogni concatenazione un test per ogni unione un ciclo per ogni stella di kleen 6

7 R = C (C 0)* 0 if (CurrentChar == c'){ read(currentchar) while(currentchar == c CurrentChar == 0 ) read(currentchar) return ok if (read(currentchar) == 0 ) return ok return errore // NOT(EOL)* EOL 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 7

8 CODING REGULAR DEFINITIONS IN TRANSITION DIAGRAMS relop <<=<>>>== start 0 < 1 = 2 return(relop, LE) > 3 return(relop, NE) other * 4 return(relop, LT) = 5 return(relop, EQ) > 6 = 7 return(relop, GE) other * 8 return(relop, GT) id letter ( letterdigit ) * start 9 letter letter or digit 10 other 11 * 15 return(gettoken(), install_id()) CODING REGULAR DEFINITIONS IN TRANSITION DIAGRAMS: CODE token nexttoken() { while (1) { switch (state) { case 0: c = nextchar(); if (c==blank c==tab c==newline) { 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: case 9: c = nextchar(); if (isletter(c)) state = 10; else state = fail(); break; case 10: c = nextchar(); if (isletter(c)) state = 10; else if (isdigit(c)) state = 10; else state = 11; break; Decides the next start state to check int fail() { forward = token_beginning; swith (start) { case 0: start = 9; break; case 9: start = 12; break; case 12: start = 20; break; case 20: start = 25; break; case 25: recover(); break; default: /* error */ 16 return start; 8

9 REALIZZAZIONE PROCEDURALE 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 non-terminale che compare in RHS ESEMPIO 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 9

10 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 REALIZZAZIONE TABULARE Espressione regolare Automa a stati finiti non deterministico Automa a stati finiti deterministico 10

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

12 IMPLEMENTING A LEXICAL ANALYZER Practical Issues: Input buffering Translating RE into executable form Must be able to capture a large number of tokens with single machine Interface to parser Tools 23 ALCUNE CONSIDERAZIONI PRATICHE IDENTIFIERS VS. RESERVED WORDS 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. 12

13 CAPTURING MULTIPLE TOKENS Capturing keyword begin b e g i n WS 25 Capturing variable names A WS WS white space A alphabetic AN alphanumeric AN What if both need to happen at the same time? CS 540 Sprin g 2013 GM U CAPTURING MULTIPLE TOKENS b e g i n WS 26 A-b AN WS AN WS WS white space A alphabetic AN alphanumeric Machine is much more complicated just for these two tokens! CS 540 Sprin g 2013 GM U 13

14 CONVERSIONE DEI TOKEN IN VALORI 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 rappresentata utilizzando 32 o 64 bit. SCANNER TERMINATION 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 14

15 MULTI CHARACTER LOOKAHEAD 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. LEXICAL ERROR RECOVERY 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 15