Analisi semantica. Scopi Tecniche Strumenti - Yacc. L4 - Introduzione ai compilatori - UNINA - Silvio Imbò

Transcript

1 Analisi semantica Scopi Tecniche Strumenti - Yacc 1

2 L analizzatore semantico nel compilatore Linguaggio sorgente Analizzatore lessicale token Next token Analizzatore semantico Analizzatore sintattico AST, parse tree annotati Fasi successive Symbol table 2

3 Scopi dell analisi semantica Per poter essere usati nelle fasi successive della compilazione, le derivazioni (alberi sintattici) devono avere caratteristiche particolari, e devono conservare informazioni di natura semantica sui costrutti della grammatica. Il punto di partenza sono le produzioni della grammatica: ai simboli di una produzione vengono associate le informazioni semantiche sotto forma di attributi. Le strutture semantiche si definiscono attraverso schemi sintattici: syntax direct tranlsation. Con gli schemi di traduzione si può creare opportunamente l albero sintattico di una frase. L analisi semantica integra l analisi sintattica o traduce alberi sintattici in strutture utili alle elaborazioni successive 3

4 Attributi sintetizzati e ereditati Attributi sintetizzati L attributo di A è di tipo sintetizzato se il suo valore dipende dal valore degli attributi dei simboli X 1 X 2... X n della parte destra della produzione (S-Attributi) A X 1 X 2... X n Attributi ereditati L attributo di X i è di tipo ereditato se il suo valore dipende dal valore degli attributi degli altri simboli della parte destra della produzione e dal valore dell attributo di A 4

5 Attributi sintetizzati - esempio espressioni Produzioni E E + T E T T T * F T F F int F ( E ) Regole semantiche E 1.val = E 2.val + T.val E.val = T.val T 1.val = T 2.val * F.val T.val = F.val F.val = int.val F.val = E.val 5

6 Attributi sintetizzati - albero annotato 2*(3+5) E (16) T (16) T (2) F (2) * ( F (8) E (8) ) Albero sintattico con notazioni semantiche: int (2) albero annotato o decorato E (3) T (3) F (3) + int (3) T (5) F (5) int (5) 6

7 Attributi ereditati - esempio schema di traduzione valutazione numeri binari con segno Produzioni Regole semantiche N S L L.pos = 0; if (S.neg) N.val= - L.val; else N.val= L.val; S - S + S.neg =true; S.neg =false; L B L.val = B.val; L.pos = B.pos L 0 L 1 B L 0.val = L 1.val+B.val; L 1.pos= L 0.pos+1; B.pos= L 0.pos; B 0 B.val = 0 B 1 B.val = 2 B.pos 7

8 Attributi ereditati - esempio albero decorato N S L L.pos = 0 if (S.neg) N.val= - L.val; else N.val= L.val; S - S.neg =true; S + S.neg =false; L B L.val = B.val; L.pos = B.pos L 0 L 1 B L 0.val = L 1.val+B.val; L 1.pos= L 0.pos+1; B.pos= L 0.pos; B 0 B.val = 0 B 1 B.val = 2 B.pos S neg=true N val=-9 L {val=9 pos=0} L {val=8 pos=1} B {val=1 pos=0} L {val=1 pos=2} B {val=0 pos=1} L {val=8 pos=3} B {val=0 pos=2} B {val=8 pos=3} 1 0 8

9 Attributi ereditati - esempio dichiarazione Produzioni D T L T int T real L 0 L 1, id L id Regole semantiche L.in=T.type T.type =integer T.type =real L 1.in = L 0.in; addtype (id.entry, L.in) addtype (id.entry, L.in) Attributo edreditato Aggiunge il tipo all entry nella symbol table 9

10 Ordine di valutazione degli attributi L ordine di valutazione degli attributi corrisponde ad un ordinamento topologico dei nodi del parse tree La tecnica parse tree si basa su un ordinamento del grafo delle dipendenze, che esplicita le dipendenze tra gli attributi sintetizzati ed ereditati Es.: real A,B,C i Dipende da j i<j D T L L.in=T.type T int T.type =integer T real T.type =real L0 L1, id L1.in = L0.in; addtype (id.entry, L.in); L id addtype (id.entry, L.in) T 4 type real 7 9 entry10 in L D in L, 5 in L 6 8, B 2 entry C 3 A 1 10

11 Metodo parse tree 1) costruzione del parse tree 2) costruzione del grafo delle dipendenze Tecniche di valutazione 3) creazione di un ordinamento topologico del grafo 4) valutazione Fallisce nel caso di cicli Metodo Rule-based 1) Analisi delle regole semantiche associate alle produzioni nella fase di progettazione del compilatore 2) determinazione di un ordine della valutazione degli attributi a compile construction time 3) utilizzo dell ordine a parsing time Metodi ad HOC L ordine di valutazione è indipendente dalla grammatica e dal parse tree, e viene applicato a compile time 11

12 Attributi L Un metodo di valutazione tipo parse tree usato è quello della visita Deepth First: per ogni nodo si valutano gli attributi ereditati da sinistra a destra, quindi si a valutare l attributo sintetizzato del nodo. Gli attributi ereditati per poter essere adatti al metodo di valutazione depth first devono essere di tipo L: A X 1...X I-1 X I X 1+1 X n L attributo di X i è di tipo L se il suo valore dipende dal valore degli attributi dei simboli della parte destra della produzione che lo precedono (X 1...X I-1 ) e dal valore dell attributo di A. Gli S-attributi sono adatti ad essere valutati con tecniche tipo LR,quelli L con tecnica tipo LL(1). Inoltre gli S attributi sono anche L attributi. 12

13 Alberi sintattici astratti Gli Alberi Sintattici Astratti AST sono una versione condensata di alberi sintattici dove: 1. Gli operatori occupano i nodi interni 2. Le catene di produzioni singole sono collassate. 3. I Terminali senza attributi non vengono disegnati (parentesi, virgole, ecc) Gli AST vengono usati nella fase di generazione di codice Negli schemi di traduzione le regole semantiche sono racchiuse tra parentesi graffe, inserite nelle regole di produzione ed eseguite secondo l ordine depth-search 13

14 Esempio AST per espressioni E T * T * F 2 + F ( E ) 4 5 int (2) E * T T F F int (4) int (5) 14

15 Schema di traduzione per costruire AST per espressioni E 1 E 2 + T {E 1.ptr = addnode( +,E 2.ptr, T.ptr) E T {E.prt= T.ptr} T 1 T 2 * F {T 1.trans = addnode( * T 2.trans, F.trans)} T F {T.ptr = F.ptr} F int {F.ptr = addleaf(int, int.value)} F ( E ) {F.ptr= E.ptr} * num 2 + num 4 num 5 typedef struct node { type label; struct node *left; struct node* right; } node; 15

16 DAG Per motivi pratici si preferisce realizzare i DAG anzicchè gli AST. I DAG (Direct aciclic graph) a differenza degli AST, le sotto espressioni comuni non sono ripetute: + Dag per a+a*(b-c)+(b-c)*d + * a * - d b c La costruzione è simile a quella degli AST, sono che in fase di costruzioni di un nuovo nodo si controlla prima se il nodo già esiste: nel caso si fa riferimento a quello esistente. 16

17 Valutazione attributi S con stack La valutazione degli attributi S può avvenire estendendo le funzioni di un parser LR, aggiungendo un campo allo stack per conservare il valore degli attributi Stato X Y Z valore X.x Y.y Z.z Se alla produzione A XYZ è associata la regola semantica A.a=f (X.x,Y.y,Z. z), prima che XYZ viene ridotto con A, val[top] contiene il valore di Z.z, val[top-1] quello di Y.y val[top-2] quello di X.x. Dopo la riduzione, il valore dell attributo sintetizzato di A va in val[top]. 17

18 Esempio valutazione attributi S con stack LR Produzione L E E E 1 + T E T T T 1 * F T F F (E ) F digit Codice print (val[top]) val[ntop]=val[top-2]+val[top] val[ntop]=val[top-2]*val[top] val[ntop]=val[top-1] 18

19 Valutazione attributi L con parser predittivi Si applicano agli schemi di traduzioni le stesse trasformazioni per rendere una grammatica adatta ad un parser predittivo E E 1 + T {E.val= E 1.val+T.val} E E 1 - T {E.val= E 1.val-T.val} E T {E.val= T.val} T (E) {T.val= E.val} T num {T.val= num.val} Eliminazione ricorsione sinistra E T {R.I= T.val} R {E.val= R..s} R + T R 1 R - T R 1 R ε T (E ) T num {R 1.i= R..i + T.val} {R..s= R 1.s} {R 1.i= R..i - T.val} {R..s= R 1.s} {R..s = R..i} {T.val= E.val} {T.val= num.val} 19

20 Parser predittivo - estensione per valutazione attributi L Per ciascun non terminale si costruisce una funzione con un parametro formale per attributo ereditato, e che restituisce il valore dell attributo sintetizzato Per ogni token X, si conserva il valore dell attributo sintetizzato in una variabile, si verifica che l input corrisponda a X e si avanza l input Per i non terminali, si invoca la funzione e si conserva in una variabile il valore dell attributo sintetizzato restituito Le azioni semantiche vanno ricopiate sostituendo ad ogni riferimento per l attributo la variabile corrispondente. 20

21 Valutazione attributi L esempio E E 1 + T {E.ptr= mknode( +,E 1.ptr, T.ptr)} E E 1 - T {E.ptr= mknode( -,E 1.ptr, T.ptr)} E T {E.ptr= T.ptr}... E T {R..i= T.ptr} R {E.ptr= R..s} R + T {R 1.i= mknode( +,R..i,T.ptr)} R 1 {R..s= R 1.s} R ε {R..s = R..i}... ptr R(ptr in) { ptr nptr,i1,s1,s; if (cc= + ) { cc=nextok(); nptr=t(); i1=mknode( +,in,nptr); s1=r(i1); s=s1; } else /* empty prod. */ } s=in; 21

22 Valutazione attributi L esempio 2 <s-expr>:= alpha_atom numeric_atom "(" <list_elements> <list_elements>:= ")" <s-expr> <list_elements> ccp list_elements(ccp np_list) { if (cc!= ) ) { } else np_sexpr=s_expr(); ni=mklist(np_sexpr,np_list); return list_elements(ni); { cc=nextok(); } } return np_list; mklist typedef enum {a,n,l} s_expr_type; typedef struct cons_cell* ccp; typedef struct cons_cell { s_expr_type celltype; union { struct { } cc; char *alfap; int nump; } Cont; } CCell; ccp car; ccp cdr; 22

23 Valutazione attributi L con stack Un parser bottom up riduce la parte destra di una produzione A XY rimuovendo X e Y sostituendoli con A in cima allo stack Se X ha un attributo S: X.s e Y ha un attributo di tipo ereditato definito da una regola copia: Y.i=X.s, il valore di X.s può essere usato laddove serve Y.i, ed è già presente sullo stack. 23

24 Valutazione attributi L con stack: esempio D T L T int T real L L 1, id L id {L.in=T.type} {T.type=integer} {T.type=real} {L 1. in = L.in} {addtype(id.entry, L.in)} {addtype(id.entry, L.in)} I valori degli attributi possono essere conservati nello stack (val) Produzione D T L T int T real L L 1, id L id Regola val[ntop]=integer val[ntop]=real addtype(val[top],val[top-3]) addtype(val[top],val[top-1]) La regola copia scompare perché sullo stack c e il valore di T.type 24

25 Semantica in YACC/1 YACC è predisposto per la valutazione semantica degli simboli della grammatica: oltre allo stack dei simboli, possiede lo stack dei valori I valori semantici sono conservati nele variabili denotate da $x (parte destra regole) e $$ (parte sinistra), che sono di tipo intero Per default, ad ogni simbolo viene associato un solo attributo di tipo intero: typedef YYSTYPE int 25

26 Semantica in YACC /2 In alternativa è possibile usare i costrutti %union e %type per definire un insieme di interpretazioni alternative dei valori semantici Esempio dichiarazione di funzione Func ( Args ) Func ha due attributi: un intero (numero di argomenti( ed un puntatore a carattere (il nome). I simboli E, T ed F hanno un solo attributo di tipo reale (il loro valore), Args un solo attributo di tipo intero. 26

27 Semantica in YACC /3 %{ typedef struct _function_desc { int arg_number; char *name; } function_desc; %} %union { function_desc function; float expression; char * id; int other; } %type <expression> E T F %type <function> Func %type <other> Args 27

28 Semantica in YACC /4 Se ad un simbolo sono stati associati più attributi sotto forma di struct, è possibile far riferimento a ciascuno di essi con la sintassi $n.attr. Func: identifier ( Args ) { $$.name=$1; $$.arg_number=$3; } ; 28

29 Semantica in YACC /5 E possibile associare attributi ai simboli terminali; bisogna definirne il tipo nella sezione delle dichiarazioni : %token <expression> number L analizzatore lessicale deve assegnare al simbolo il suo valore semantico nella variabile yylval (nel caso di %union, bisogna indicare il campo della unione [0-9]+. [0-9]* {yylval.field = atof(yytext); return(number);} 29

30 Semantica in YACC /6 attributi ereditati E possibile ottenere i valori semantici precedentemente conservati nello stack: $0 valore precedente a $$, $-1 valore precedente a $0 Bisogna essere sicuri di conoscere le posizioni relative. D: id {$$.type=$0.type; addid($1.name,$$.type);} I Bisogna essere sicuri che alla dichiarazione sia sempre preceduta da un identificatore di tipo 30

31 Semantica in YACC /7 attributi ereditati Con la regola lista viene a cadere questa condizione: Decl1: id, Decl1 ; Soluzione: utilizzo di un non terminale supplementare Decl1: id, Empty Decl1 { $$.type= $0.type; Empty: {$$=$-2;}; ; add_id($1.name,$$.type); } 31

32 Semantica in YACC /7 attributi ereditati embedded production A: { /* do something */ } ; Si usano per eseguire delle azioni necessarie ai simboli seguenti. YACC introduce dei valori semantici supplementari per ogni embedded production,$$1, $$2 che possono essere a loro volta utilizzati. Es. installazione dei simboli locali ad un statement in c. B: C A D ; A: B { /* do something */ } C La funzione installsymtab crea una nuova symbol table (symtab è un parametro: concatenazione di symbol table) Quando statement: '{' { symtab = installsymtab(symtab); } DeclarationList StatementListOpt '}' { $$ = newnode(nt_compound, symtab, $4); symtab = symtab->parent; } 32

33 Semantica in YACC /7 embedded producion. E possibile definire il tipo delle embedded production: statement: '{' <symtab> { symtab = installsymtab(symtab); $$ = symtab; } DeclarationList StatementListOpt '}' { $$ = newnode(nt_compound, $2, $4); symtab = $2->parent; } Le embedded production possono essere utilizzate nelle traduzioni: rel : esp rel '<' { printf("<"); } esp 33

34 Semantica in YACC /8 E possibile controllare la correttezza semantica dei costrutti e forzare l andamento del parser attraverso le macro: YYABORT interrompe l esecuzione del parser restituendo 1 (errore) YYACCEPT interrompe l esecuzione del parser restituendo 0 (successo) YYERROR genera un errore sintattico 34

35 Semantica in ANTLR/1 ANTLR consente di costruire AST con tree operators, rewrite rules, ed azioni semantiche. ANTLR permette di definire la struttura degli AST, ed inoltre possiede strumenti per modificare, percorrere e trasformare gli alberi generati 35

36 Semantica in ANTLR / 2 Gli AST di ANTLR si basano su una interfaccia che prevede, per ciascun nodo i nodi figli siano contenuti in una lista di fratelli. I tree parser DEVONO implementare l interfaccia AST di ANTLR. I metodi per la navigazione sono: getfirstchild: Restituisce una referenza al primo figlio della lista dei nodi figli. getnextsibling: Restituisce una referenza al prossimo nodo figlio della lista di fratelli. Le regole per la costruzione, la navigazione degli alberi sintattici si scrivono alla stessa maniera della parte lessicale e sintattica, in forma EBNF con l aggiunta di notazioni speciali, dette tree pattern #( root-token child1 child2... childn ) 36

37 Es 1: AST PLUS #( PLUS INT INT ) INT INT Alla radice di un tree pattern ci deve essere un TOKEN, ma i figli possono essere regole. Es 2: #( IF expr stat (stat)? ) 37

38 Semantica in ANTLR/3 Costruzione degli AST La costruzione degli AST è attivata dalla opzione buildast=true I nodi radice sono seguiti dal simbolo ^ : ES.: la regola a : A B^ C^ ; Corrisponde alla creazione dell albero #(C #(B A)) 38

39 Il suffiso! per un token inibisce la creazione dell albero per la regola corrente da parte di ANTLR, che puo essere costruito invece specificando un tree pattern. begin! : INT PLUS i:int { #begin = #(PLUS INT i); } Esempi: Semantica in ANTLR/4 Modifica creazione standard degli r! : a:a{ #r = #a; } AST decl : ( TYPE ID )+ { #decl = #([DECL,"decl"], #decl); } /* Costruzione di un sotto albero */ 39

40 Semantica in ANTLR/5 Costruzione dei nodi Ci sono tre modi possibili per creare i nodi con ANTLR attivato in modalità parse tree (buildast=true) 1)Costruirlo esplicitamente: new T(arg) T è il tipo nodo, arg è un tipo token o un Token nella parte action delle regole. 2)costrurilo tramite Factory (ASTFactory.create(arg)) 3)Usare una notazione tipo: #[TYPE] #[TYPE,"text"] #[TYPE,"text",ASTClassNameToConstruct]. (ASTFactory.create()) #id (id è un token, una label, o una regola). Per costruire l albero si puo ricorrere alla factory o un tree pattern #(...): #(root, c1,..., cn) 40

41 Semantica in ANTRL/6 Uso del tree parser insieme al lexer ed al parser L lexer = new L(System.in); P parser = new P(lexer); parser.setastnodetype("myast"); parser.startrule(); buildast=true costruzione AST-> parser.getast(). 41

42 Semantica in ANTLR/7 - Cosa fare con gli AST Navigazione TT walker = newt(); walker.startrule(parser.getast()); Trasformazione (Visitor)AST results = walker.getast(); DumpASTVisitor visitor = new DumpASTVisitor(); visitor.visit(results); DumpASTVisitor è una classe predefinita (derivata da) ASTVisitor che stampa l albero sullo standard output. PrintOut dell albero (LISP like) String s = parser.getast().tostringlist(); 42

43 Controllo dei tipi La verifica della correttezza dei tipi nelle operazioni si applica a: verifica compatibilità operatori/operandi overloading: un operatore può avere diversi significati a seconda del contesto: si deve riconoscere il contesto ed effettuare le eventuali conversioni polimorfismo: una funzioni può avere lo stesso nome ma più firme: può essere eseguita con diverse combinazioni di argomenti per tipo e numero 43

44 Posizione del type checker nel compilatore token Parse Parser Type tree cheecker Parse tree Generatore codice intermedio Rappr. intermedia 44

45 Type expression, type constructor, type system I tipi dei costrutti di un linguaggio sono descritti (denotati) da type expression. Type expression char, integer, real, void, type_error (denota errore), denotano i tipi primitivi. I tipi costruiti si ottengono applicando i type constructor alle type expression. Es.: -Array: array( I, T ) (I : dimensione dell array, T : type expression) -Puntatori: pointer( T ) (denota il puntatore a un tipo T) -Prodotto: T 1 T 2 (prodotto cartesiano, necessari per record e funzioni) - Strutture/record: struct( T ) struct { int i; char s[2]; } -----> struct((i int ) ( s array(2,char))) 45

46 Type expression, type constructor, type system/2 Le funzioni fanno corrispondere elementi di un insieme Tipo Dominio ad un insieme Tipo Range Funzioni: T 1 T 2 T1 : tipo del dominio, T2 : tipo del range. La funzione int* f(char a, char b) viene rappresentata dalla seguente type expression: (char x char) pointer(int) Un type system è un insieme di regole per assegnare type expression alle diverse parti di un programma (espressioni, dichiarazioni, istruzioni) Il type cheecker applica le type expression secondo il type system: costruisce e verifica i tipi 46

47 Schema di traduzione per costruzione tipi di un identificatore D D ; D D id : T T char T integer T ^T 1 T array [num] of T 1 {addtype(id.entry,t.type)} {T.type=char} {T.type=integer} {T.type=pointer(T 1.type)} {T.type=array(num.val,T 1.type)} 47

48 Schema di traduzione per costruzione tipi di una espressione E literal E num E ID E E 1 mod E 2 E E 1 [E 2 ] E E 1^ {E.type=char} {E.type=integer} {E.type=lookup(ID.entry)} {if E 1.. type==integer and E 2.. type==integer then E.type=integer else E.type=type_error} {if E 2.type=integer and E 1.type=array(s,t) then E.type=t else E.type=type_error} {if E 1.type=pointer(t) then E.type=t else E.type=type_error} Consulta la symbol table per risalire al tipo dell ID 48

49 Controllo tipi istruzioni e funzioni Il controllo dei tipi per le istruzioni serve a verificare la correttezza delle espressioni coinvolte nelle istruzioni: S if E then S 1 {if E 1.. type==boolean then S.type=void else S.type=type_error} Nel caso delle funzioni l effetto è di controllare la correttezza degli operandi E E 1 (E 2 ) {if E 2.type=s and E 1.type=s -> t then E.type=t else E.type=type_error} 49

50 Equivalenza tra espressioni di tipo Per poter stabilire quando due espressioni di tipo sono equivalenti si ricorre al concetto di equivalenza strutturale.due type expression sono equivalenti se 1) sono lo stesso tipo primitivo, oppure 2) sono l applicazione del costruttore di tipo a tipi equivalenti. Algoritmo a discesa ricorsiva boolean function sequiv(s,t) { if s e t sono dello stesso tipo primitivo, return true else if s=array(s1,s2) and t=array(t1,t2) return (sequiv(s1,t1) and sequiv(s2,t2)) else if s=s1 s2 and t= t1 t2 return (sequiv(s1,t1) and sequiv(s2,t2)) else if s=pointer(s1) and t= pointer(t1) return (sequiv(s1,t1)) else if s=s1 s2 and t= t1 t2 return (sequiv(s1,t1) and sequiv(s2,t2)) else return false; } 50

51 Equivalenza e nomi per tipi In alcuni linguaggi è possibile assegnare dei nomi ai tipi, es PASCAL: type link = ^cell; var p : link; q : ^cell; p e q sono dello stesso tipo? Dipende dall implementazione: se ogni nome tipo è visto come un tipo distinto, p e q non sono equivalenti (sono equivalenti in senso strutturale). I riferimenti uficiali in Pascal non fanno riferimento ad identical type 51

52 Cicli nella rappresentazioni di tipi Alcune definizioni ricorsive possono indurre delle circolarità che ostacolano la verifica della equivalenza strutturale tra tipi es. Pascal type link= ^cell; cell= record info: integer; next: link; struct cell{ int info; struct cell *next; }; end; Il C affronta il problema non usando l equivalenza strutturale per le struct, e richiedendo che i type names vengano dichiarati prima di venire usati (il nome diventa parte del tipo). Due struct sono equivalenti se hanno allora lo stesso nome. 52

53 Conversione dei tipi Le conversione dei tipi possono essere esplicite o implicite. In genere si applica la conversione che non disperde l informazione: E E 1 op E 2 if E 1. type=integer and E 2. type=integer then E.type=integer; else if E 1. type=integer and E 2. type=real then E.type=real; else if E 1. type=real and E 2. type=integer then E.type=real; else if E 1. type=real and E 2. type=real then E.type=real; else E.type=error_type; 53