Extension du langage while

Extension du langage while
Jean-Claude Fernandez
Extension du langage while – p.1/31
Sémantique opérationnelle structurelle: SOS
Une sémantique opérationnelle définit un système de transition.
Un système de transition est donné par:
(Γ, T, →) où
• Γ est l’ensemble de configurations.
• T ⊆ Γ est l’ensemble des configurations finales.
• →⊆ Γ × Γ est la transition de transition.
Dans le cas de la sémantique opérationnelle naturelle, on a :
1. Γ = (Stm × State) ∪ State.
2. T = State
3. → définie par des arbres d’inférence.
Extension du langage while – p.2/31
Sémantique opérationnelle structurelle: SOS
Le système de transition sera tel que par :
1. Γ = (Stm × State) ∪ State.
2. T = State
3. → définie par des séquences d’inférence.
Extension du langage while – p.3/31
Sémantique opérationnelle structurelle 1
Idée : Décrire comment le résultat de l’exécution d’un
programme est obtenu.
Sémantique décrite par un système d’inférence : axiomes et
règles.
(x := a, σ) ⇒ σ[x 7→ A[a]σ]
(skip, σ) ⇒ σ
(S1 , σ) ⇒ σ ′
(S1 ; S2 , σ) ⇒ (S2 , σ ′ )
(S1 , σ) ⇒ (S1′ , σ ′ )
(S1 ; S2 , σ) ⇒ (S1′ ; S2 , σ ′ )
Extension du langage while – p.4/31
Sémantique opérationnelle structurelle 2
Si B[b]σ = ff alors
(if b then S1 else S2 , σ) ⇒ (S2 , σ)
Si B[b]σ = tt alors
(if b then S1 else S2 , σ) ⇒ (S1 , σ)
(while b do S od , σ) ⇒ (if b then (S; while b do S od ) else skip, σ)
Extension du langage while – p.5/31
Séquence d’inférence
• Séquence fini :
γ1 , γ1 , · · · , γk où
• γi ⇒ γi+1 , pour i ∈ [1, k − 1] et
• γk 6⇒ c.a.d. qu’il n’existe aucune configuration γ avec
γk ⇒ γ . Dans ce cas, si γk n’est pas une configuration
finale, on l’appelle configuration bloquante.
• Séquence infini :
γ1 , γ1 , · · · où
γi ⇒ γi+1 , pour i ≥ 1
Donc, on ne considère que des séquence maximale.
Extension du langage while – p.6/31
Discussion sur les deux sémantiques opérationnelles
Comment modélisent-elles le fait qu’un programme divèrge?
• Sémantique naturelle :
Un programme S divèrge dans l’états σ , si (S, σ) n’a pas de
configuration successeur: (S, σ) 6→
6 ∃γ · (S, σ) → γ
• Sémantique structurelle :
Un programme S divèrge dans l’états σ , s’il y a une
séquence infini qui commence avec (S, σ).
Extension du langage while – p.7/31
Equivalence sémantique
• Sémantique naturelle :
S1 et S2 sont sémantiquement équivalents, si pour tout états
σ et σ ′ :
(S1 , σ) → σ ′ ssi (S2 , σ) → σ ′
• Sémantique structurelle :
S1 et S2 sont sémantiquement équivalents, si pour tout états
σ
• Pour toute configuration γ finale ou bloquante:
(S1 , σ) ⇒∗ γ ssi (S2 , σ) ⇒∗ γ
• Il existe une séquence inifni qui commence avec (S1 , σ)
ssi il existe une séquence inifni qui commence avec
(S2 , σ).
Extension du langage while – p.8/31
La fonction sémantique Ssos
Ssos [S]σ =
(
σ′
; Si (S, σ) ⇒∗ σ ′
undef ; sinon
Question
a-t-on Sns = Ssos ?
Lemme Pout tout S , σ et σ ′
Si (S, σ) → σ ′ alors (S, σ) ⇒∗ σ ′ .
Lemme
Pout tout S , σ et σ ′
2
Si (S, σ) ⇒k σ ′ alors (S, σ) → σ ′ .
2
Extension du langage while – p.9/31
Styles de sémantique et principes de preuve associés
• Sémantique inductive: ex. A.
Preuve par induction structurelle sur les expressions
arithmétiques.
• Sémantique opérationnelle naturelle.
Relation de transition définie par les arbres d’inférence.
Preuve sur la structure de l’arbre d’inférence.
• Sémantique opérationnelle structurelle.
Relation de transition définie par les séquences d’inférence.
Preuve par récurrence sur la longueur de la séquence
d’inférence.
Extension du langage while – p.10/31
Lemmes intermédiaires
Lemme
Pout tout S , σ et σ ′
Si (S, σ) → σ ′ alors (S, σ) ⇒∗ σ ′ .
2
Preuve On montre d’abord
Si (S1 , σ) ⇒k σ ′ alors (S1 ; S2 , σ) ⇒k (S2 ; σ ′ )
Preuve de Lemme par induction sur la structure de l’arbre de
dérivation de (S, σ) → σ ′ .
2
Extension du langage while – p.11/31
Lemmes intermédiaires 2
Lemme
Pout tout S , σ et σ ′
Si (S, σ) ⇒k σ ′ alors (S, σ) → σ ′ .
2
Preuve On montre d’abord Si (S1 ; S2 , σ) ⇒k σ ′′ alors il existe σ ′
et k1 avec :
(S1 , σ) ⇒k1 σ ′ et (S2 , σ ′ ) ⇒k−k1 σ ′′ .
Preuve de Lemme par reccurrence sur k : (S, σ) ⇒k σ ′ .
2
Extension du langage while – p.12/31
Extensions du langage While
• La commande abort. La configuration (abort, σ) n’a pas de
sucesseur. C’est le blocage.
• La commande or : S1 or S2 .
On dénote le langage obtenu par Whileor .
Configuration :
{(S, σ) | S ∈ Whileor , σ ∈ State} ∪ State.
Extension du langage while – p.13/31
Règles de transition pour or
• Règles de transition pour SN :
(S1 , σ) → σ ′
(S1 or S2 , σ) → σ ′
(S2 , σ) → σ ′
(S1 or S2 , σ) → σ ′
• Règles de transition pour SOS :
(S1 or S2 , σ) ⇒ (S1 , σ)
(S1 or S2 , σ) ⇒ (S2 , σ)
Extension du langage while – p.14/31
Discussion
Dans la sémantique naturelle le or "cache" la non-terminaison.
Exemple Soit S1 = while true do skip od et
S2 = while false do skip od .
(S1 or S2 , σ) → σ
Mais (S1 or S2 , σ) aura toujours une séquence infini dans SOS. 2
Extension du langage while – p.15/31
La mise en parallèle
On ajoute la commande k : S1 k S2 .
On dénote le langage obtenu par Whilek .
Configuration : {(S, σ) | S ∈ Whilek , σ ∈ State} ∪ State.
Règles de transition pour or
• Règles de transition pour SN :
(S1 ,σ)→σ ′ , (S2 ,σ ′ )→σ ′′
(S1 k S2 ,σ)→σ ′′
(S2 ,σ)→σ ′ , (S1 ,σ ′ )→σ ′′
(S1 k S2 ,σ)→σ ′′
• Règles de transition pour SOS :
(S1 , σ) ⇒ (S1′ , σ ′ )
(S1 k S2 , σ) ⇒ (S1′ k S2 , σ ′ )
(S2 , σ) ⇒ (S2′ , σ ′ )
(S1 k S2 , σ) ⇒ (S1 k S2′ , σ ′ )
Extension du langage while – p.16/31
Discussion concernant le k
La sémantique naturelle ne permet pas d’exprimer une
sémantique d’entrelacement (interleaving semantics).
La sémantique structurelle le permet.
Extension du langage while – p.17/31
Conclusion
Sémantique naturelle
• ne distingue pas entre blocage et non-terminaison
• non-determinisme "cache" la non-terminaison
• ne permet pas d’exprimer la sémantiqued’entrelacement
Sémantique structurelle
• distingue entre blocage et non-terminaison
• non-determinisme ne "cache" pas la non-terminaison
• permet d’exprimer la sémantiqued’entrelacement
Extension du langage while – p.18/31
Introduction des exceptions : break
Provoque l’arrêt de l’exécution de la boucle immédiatement
englobante ou, à défaut du bloc immédiatement englobant. Les
configurations terminales sont alors State ∪ {stopb } × State.On
rajoute, pour la construction break, la règle suivante :
(break, σ) −→ (stopb , σ)
Extension du langage while – p.19/31
Introduction des exceptions : break
Composition séquentielle: us rajoutons la possibilité de déclarer
des exceptions et de traiter les exceptions nommées.
(S1 , σ) −→ (stopb , σ ′ )
(S1 ; S2 , σ) −→ (stopb , σ ′ )
(S1 , σ) −→ σ ′ (S2 , σ ′ ) −→ (stopb , σ ′′ )
(S1 ; S2 , σ) −→ (stopb , σ ′′ )
Extension du langage while – p.20/31
Introduction des exceptions : break
While
Bloc
(S, σ) −→ (stopb , σ ′ )
B[b]σ = tt
′
(while b do S od, σ) −→ σ
(Dv , σ) −→ σ1
(S, σ1 ) −→ (stopb , σ ′ )
(begin DV ; S end, σ) −→ σ ′ [DV (DV ) 7→ σ]
Extension du langage while – p.21/31
Introduction des exceptions : exit
Cette instruction provoque l’arrêt du programme en cours
d’exécution. Les nouvelles configurations terminales sont alors
State ∪ {stopb } × State ∪ {stope } × State.
Bloc
(DV , σ) −→ σ1
(S, σ1 ) −→ (stope , σ ′ )
(begin DV ; S end, σ) −→ (stope , σ ′ [DV (DV ) 7→ σ])
Extension du langage while – p.22/31
Introduction des exceptions : raise
possibilité de déclarer des exceptions et de traiter les exceptions
nommées. La syntaxe d’un bloc devient :
S ::= begin DE ; DV ; S; T end
Les déclarations d’exceptions se font de manière analogue aux
déclarations de variables :
DE ::= exception e; DE | ǫ
Un exception est provoquée par la commande raise e.
Le traitement d’exception, à la fin du bloc, prend la forme
suivante :
T ::= when e =⇒ S; T
La syntaxe des commandes devient alors :
S ::= x := a | skip | S; S | if b then S else S | while b do S od | be
break | exit | raise e
Extension du langage while – p.23/31
Introduction des E/S
On rajoute au langage while deux commandes :
S ::= · · · | read(x) | write(a)
• La commande read(x) prend en entrée un entier et le
range dans la mémoire associée à x,
• La commande write(a) écrit la valeur associée à a.
on modifie les configurations de la manière suivante : (S, i, o, σ)
où S désigne une commande, i la séquence d’entiers en entrée,
o, la séquence d’entiers en sortie et σ la mémoire. Par exemple,
l’axiome
(x := a, σ) → σ[x 7→ A[a]σ]
devient
(x := a, i, o, σ) → (i, o, σ[x 7→ A[a]σ])
Extension du langage while – p.24/31
Introduction des E/S
Entrée
(read(x), v : i, o, σ) → (i, o, σ[x 7→ x])
Sortie
(write(a), i, o, σ) → (i, v : o, σ)
Extension du langage while – p.25/31
Des expressions qui modifient la mémoire ?
Extension du langage while – p.26/31
Un interpréteur pour le langage while
Structure de données :
typedef struct node{
int type_node ; /*oper ou feuille */
leaf val_node ;
struct node *fg ;
struct node *fd ;
struct node *els ;
} NODE;
typedef NODE *PTR_NODE ;
Extension du langage while – p.27/31
Expressions arithmétiques
int EvalAexp(n,m)
NODE *n;
MEM *m;
{
switch(n->type_node) {
case PLUS:
return(EvalAexp(n->fg,m)+EvalAexp(n->fd,m)) ;
case MOINS:
return(EvalAexp(n->fg,m)-EvalAexp(n->fd,m)) ;
case MULT:
return(EvalAexp(n->fg,m)*EvalAexp(n->fd,m)) ;
case NUM:
return((n->val_node).u_int) ;
case IDF:
return(EvalMem(m,(n->val_node).u_char));
}
}
Extension du langage while – p.28/31
Expressions booléennes
int EvalBexp(n,m)
NODE *n;
MEM *m;
{
switch(n->type_node) {
case AND:
return(EvalAexp(n->fg,m)&&EvalAexp(n->fd,m)) ;
case EGAL:
return(EvalAexp(n->fg,m)==EvalAexp(n->fd,m)) ;
case INF:
return(EvalAexp(n->fg,m)<EvalAexp(n->fd,m)) ;
case TRUE:
return(True) ;
case FALSE:
return(False);
}
}
Extension du langage while – p.29/31
Un interpréteur pour les instructions
PTR_MEM interprete(n,m)
NODE *n;
MEM *m;
{
int val ;
switch(n->type_node) {
case ASSIGN:
val=EvalAexp(n->fd,m);
m=maj_mem(m,((n->fg)->val_node).u_char,val) ;
return(m);
case SEMI_COLON:
m=interprete(n->fg,m);
m=interprete(n->fd,m);
return(m);
Extension du langage while – p.30/31
Un interpréteur pour les instructions
case WHILE:
val=EvalBexp(n->fg,m);
if(val) {
m=interprete(n->fd,m);
m=interprete(n,m);
return(m);
}
return (m);
case IF:
val=EvalBexp(n->fg,m);
if(val) {
m=interprete(n->fd,m);
return(m);
} else {
m=interprete(n->fd,m);
return (m);
}
Extension du langage while – p.31/31