INE 11

(1)

Principes des lang. de progr.

INE 11

Michel Mauny

Inria-Paris

prénom.nom@inria.fr

Michel Mauny (Inria-Paris) INE 11 prénom.nom@inria.fr 1 / 26

Sémantique opérationnelle

1 Sémantique opérationnelle

Évaluation stricte du noyau fonctionnel d’un petit langage Ajout de données structurées

Évaluation non stricte

2 Interprétation

3 Compilation

Sémantique dénotationnelle vs. opérationnelle

Sémantique dénotationnelle (pour ceux qui ont lu le chapitre) valeurs abstraites

le sens, pas le calcul.

quid des programmes qui ne terminent pas ?

quid des programmes qui produisent une erreur d’exécution ? Sémantique opérationnelle

utilise des valeurs concrètes (syntaxiques) explicite les étapes du calcul

procède par «réduction» (transformation syntaxique) du programme initial

des catégories syntaxiques + des règles d’inférence G. Plotkin, 1981 ; G. Kahn 1985 (sémantique «naturelle»)

(2)

Noyau fonctionnel : évaluation stricte

Le langage

c∈Const Constantes, incluant les fonctions primitives x∈Id Identificateurs

e∈Exp Expressions

Syntaxe

e ::= c|x |e1+e2 |e1=e2

| ife₁ thene₂else e₃

| e₁e₂

| funx → e

| letx=e1 ine2

| let rec f(x) =e1in e2

Noyau fonctionnel, évaluation stricte

Valeurs

v ::= c|Valf(x,e, ρ)|Valfr(f,x,e, ρ)

ρenvironnement :x∈Id→v ρ⊕[x7→v]: extension deρ

(ρ⊕[x7→v])(x) =v

(ρ⊕[x7→v])(y) =ρ(y)poury6=x

Valf et Valfr : valeurs fonctionnelles (fermeturesouclosures) Réponses

r ::= v |Erreur Règles d’évaluation

définissent des «jugements» de la forme ρ`e⇒r

«Dans l’env.ρ, l’évaluation de l’expressioneproduit la réponser.»

Langage fonctionnel, strict : règles d’inférence

^1/4

Règles : elles ont un nom, et sont des axiomes ou bien des implications

Constantes, variables, fonctions

ρ`c⇒c (Const) x∈dom(ρ)

ρ`x⇒ρ(x) (Ident)

ρ`(funx → e)⇒Valf(x,e, ρ) (Fun) Conditionnelle

ρ`e₁⇒T ρ`e₂⇒r

ρìfe1then e2 elsee3⇒r (IfTrue) ρè₁⇒F ρè₃⇒r

ρ`ife1 thene2else e3⇒r (IfFalse)

(3)

Langage fonctionnel, strict : règles

^2/4

Primitives

ρ`e1⇒n1 ρ`e2⇒n2 n=n1+n2

ρ`(e1+e2)⇒n (Plus)

ρ`e1⇒v1 ρ`e2⇒v2 v1=v2

ρ`(e1=e2)⇒T (EgTrue)

ρ`e1⇒v1 ρ`e2⇒v2 v16=v2

ρ`(e1=e2)⇒F (EgFalse)

Langage fonctionnel, strict : règles

^3/4

Déclarations

ρ`e₁⇒v₁ ρ⊕[x 7→v₁]`e₂⇒r ρ`(let x=e₁ ine₂)⇒r (Let)

ρ⊕[f 7→Valfr(f,x,e₁, ρ)]`e₂⇒r

ρ`(let rec f(x) =e₁ ine₂)⇒r (Letrec)

Langage fonctionnel, strict : règles

^4/4

Applications

ρè₁⇒Valf(x,e₀, ρ₀) ρè₂⇒v₂ ρ0⊕[x7→v₂]è₀⇒r

ρ`(e1e2)⇒r (AppF)

ρè₁⇒Valfr(f,x,e₀, ρ₀) ρè₂⇒v₂ ρ0⊕[f 7→Valfr(f,x,e0, ρ0)]⊕[x7→v2]è0⇒r

ρ`(e1e2)⇒r (AppFR)

(4)

Les règles auxquelles vous avez échappé

Production d’erreurs et propagation

x6∈dom(ρ)

ρ`x⇒Erreur(IdentErr) ρ`e₁⇒r6∈ {T,F}

ρ`ife₁thene₂elsee₃⇒Erreur(IfErr)

ρ`e₁⇒r6∈N

ρ`(e₁+e₂)⇒Erreur(PlusErrL) ρ`e₁⇒n₁ ρ`e₂⇒r6∈N ρ`(e₁+e₂)⇒Erreur (PlusErrR)

ρ`e₁⇒Erreur

ρ`(e₁=e₂)⇒Erreur(EgErrL) ρ`e₁⇒v₁ ρ`e₂⇒Erreur ρ`(e₁=e₂)⇒F (EgErrR)

ρ`e₁⇒Erreur

ρ`(letx=e₁ine₂)⇒Erreur(LetErr) ρ`e₁⇒r6=Valf(_,_,_)∧r6=Valfr(_,_,_,_) ρ`(e₁e₂)⇒Erreur (AppErrL)

ρ`e1⇒Valf(x,e0, ρ0) ρ`e2⇒Erreur ρ`(e₁e₂)⇒Erreur (AppFErrR)

ρ`e₁⇒Valfr(f,x,e₀, ρ₀) ρ`e₂⇒Erreur

ρ`(e₁e₂)⇒Erreur (AppFRErrR)

Arbres d’évaluation – dérivations

Arbres :axiomes = feuilles, règles d’inférence = nœuds

Posonsf =Valf(x,x,∅)etρ_f =∅ ⊕[f 7→f] = [f 7→f].

f ∈dom(ρf)

ρf `f ⇒f ρf `1⇒1

x ∈dom(∅ ⊕[x7→1])

∅ ⊕[x7→1]`x⇒1

ρf `f(1)⇒1 ^(App)

(Fun)

∅ `(funx → x)⇒f

∅ `(letf =funx → x inf(1))⇒1 (Let)

Données structurées

Couples et projections

e ::= . . . |(e1,e2)|fst e|snde

Valeurs

v ::= . . . |(v1,v2)

Règles

ρ`e₁⇒v₁ ρ`e₂⇒v₂ ρ`(e1,e2)⇒(v1,v2)

ρ`e⇒(v₁,v₂) ρ`fst e⇒v1

ρ`e⇒(v₁,v₂) ρ`snde⇒v2

(5)

Langage fonctionnel : évaluation non-stricte

^1/4

Coder les calculs suspendus : suspensions s ::= he, ρi

Valeurs v ::= c

| Valf(x,e, ρ)|Valfr(f,x,e, ρ)

| (he1, ρ1i,he2, ρ2i)

Évaluation des couples : suspension des composantes ρ`(e₁,e₂)⇒(he₁, ρi,he₂, ρi)

⇒les composantes de couples sont toujours des suspensions

De l’évaluation (formelle) à l’interprétation (mécanique)

Implémenter les valeurs de la sémantique opérationnelle : v ::= c |Valf(x,e, ρ)|Valfr(f,x,e, ρ)

par :

typesemopval=

| Intvalofint

| Boolvalofbool

| Stringvalofstring

| . . .

| Funvalof{param:string;body:expr;env:environment}

| Funrecvalof{fname:string;param:string;body:expr;env:environment}

andenvironment= (string∗semopval)list;;

On considère qu’uneréponsesera ou bien une valeur, ou alors la levée d’une exception OCaml.

De l’évaluation à l’interprétation

Puis «lire» les axiomes et règles d’inférence comme des cas d’une fonction d’évaluation :

val eval:Pcfast.expr→environment→semopval let rec eval t rho=matchtwith. . .

| Pcfast.EInt n→Intval n (∗ ρ`c⇒c ∗)

| Pcfast.EString s→Stringval s (∗ ρ`c⇒c ∗)

| Pcfast.EIdent x→begin

try List.assoc x rhowith (∗ x∈dom(ρ) ρ`x⇒ρ(x) ∗) Not_found→

error(Printf.sprintf "Unbound variable %s." x) end

| . . .

(6)

De l’évaluation à l’interprétation

Les axiomes et règles d’inférence comme des cas d’une fonction d’évaluation :

let rec eval t rho=matchtwith. . .

| Pcfast.EFun(x,e)→ (∗ ρ`(funx→e)⇒^Valf(x,^{e, ρ)}∗) Funval{param=x;body=e;env=rho}

| Pcfast.EIf(e1,e2,e3) → begin

matcheval e1rhowith (∗ ^ρ^`^e¹^⇒^T ^ρ^`^e²^⇒^r

ρ`ife₁thene₂elsee₃⇒r ∗)

| Boolvaltrue→ eval e2rho

| Boolvalfalse→ eval e3rho (∗ ^ρ^`^e¹^⇒^F ^ρ^`^e³^⇒^r

ρ`ife₁thene₂elsee₃⇒r ∗)

| _ → error "Boolean value expected"

end

| . . .

De l’évaluation à l’interprétation

| Pcfast.EBinop("+",e1,e2)→ begin (∗ ^ρ^`^e¹^⇒ⁿ¹ ^ρ^`^e²^⇒ⁿ²

ρ`(e₁+e₂)⇒n₁+n₂ ∗) match(eval e₁ rho,eval e2 rho)with

| (Intval n₁,Intval n2)→ Intval(n₁+n₂)

| _ → error "Integer values expected"

end

| . . .

De l’évaluation à l’interprétation

| Pcfast.ELet(x,e1,e2) → (∗ ^ρ^`^e¹^⇒^v¹ ^ρ^⊕^[x^7→^v¹^]^`^e²^⇒^r

ρ`(letx=e₁ine₂)⇒r ∗) let v1 =eval e1rhoin

eval e2((x,v1)::rho)

| Pcfast.ELetrec(f,x,e1,e2) → (∗ ^ρ^⊕ρ`^[f(let rec^7→^Valfr(ff(x) =^,^x,^ee¹₁^{, ρ)]}ine^`₂)^e²⇒^⇒r ^r ∗) let vf =Funrecval{fname=f;param=x;body=e1;env=rho}in eval e2((f,vf)::rho)

| . . .

(7)

De l’évaluation à l’interprétation

Des axiomes et règles d’inférence aux cas d’une fonction d’évaluation let rec eval t rho=matchtwith

. . .

| Pcfast.EApp(e1,e2)→

let (vf,v2) = (eval e1 rho,eval e2 rho)in begin matchvf with

(∗ ^ρ^`ê²^⇒^ρ^v^`²ê¹^⇒^ρ⁰^Valf(x,e^⊕^[x^7→⁰^{, ρ}^v²⁰^]⁾^`ê⁰^⇒^r

ρ`(e₁e₂)⇒r

∗)

| Funval{param=x;body=e0;env=rho0}→eval e0((x,v2)::rho0) (∗ ^ρ⁰^ρ^⊕^`^[fê^7→¹^⇒^Valfr(f^Valfr(f^,x,^,x,ê⁰ê^{, ρ}⁰^{, ρ}⁰^)]⁰⁾^⊕^[x^7→^ρ^`^v²ê^]²^`^⇒ê⁰^v²^⇒^r

ρ`(e₁e₂)⇒r

∗)

| Funrecval{fname=f;param=x;body=e₀;env=rho₀}→ eval e0((x,v₂)::(f,vf)::rho₀)

| _ → error "Expecting a functional value"

;;end

De l’interprétation à la compilation

Interprète

+ environnements, valeurs

− gestion du contrôle par le langage hôte

(Modèle de) Compilateur + environnements, valeurs

+ gestion explicite du contrôle (pile)

Machine abstraite

code, pile, registre, (mémoire,etc.) instruction : état→état

Compilation

Le langage

e ::= c|x |e₁e₂ |funx → e|ife₁ thene₂ elsee₃

| e1+e2|e1=e2

Codage de de Bruijn des occurrences de variables

occurrence dexdans un contexte oùnlieurs («fun y →»,

«let y=» ou «let f(y) =») séparent cette occurrence de son lieur, est codée par un accès à une profondeurndans un environnement : Access(n)

Exemples funx → x

Access(0)

funx → let y= ... in let z= ... in funt → ... x ...

Access(3)

(8)

Compilation

État de la machine(registre,code,pile)

registre: contient une valeur ou un environnement code: instructions

pile: chaque élément est valeur, ou env., ou adresse de retour Les instructions

i ::= Loadi(n)|Loadb(b) chargement de cst dans le registre

| Plus|Equal opérations binaires (arith, tests, ...)

| Access(n) accès dans env.

| Branch(c₁,c₂) branchement

| Push|Swap empile, échange

| Mkclos(c) constr. de valeur fonctionnelle

| Apply application

La machine dans tous ses états

État État suivant

(r,Loadi(n) ::c,p) ⇒ (n,c,p) (r,Loadb(b) ::c,p) ⇒ (b,c,p) (n,Plus::c,m::p) ⇒ (n+m,c,p) (n,Equal::c,m::p) ⇒ (n=m,c,p) (true,Branch(c1,c₂) ::c,r ::p) ⇒ (r,c₁,c::p) (false,Branch(c1,c2) ::c,r ::p) ⇒ (r,c2,c::p) (r,Push::c,p) ⇒ (r,c,r ::p) (r₁,Swap::c,r₂::p) ⇒ (r₂,c,r₁::p) (r,Mkclos(c1) ::c,p) ⇒ (hc₁,ri,c,p) (v,Apply::c,hc₀,r₀i::p) ⇒ ((v,r₀),c₀,c::p)

(ρ,Access(n) ::c,p) ⇒ (ρ(n),c,p) (r,[ ],c::p) ⇒ (r,c,p)

La machine dans tous ses états (en OCaml)

let next state=matchstatewith

(r, Loadi n::c, p) → (I(n), c, p)

| (r, Loadb b::c, p) → (B(b), c, p)

| (I(n), Plus::c, I(m)::p) → (I(n+m),c, p)

| (I(n), Equal::c, I(m)::p) → (B(n=m),c, p)

| (B(true), Branch(c1,c2)::c, r::p) → (r, c1, A(c)::p)

| (B(false), Branch(c1,c2)::c, r::p) → (r, c2, A(c)::p)

| (r, Push::c, p) → (r, c, r::p)

| (r1, Swap::c, r2::p) → (r2, c, r1::p)

| (r, Mkclos(c1)::c, p) → (C(c1, r), c, p)

| (v, Apply::c, C(c0,r0)::p) → (E(v,r0), c0, A(c)::p)

| (E(v,r), Access(0)::c, p) → (v, c, p)

| (E(v,r), Access(n)::c, p) → (r, Access(n−1)::c,p)

| (r, [ (∗ ret ∗) ], A(c)::p) → (r, c, p)

| (r, [ ] , [ ] ) → raise(Success r)

| _ → error "Error: invalid state (machine stopped)"

(9)

La compilation

Compilation du noyau

[[n]]_ρ = Loadi(n)

[[b]]_ρ = Loadb(b)

[[x]]_ρ = Access(n)

oùnest la profondeur dex dansρ [[e₁e₂]]_ρ = Push; [[e1]]_ρ;Swap; [[e2]]_ρ;Apply [[ife₁thene₂ elsee₃]]_ρ

= Push; [[e1]]_ρ;Branch([[e2]]_ρ,[[e₃]]_ρ) [[funx → e]]_ρ = Mkclos([[e]]_x,ρ)

[[letx=e1 in e2]]_ρ = [[(funx → e2)e1]]_ρ

Compilation des définitions récursives ? Laissée en exercice

Conclusion

La sémantique opérationnelle

précise comments’effectuent les calculs se rapproche des interprètes

La compilation

consiste essentiellement à expliciter le contrôle (manipulation de pile)