Université Chouaïb Doukkali Filière : SMI

Faculté des Sciences, Département d’Informatique Année Universitaire 2018-

2019

Correction de l’Examen
Théorie des langages et compilation

Questions du cours
1- Décrire toutes les phases d’un compilateur.
Un compilateur typique se décompose en 6 phases élémentaires :
Analyseur lexical qui permet de reconnaître les unités lexicales
Analyseur syntaxique qui permet de vérifier les entités en entrée apparaissent
conformément ou non aux règles définissent la grammaire du langage.
Analyseur sémantique qui permet de contrôler la cohérence sémantique du
programme source.
Générateur de code intermédiaire qui permet de construire une représentation
intermédiaire des programmes sources indépendante de tous les langages de
programmations.
Optimiseur de code qui permet d’améliorer le code intermédiaire par la réduction du
nombre de variables et d’instructions
Générateur de code final qui permet de choisir des emplacements mémoire pour les
variables et de les assigner aux registres.
Gestion de table des symboles qui permet de stocker toutes les informations
nécessaires sur les lexèmes du programme source
Gestion des erreurs qui permet signaler et traiter une erreur détecté, de telle façon que
le compilateur puisse continuer son traitement et que d’autre erreurs puissent être
détectées.
2- La grammaire G(VT,VN,R,S) est une notation utilisée pour la description de la syntaxe
d’un langage telle que:
VT: l’ensemble fini de symboles dits terminaux
VN: Ensemble fini de symboles non terminaux qui représente les noms attribués aux
productions constituant la grammaire du langage.
R: Ensemble de règles de productions de la forme g → d tel que g∈(VTỤ VN)+ et
d∈(VTỤ VN)*
S: Symbole non-terminal particulier appelé axiome.
Un automate est un modèle mathématique (ou une machine abstraite) qui permet de
lire un mot et déterminer si un mot requête appartient à un langage L.
LL(1) : Soit G=(VT,VN,R,S) une grammaire hors-contexte
La grammaire G est de type LL(1) si et seulement si pour toutes les productions de la
forme A → β1|β2| ……|βn :
∀ i≠j First(βi) ∩ First(βj)=Φ
1
 Si ∃ i tel que βi ε alors Follow(A)∩First(βj)=Φ ∀ j
Si ∃ i tel que βi ε alors ∀ j≠i , βj≠ε
Exercice 1
1- AFD de l’automate

Etat a b c
p p p,q r,q,p
p,q p,q q,r,p r,p ,q
p,r,q p,q,r q,r,p r,q,p

Eta a b c
t
0 0 1 2
1 1 2 2
2 2 2 2
a

1
b,c a,b,c
a b

0 2
c
Exercice 2
1- La grammaire hors-contexte qui génère le langage a ͫ b ͫ (m≥0) :
G(VT,VN,R,S) telle que : VT ={a,b}, VN ={S}, R={S→aSb| ε }
2- Transformer G à une grammaire G1 hors contexte propre.
S→aSb| ε
Etape 1
S’ →S
S’→aSb| ε
Etape 2
S’ → aSb|ab| ε
S→ aSb| ab
3- La Forme normale de Chomsky.
Soit A→a, U→SB et B→b Alors S→aSb implique
S’ →AU
A→a
U→SB
B→b
Et S→ab|ε implique
S’→AB
S→ ε
Donc la forme normale de Chomsky de G1 est
S’→AU
S →AB

2
 S→ ε
A→a
U→SB
B→b
4- L’automate à pile du langage L est :
A1=({q0,q1,q2},{A},{a,b},&,q0 Z,{q2})
δ (q0,a,Z)=(q1,aZ)
δ (q1,a,A)=(q1,AA)
δ (q1,b,A)=(q2, ε)
δ (q2,b,A)=(q2, ε)
Exercice 3
1. Les ensembles First et Follow pour les symboles non terminaux de G sont:
First(S)={a,b} ; First(T)={a,c}; First(U)={a,b,ε}
Follow(S)={a,b,c,$} ; Follow(T)={a,b}; Follow(U)={a,b}
2. G n’est pas de type LL(1) car : Follow(U)∩First(S)≠Ø.
3. les quatre états I0=Fermeture({E→•S}), Ii=Transition(I0,a), Ij=Transition(I0,b) et
Ik=Transition(Ii,c) de l’AFD de G augmentée par la production E→S sont :
I0=Ferm({E→•S})={E→•S, S→•bSTa, S→•aTb}
Ii=Tan(I0,a)=Ferm({S→a•Tb})={S→a•Tb, T→ •abS, T→ •cU}
Ij=Tran(I0,b)=Ferm({S→b•STa})={S→b•STa, S→•bSTa, S→•aTb}
Ik=Tran(Ii,c)=Ferm({T→ c•U})={T→ c•U, U→ •S, U→ •, S→•bSTa, S→•aTb}
L’état Ik, contient les deux items suivants : S→•bSTa, U→•, et on peut vérifier facilement
que Ij=Transition(Ik,b) et on a aussi b∈Follow(U), donc Action[k][b]=r6 et Action[k][b]=dj,
alors il y a un conflit D/R dans cet état par le symbole b, ce qui implique que l’algorithme
SLR(1) est incapable de gérer la grammaire G.
4.
Les ensembles First et Follow pour les symboles non terminaux de G1 sont:
First(S)={a,b} ; First(T)={a,c}.
Follow(S)={a,b,c,$} ; Follow(T)={a,b}.
Calcul de l’ensemble C :
I0=Ferm({E→•S})={E→•S, S→•bSTa, S→•aTb}
I1=Tran(I0,S)=Ferm({E→S•})={E→S•}
I2=Tran(I0,a)=Ferm({S→a•Tb})={S→a•Tb, T→•abS, T→•c}
I3=Tran(I0,b)= Ferm({S→b•STa})={S→b•STa, S→•bSTa, S→•aTb}
I4=Tran(I2,T)= Ferm({S→aT•b})= { S→aT•b }
I5=Tran(I4,b)=Ferm({S→aTb•})={ S→aTb•}
I6=Tran(I2,c)=Ferm({T→c•})={ T→c•}
I7=Tran(I2,a)=Ferm({T→a•bS})={T→a•bS}
I8=Tran(I7,b)=Ferm({T→ab•S })={T→ab•S, S→•bSTa, S→•aTb}
I9=Tran(I8,S)=Ferm({T→abS•})={ T→abS•}
I2=Tran(I8,a)
I3=Tran(I8,b)
I2=Tran(I3,a)

3
 I3=Tran(I3,b)
I10=Tran(I3,S)=Ferm({S→bS•Ta})={ S→bS•Ta, T→•abS, T→•c }
I7=Tran(I10,a)
I6=Tran(I10,c)
I11=Tran(I10,T)= Ferm({S→bST•a})= { S→bST•a}
I12=Tran(I11,a)=Ferm({S→bSTa•})={ S→bSTa•}
Construction de l’AFD :
I0
E→•S I1
S→•bSTb S E→S•
S→•aTb
a
b I2 I4 I5
b T b
I3 S→a•Tb S→aT•b S→aTb•
S→b•STa T→•abS
S→•bSTb a T→•c
c I6
S→•aTb
a
I7 T→c•
S
I10
a T→a•bS
S→bS•Ta
a
T→•abS
b b
T→•c I8
T T→ab•S
I11 S→•bSTb
S→•aTb c
S→bST•a
S
a I9
I12 T→abS•
S→bSTa•

Construction de la table d’analyse par l’algorithme SLR(1) :

Action Successeur
a b c $ S T
0 d2 d3 1
1 succès
2 d7 d6 4
3 d2 d3 10
4 d5
5 r2 r2 r2 r2
6 r4 r4
7 d8
8 d2 d3 9
9 r3 r3

4
 10 d7 d6 11
11 d12
12 r1 r1 r1 r1
Avec : 1)S→bSTa , 2)S→aTb , 3)T→abS , 4)T→c
L’analyse des deux mots M1=bacbca$ et M2= bacca$:
M1= bacbca$

Pile Tampon Action

I0$ bacbca$ d3
I3I0$ acbca$ d2
I2I3I0$ cbca$ d6
I6I2I3I0$ bca$ r4
I4I3I2I0$ bca $ d5
I5I4I3I2I0$ ca$ r2
I10I3I0$ ca$ d6
I6I10I3I0$ a$ r4
I11I10I3I0$ a$ d12
I12I11I10I3I0$ $ r1
I1I0$ $ succès
M2= bacca$

Pile Tampon Action

I0$ bacca$ d3
I3I0$ acca$ d2
I2I3I0$ cca$ d6
I6I2I3I0$ ca$ erreur