Elementi di semantica operazionale

1. Elementi di semantica operazionale

2. Sintassi e semantica • un linguaggio di programmazione, come ogni sistema formale, possiede • una sintassi • le formule ben formate del linguaggio (o programmi sintatticamente corretti) • una semantica • che assegna un significato alle formule ben formate • dando un’interpretazione ai simboli • in termini di entità (matematiche) note 2

3. Sintassi e semantica • la teoria dei linguaggi formali fornisce i formalismi di specifica (e le tecniche di analisi) per trattare gli aspetti sintattici • per la semantica esistono diverse teorie • le più importanti sono la semantica denotazionale e la semantica operazionale • la semantica formale viene di solito definita su una rappresentazione dei programmi in sintassi astratta • invece che sulla reale rappresentazione sintattica concreta 3

4. Semantica operazionale • lo stile di definizione tradizionaleè quello deisistemi di transizione • insieme di regole che definiscono • attraverso un insieme di relazioni di transizione come lo stato cambia per effetto dell’esecuzione dei vari costrutti • una tipica regola descrive la semantica di un costrutto sintattico c eseguito nello stato s, specificando il nuovo stato s’ e/o il valore calcolato v • i domini semantici con cui rappresentiamo lo stato ed i valori dipendono dal linguaggio di programmazione 4

5. Linguaggio Didattico • Semplice linguaggio imperativo (frammento di C), blocchi, puntatori, chiamata di funzione • Rivediamo l’interprete presentato a Programmazione I

6. Sintassi concreta Programma::= int main() {StmtList} StmtList ::= Stmt ; StmtList | e Stmt::=Decl | Com

7. Comandi Com::=Ide=Exp|Assegnamento if (Exp) Com else Com |Condizionale while (Exp) Com|Iteratore {StmtList}| Blocco Ide(Exp)|Invocazione di fun return ExpCalcolo dei risultato di una fun

8. Espressioni Exp::= Ide | Identificatore Costante | Costante Exp Op Exp | Operazioni Binarie Uop Exp | Operazioni Unarie Ide(Exp) | Chiamata di fun (Exp) Parentesi

9. Espressioni 2 Ide::= Lettera (Lettera | Cifra | Simbolo)* Costante::= Numero | Carattere UnOp::= ! | * | Op::=+ | - | * |...& | > | < | ==.... Numero::=É

10. Puntatori • ! si applica per semplicita’ ai soli identificatori. La locazione calcolata, in questo caso `e la locazione in cui `e memorizzato il valore dell’identificatore • * che si applica ad una qualunque espressione, la calcola ottenendo un valore v che viene per`o trasformato in una locazione l. Il valore finale calcolato `e il valore v’ contenuto nella locazione l.

11. Dichiarazioni Decl ::= Type Ide [=Exp] | variabile FunctDec funzione FunctDec::= Type Ide (Formal) {StmtList} Type::= int Formal::= Type Ide

12. Nota • Per semplicita’ si considerano funzioni che hanno un solo parametro formale • L’estensione a piu’ parametri e’ banale • Ricordiamo che il passaggio dei parametri e’ per valore

13. Semantica Operazionale • Domini dei valori • Componenti dello stato • Regole di Transizione per ogni categoria sintattica (espressioni, dichiarazioni, comandi,programmi)

14. Domini semantici: lo stato • in un qualunque linguaggio ad alto livello, lo stato deve comprendere una componente chiamato ambiente (environment) • per modellare l’associazione tra gli identificatori ed i valori che questi possono denotare (dval) • il nostro frammento è imperativo ed ha la nozione di entità modificabile, cioè le variabili ed i puntatori (create con le dichiarazioni e modificate con l’assegnamento) • è quindi necessario un secondo componente dello stato, chiamato memoria (store) • per modellare l’associazione fra locazioni e valori che possono essere memorizzati (mval) 14

15. L’ambiente • Per modellare i blocchi l’ambiente e’ una pila di Frames • La politica FIFO permette di catturare la dichiarazione piu’ recente di una variabile

16. Valori (memorizzabili) • Ide identificatori • Val=Int + {omega}+{Undef} • Loc le locazioni di memoria, possono essere rappresentati come numeri naturali. Nel seguito useremo la notazione 0L , 1L , 2L ...ecc, per indicare rispettivamente le locazioni di indirizzo 0, 1, 2 ecc

17. Memoria • store: Loc ---> Val (si usa la metavariabile μ) • Nota: Val non contiene le locazioni. Nella semantica data, si usano meccanismi per trasformare locazioni in valori e viceversa. La seconda `e possibile ed anzi molto semplice perch`e le locazioni sono numeri naturali

18. Frame • frame: Ide ---> Den (si usa la metavariabile φ) • Den = Loc ∪ FunDecl ∪ Unbound. L’insieme delle denotazioni `e l’unione dell’insieme Loc degli indirizzi di memoria e dell’insieme FunDecl delle definizioni di funzione e della denotazione speciale Undef, che rappresenta una situazione di errore.

19. Funzioni FunDecl `e una tripla Ide × SList × Env • il nome del parametro formale • il corpo della funzione • l’ambiente di definizione (scoping statico)

20. Operazioni sui Frames • EmptyFramecrea il frame ovunque indefinito φ(x)=Unbound per ogni x

21. Modifica di un frame φ[d/x](y)= φ(y) se x e’ diverso da y d se x=y • La definizione cos`ı data risulta corretta anche nell’eventualit`a che un legame diverso da Unbound per x esista gia’ • non e’ molto corretto solo per programmi sintatticamente corretti

22. Ambiente • env=Stack(Frames) (si usa la metavariabile σ)

23. Operazioni sulla pila •EmptyStack crea la pila vuota •top restituisce l’elemento in testa alla pila ovvero l’ultimo elemento inserito. Non modifica la pila. •pop restituisce l’elemento in testa alla pila. Modifica la pila, eliminando l’elemento in testa. •push inserisce un elemento in testa alla pila.

24. Operazioni sulla memoria • μ : Loc ---> Val Val=Int + {omega}+{Undef} • Verrebbe da dare operazioni analoghe a quelle del frame....si tratta di una funzione parziale

25. Gestione della memoria • allocazione di memoria: l’inserzione di nuovi legami nella memoria corrisponde alla allocazione di memoria su una machina, e differisce dall’inserzione di un nuovo legame in un generico frame • Deve esserci un meccanismo per assegnare una nuova locazione ancora libera • Deve esserci un modo per distinguere una locazione assegnata con valore indefinito da una libera

26. Operazioni sulla Memoria • μ(l)=omega valore speciale • μ(l)=Undef indefinita • EmptyStore crea una memoria ovunque indefinita μ(x)=Undef per ogni x

27. Allocazione di Memoria • free: Store---> Loc *Store • restitituisce una nuova locazione libera e la memoria modificata di conseguenza • free(μ) = (μ’,l) dove μ’(l’)= μ(l’) per ogni l’!= l μ’(l)=omega se μ(l)=Undef

28. Modifica di Memoria μ[v/l](l’)= μ(l’) se l != l’ Undef se μ(l)=Undef v altrimenti • l’operazione di modifica non effettua l’inserzione del legame per l nel caso non ne esista alcuno ma in questo ultimo caso, lascia la memoria invariata (da un punto di vista matematico va bene....)

29. Le funzioni di valutazione semantica • per ogni dominio sintattico esiste una funzione di valutazione semantica • E : EXPR * env * store  (eval * store) • C : COM * env * store  store • D : DEC * env * store  (env * store) • P : PROG * env * store  store

30. Implementazione in OCaml • Vediamo i domini • La Sintassi Astratta • Le funzioni di valutazione semantica che assegnano un significato ai vari costrutti, con una definizione data sui casi della sintassi astratta • Per semplicita’ nell’interprete si usano funzioni che restituiscono una coppia (ambiente, memoria) per ogni categoria sintattica

31. Programma PicoC • http://www.di.unipi.it/~occhiuto/PicoC/ • Generatore di programmi PicoC in sintassi astratta • Alcuni esempi di programmi PicoC in sintassi astratta per testare l`interprete

32. Valori Val=Int + {omega}+{Undef} type value = Val of int | Omega | Undef;;

33. Valori Denotabili Den = Loc ∪ FunDecl ∪ Unbound type denotation = Loc of int | Funct of string * com * sigma ref | Unbound;; • In FunDecl c’e’ il riferimento all’env (per trattare la ricorsione ..)

34. Frame • frame: Ide ---> Den (si usa la metavariabile φ) type fi = Frame of (string * denotation) list;; • Definizione molto a basso livello, una lista di coppie (identificatore, valore)

35. Ambiente • env=Stack(Frames) type sigma = Stack of fi list;; • Definizione molto a basso livello, una lista di frames

36. Memoria • μ : Loc ---> Val • type 'a mu = Mem of 'a list ;; • Definizione molto a basso livello, una lista polimorfa • Si usera’ per memorizzare coppie (identificatore, valore)

37. Espressioni • type aop = Add | Sub | Mul | Div | And | Or | Ls | Gr | Eq ;; • type unop = Neg | Amp | Star;; • type aExp = Num of int | Exp of aExp * aop * aExp | Bracket of aExp | UnExp of unop * aExp | Var of string | Apply of string * aExp ;;

38. Comandi • type com = Assign of string * aExp | AssignDeRef of aExp * aExp | If of aExp * com * com | While of aExp * com | Block of (stmt list) | Return of aExp;;

39. Dichiarazioni • type decl = Decl1 of espType * string | Decl2 of espType * string * aExp | DeclFun of espType * string * espType * string * com;;

40. Programmi type stmt = StDec of decl | StCom of com;; type prog = Prog of (stmt list);; • Un programma e’ una lista di statements (dichiarazioni, comandi)

41. Funzione main • let valProg (Prog l)= let (sigma,mu)= valStmtL l (Stack[Frame[]],(Mem []))in (mu,sigma);; • Il programma e’ valutato nello stato iniziale, lo stack contiene un frame vuoto e la memoria e’ vuota • restituisce lo stato ottenuto

42. Per valutare una lista di statements • Funzione ricorsiva (valStmtL) • Per ogni statement (comando o dichiarazione) chiama la funzione di valutazione corrispondente

43. Lista di Statements let valStmtL l (sigma, mu) = match l with| [] -> (sigma, mu)| st::stml -> (match st with | StDec d -> let (sigma1, mu1) = valDecl d (sigma,mu) in valStmtL stml (sigma1,mu1) | StCom c -> let (sigma1,mu1) = valCom c (sigma,mu) in valStmtL stml (sigma1,mu1));;

44. Dichiarazioni • valDecl: Decl * (env*mem)---> (env*mem) • Funzione ricorsiva (valDecl) • Usa valExp: Exp* (env*mem)---> (Val*env*mem)

45. Dichiarazioni • Variabile senza inizializzazione • Variabile con inizializzazione • Funzione

46. Sintassi Astratta • type decl = Decl1 of espType * string | Decl2 of espType * string * aExp | DeclFun of espType * string * espType * string * com;;

47. Funzioni Ausiliarie: memoria • free: Store---> Loc *Store • restitituisce una nuova locazione libera e la memoria modificata di conseguenza (alla nuova locazione viene assegnato il valore omega) type 'a mu = Mem of 'a list ;;

48. Implementazione let free (Mem xm) = let loc = (length xm) in ((Loc loc), (Mem (append xm [((Loc loc),Omega)] )));; • la lista e’ del tipo [(0,v1),(1,v20)...] • la prima locazione libera e’ detreminata con length

49. Modifica della Memoria • Serve una operazione updateM:Store*Loc*Val---> Store • Modifica la memoria rimpiazzando il valore associato alla locazione con il nuovo valore

50. Implementazione let rec updateM (Mem m) (x,y) = let def m x = foldr (or) false (map (compose ((=) x) (fst)) m) and modify m (x,y) = let f (x,y) b = if ((fst b)=x) then (x,y) else b in map (f(x,y)) m in if (not(def m x)) then (Mem m) else (Mem (modify m (x,y)));; Usa due funzioni ausiliarie def e modify per testare se la locazione x e’ definita e per modificarne il valore nella lista