Vous êtes sur la page 1sur 329

Théorie des langages et

Compilation

Prof. Leila Ben Ayed

Ecole Nationale des Sciences de l’Informatique


ENSI - Université la Manouba - Tunis
Théorie des Langages et
Compilation
Objectif. Ce cours présente la théorie des langages en traitant trois aspects :
L’aspect reconnaissance par les automates finis, les automates à pile et les
machines de turing, L’aspect génération par les grammaires régulières, non
contextuelles et contextuelles, et L’aspect représentation par propriétés
mesurables, définitions récursives et expressions régulières. L’objectif est
d’introduire des connaissances en théorie des langages et des automates afin
de pouvoir les étendre à la description des langages de programmation et leur
analyse syntaxique en vue de leur compilation.
Un mini compilateur fera l’objet d’un projet de ce module.
Références. A. Aho, R. Sethi et J. Ullman, Compilateurs Principes,
Techniques et Outils, InterEditions, Paris, 1991.
- P. Walper, Introduction à la Calculabilité, Dunod, Paris, 2001.
-G. Dowek et J. Lévy, Introduction à la théorie des langages de programmation,
Éditions de l'École polytechnique, Paris, 2006.
Théorie des langages et
Compilation
Langages
Processus Réguliers Hors contexte Dépendants du
contexte
Représentation ExpressionsPropriété Propriété
régulières mesurable mesurable + Compilation
+ Définition
Définition Récursive Analyse lexicale
Récursive Analyse
Reconnaissance Automates Automates à Machines de syntaxique
finis Pile Turing
Analyse
Génération Grammaires Grammaires Grammaires sémantique
régulières Non contextuelles
contextuelles
Théorie des langages

I. Mots et langages
II. Les automates finis et les langages réguliers
III. Les grammaires
IV. Les grammaires non contextuelles
V. Les automates à piles
VI. Les machines de Turing
VII. Décidabilité

C pour TLC (Compilation)


Mini projet TLC
I. Mots et langages
Plan

I.1. Vocabulaire et Mot


I.2. Langage
I.3. Opérations sur les langages
I.4. Propriétés des langages
I.5. Définition des langages
I.6. Le lemme d’Arden
Leila Ben Ayed Théorie des Langages et Compilation 5
I.1. Vocabulaire et mot Exercices
Définition 1. Alphabet: Un alphabet (ou vocabulaire) est un
ensemble fini, non vide de symboles. On le note
généralement X.

Définition 2. Fermeture: Soit X, un alphabet. On note par


X*, l’ensemble de toutes les séquences finies de symboles
de X.

Rq le symbole * est une fonction qui, appliquée à un


ensemble non vide X, donne un autre ensemble infini X*.
On dit que X* est la fermeture de X.

Leila Ben Ayed Théorie des Langages et Compilation 6


I.1. Vocabulaire et mot

Définition 3. Chaine vide: Une chaine vide est une chaine


qui ne contient aucun symbole du vocabulaire ( appelée
aussi mot vide). Une chaine vide est un élément de X*. On
la note : 

Définition 4. Longueur d’une chaine: La longueur d’une


chaine finie  est le nombre de symboles qu’elle contient.
On la note ||.

Leila Ben Ayed Théorie des Langages et Compilation 7


I.1. Vocabulaire et mot
Définition 5. Mot : Un mot  est une application d’un
segment initial de longueur n vers le vocabulaire:
 : [n]  X

Où i est l’image de i dans X; i est le rang de i dans ;


si i = a et a X alors i est une occurrence de a dans le
mot .

Exercice :
Donner les i associés aux mots sivants :
1) abba sur le vocabulaire {a, b}
2) (x1*(x2+x1)) sur le vocabulaire {x1, x2, +, *, (, )}
Leila Ben Ayed Théorie des Langages et Compilation 8
I.1. Vocabulaire et mot
Corrigé:
1) Si le vocabulaire X = {a, b} alors dans le mot abba,
1 = a
2 = b
3 = b
4 = a
2) Si le vocabulaire est X = {x1, x2, +, *, (, )} alors dans le mot (x1*(x2+x1))

1 = ( 2 = x1 3 = *

4 = ( 5 = x2 6 = +

7 = x1 8 = ) 9 = )
Leila Ben Ayed Théorie des Langages et Compilation 9
I.1. Vocabulaire et mot
Longueur d’un mot : La longueur d’un mot  est le
nombre de symboles qu’il contient , on le note |
|.

Exercice :
Quelle est la longueur des mots abba et  sur le
Vocabulaire {a,b}
Corrigé:
Le mot abba est de longueur 4, |abba| = 4
Le mot  est de longueur 0, | | = 0

Leila Ben Ayed Théorie des Langages et Compilation 10


I.1. Vocabulaire et mot
Nombre d’occurrences d’un symbole dans un mot :
Le nombre d’occurrences d’un symbole x dans un mot
 est le nombre de fois où ce symbole apparaît dans
ce mot . On le note ||x.
|| = xX ||x
Exercice :
Quel est le nombre d’occurrences de b dans les mots
abba et 
Corrigé :
|abba|b=2
| |b=0
Leila Ben Ayed Théorie des Langages et Compilation 11
I.2. Langage
Définition 6. Langage :
On définit un langage sur un alphabet X comme un sous
ensemble de X*

Exemple:
• Si le vocabulaire est X = {0, 1, 2, 3, …9}
L = { représentations décimales des nombres entiers
naturels}
L = |N
• Si le vocabulaire est X = {x1, x2, +, *, (, )} x1++ X*
L = {expressions arithmétiques parenthésées}
manipulant x1, x2, + et * (x1+ x2)
Leila Ben Ayed Théorie des Langages et Compilation 12
I.2. Langage

• Si X est la vocabulaire du langage de programmation C


X = {main, (, ), #, Include, <, >, ., ;, id, nb, …….}
L= {programmes C corrects syntaxiquement}

(main) element de X*
main(){}

• Si X est le vocabulaire de la logique des propositions


X ={p, (, ), , , } où p désigne une proposition
L = {formules bien formées de la logique des
propositions} V p ->p
Leila Ben Ayed Théorie des Langages et Compilation 13
I.2. Langage
• Si X est le vocabulaire de la logique des propositions
X ={p, (, ), , , } où p désigne une proposition
L = {formules bien formées de la logique des
propositions}

L’ensemble des mots de L est défini récursivement comme


suit :
1) P est un mot
2) Si F et G sont deux mots alors F-> G, F/\G le sont aussi
3) Si F est un mot alors (F) et !F le sont aussi
(P V P) ->p S => p
F -> G S =>
F1 V F2 p
(p V p) -> p
Leila Ben Ayed Théorie des Langages et Compilation 14
I.3. Opérations sur les langages
Concaténation de deux mots:
Si u et v deux mots / |u| = n et |v| = m alors:
u.v =  / i = ui  i  [n] et
n+j = vj  j  [m]
Le mot vide  est un élément neutre de la
concaténation
u.  = .u = u

Leila Ben Ayed Théorie des Langages et Compilation 15


I.3. Opérations sur les langages
Soient A et B deux langages alors on a les opérations suivantes:
Intersection AB = {/ A et B}
Union A+B = {/ A ou B}
Complémentation A-B = {/ A et B}
Concaténation
A.B = {/ u A et v B et  = u.v}

Propriétés
Soient A, B, C des langages, on a A.(B+C) = A.B + A.C
(A+B).C = A.C+B.C

A  B  AC  BC
CA  CB

Leila Ben Ayed Théorie des Langages et Compilation 16


I.3. Opérations sur les langages
Notation:
ak = aaaaaaaaa…… a2 = aa
<----------------->
k fois
a0 = 
a* = {ai / i  0} = {a0, a1, a2, ….ai, …}
a+ = {ai / i >0} = {a1, a2, …., ai, …}

Leila Ben Ayed Théorie des Langages et Compilation 17


I.3. Opérations sur les langages
L’opération * A* =  Ai avec A0 = {}
i0 A1 = A

Ai+1 = A.Ai i0

L’opération + A+ =  Ai
i1
Leila Ben Ayed Théorie des Langages et Compilation 18
I.3. Opérations sur les langages
Exercice :
Calculer A* pour chacun des ensembles A suivants:
1) A = {a}
2) A = {X* / || = 2k+1 / k  0}
Corrigé :
1) Si A = {a} alors A* = {a}* = a*
Car A* = A0 + A1 + A2 +… Ai +…
A0 = {} = {a0}
A1 = AA0 = {a} {} = {a} = {a1}
A2 = AA1 = {a}{a} = {aa} = {a2}
Ai = {ai}
Ai+1 = A Ai = {a}{ai} = {ai+1}
….
A* = {, a, aa, aaa, …} = {a0, a1, a2, a3, …} = a*

Leila Ben Ayed Théorie des Langages et Compilation 19


I.3. Opérations sur les langages
2) Si A = {X* / || = 2k+1 / k  0}
A* = X*
Car A* = A0 + A1 + A2 +… Ai +…
A0 = {}
A1 = AA0 = A{} = {X* / || = 2k+1 / k  0}
A2 = AA1 = {X* / || = 2k+1/ k0} {X* / ||= 2k+1/ k  0}
= {X* / || = 2k+2/ k0}
= {X* / || = 2k / k>0}
A0 + A2 = {} + {X* / || = 2k / k>0} = {X* / || = 2k/ k0}

A0 + A1 + A2 = X*
Donc A* = X*

Leila Ben Ayed Théorie des Langages et Compilation 20


I.4. Propriétés des langages
Exercice :
Calculer A. et A.{}
Montrer qu’on a A.(B+C) = A.B + A.C mais pas A.(BC) = A.B  A.C
Corrigé:
1- A. = .A = 
2- A.{} = {}.A= A
5- On n’a pas A.(BC) = A.B  A.C

Contre exemple : A = {, x}, B = {xyzt}, C = {yzt}

Leila Ben Ayed Théorie des Langages et Compilation 21


I.4. Propriétés des langages
Contre exemple : A = {, x}, B = {xy}, C = {y}
Car A.(BC)  A.B  A.C
En effet (BC) =  donc A. (BC) = 
Par contre A.B = {xy, xxy} et A.C = {y, xy} donc A.B  A.C = {xy}
6- On n’a pas A+ = A* - {} par contre on A* =A+ + {}
Pour A = {, a}
A+ = A1 + A2 + … = {, a} + {, a, aa} + …
A* = A0 + A1 + A2 + … = {ai / i  0}
A* - {} = {ai / i > 0}  A+ car A  {}
A+ = A* - {} est vraie lorsque A ne contient pas 

Leila Ben Ayed Théorie des Langages et Compilation 22


I.5. Définition de langages (propriété
mesurable ou définition récursive)
•Définition par propriété mesurable

–L est l’ensemble des mots sur {a, b} de longueur paire


L = {  {a, b}*/ || = 2k, K  0}

–L est l’ensemble des mots sur {a, b} ayant un nombre impaire de b


L = {  {a, b}*/ ||b = 2k+1, K  0}

–L est l’ensemble des mots sur {a, b} où tous les a précèdent les b et sont de
même nombre
L = { anbn, n  0}

Leila Ben Ayed Théorie des Langages et Compilation 23


I.5. Définition de langages (propriétés
mesurables ou récursive)
• Définition récursive

– L est l’ensemble des mots sur {a, b} où tous les a précèdent les b et
sont de même nombre
La définition par propriété mesurable est la suivante :
L = { anbn, n  0}

La définition récursive du même langage est :

L = {   {a, b}*/  =  ou  = a1b et 1  L}

Leila Ben Ayed Théorie des Langages et Compilation 24


I.5. Définition de langages (propriétés
mesurables ou récursive)
• Définition récursive
– L est l’ensemble des mots palindromes sur le
vocabulaire {a, b}, de longueur paire.

L = {   {a, b}*/  = aa ou  = bb ou  = a1a ou


 = b1b et 1  L}

Leila Ben Ayed Théorie des Langages et Compilation 25


I.5. Définition de langages (propriétés
mesurables ou récursive)
• Définition récursive
– L est l’ensemble des mots palindromes sur le
vocabulaire {a, b}, de longueur impaire.

L = {   {a, b}*/  = a ou  = b ou  = a1a ou


 = b1b et 1  L}

Leila Ben Ayed Théorie des Langages et Compilation 26


I.5. Définition de langages (propriétés
mesurables ou récursive)
• Définition récursive
– L est l’ensemble des mots palindromes sur le
vocabulaire {a, b}.

L = {   {a, b}*/  = a ou  = b ou  = aa ou  = bb
ou  = a1a ou  = b1b et 1  L}

Leila Ben Ayed Théorie des Langages et Compilation 27


I.6. Le lemme d’Arden

Pour deux langages A et B d’un vocabulaire X*,


Les équations L= AL+B et L = LA+B admettent
respectivement comme solution minimale A*B
et BA*. Cette solution est unique si A.

Leila Ben Ayed Théorie des Langages et Compilation 28


II. Les automates finis et les
langages réguliers
Plan
II.1. Les automates finis déterministes
II.2. Langage accepté par un automate fini
II.3. Rendre déterministe un automate fini non déterministe
II.4. Les langages réguliers LR
II.5. Minimisation d’un automate fini déterministe
II.6. Expressions régulières et automates finis
II.7. Limites des automates finis
Leila Ben Ayed Théorie des Langages et Compilation 29
II.1. Les automates finis déterministes
Définition7. Automate fini
Un automate fini consiste en un quintuple de la
forme (Q, X, , q0, F) avec
Q est un ensemble fini d’états
X est un alphabet
 est une fonction de transition
: Q x X  (Q) (l’ensemble de tous les sous ensembles de Q)
q0 est l’état initial
F est l’ensemble des états finaux F  Q
Leila Ben Ayed Théorie des Langages et Compilation 30
II.1. Les automates finis déterministes
Exemple d’un automate fini

Presser Cet automate reconnaît les


séquences de presser qui
OFF ON nous mènent toujours à
l’état final souhaité ON
Presser (lampe allumée)
En partant d’un état où la
lampe est éteinte (OFF)
Q = {OFF, ON}
X = {presser}
q0 = OFF (OFF, presser) = {ON}
F = {ON} (ON, presser) = {OFF}

Leila Ben Ayed Théorie des Langages et Compilation 31


II.1. Les automates finis déterministes
Exemple d’un automate fini
Presser

OFF ON

Presser

La séquence:
presser presser presser est acceptée
Par ce que
•en partant de l’état off, avec un presser on passe à l’état ON
•En lisant le deuxième presser à partir de l’état ON, on revient à l’état OFF
•Le dernier presser lu nous mène de l’état OFF à l’état ON
Donc à la fin de la lecture des trois presser, trois transitions sont effectuées et la
dernière nous mène à l’état ON donc la séquence est acceptée.
Leila Ben Ayed Théorie des Langages et Compilation 32
II.1. Les automates finis déterministes
Exemple d’un automate fini
presser
Presser
presser presser
presser presser presser
presser
OFF
OFF ON
ON
Le mot est lu et l’état est final
Presser
presser donc le mot est accepté

La séquence:
presser presser presser est acceptée
Par ce que
•en partant de l’état off, avec un presser on passe à l’état ON
•En lisant le deuxième presser à partir de l’état ON, on revient à l’état OFF
•Le dernier presser lu nous mène de l’état OFF à l’état ON
Donc à la fin de la lecture des trois presser, trois transitions sont effectuées et la
dernière nous mène à l’état ON donc la séquence est acceptée.
Leila Ben Ayed Théorie des Langages et Compilation 33
II.1. Les automates finis déterministes
Exemple d’un automate fini

Presser

OFF ON

Presser

La séquence:
presser presser n’est pas acceptée par l’automate
Par ce que
•en partant de l’état off, avec un presser on passe à l’état ON
•En lisant le deuxième presser à partir de l’état ON, on revient à l’état OFF

Leila Ben Ayed Théorie des Langages et Compilation 34


II.1. Les automates finis déterministes
Exemple d’un automate fini

A Presser

OFF ON

Presser

Le langage accepté par cet automate est l’ensemble des séquences de presser qui,
partant de l’état initial OFF, après la lecture de tous les symboles de la séquence,
on se trouve à l’état ON.
Ce langage (le langage accepté par l’automate A, L(A)) est l’ensemble des
séquences de presser de longueur impaire.
L(A) = {  {presser}*/ | | = 2k + 1, k  0}

Leila Ben Ayed Théorie des Langages et Compilation 35


II.1. Les automates finis déterministes
Exemple d’un automate fini qui accepte
{  {a}*/ || = 2k, k  0} (aa)*

A a

P I

L’état initial devient un état final puisque le mot  est accepté (pour k = 0).
En étant à l’état initial de l’automate, on peut ne rien lire (c-a-d lire 0 symboles
donc lire ) et on est déjà à un état final.

Leila Ben Ayed Théorie des Langages et Compilation 36


II.1. Les automates finis déterministes
Exercices :
1) Construire un automate fini qui accepte le langage suivant:
{  {a}*/ || = 2k, k > 0}
A aa(aa)*
a a
q0 q1 q2

Le plus petit mot accepté est aa (On atteint l’état final après la lecture de aa).
Après il faudra continuer à avoir un nombre paire de a. Donc quand on se trouve à
l’état d’acceptation ou l’état final, il faudra continuer à lire des séquences de 2a
pour revenir à l’état final.

Leila Ben Ayed Théorie des Langages et Compilation 37


II.1. Les automates finis déterministes

{  {a}*/ || = 2k, k > 0} (autre solution)


A
a a a
q0 q1 q2 q3
a

Le plus petit mot accepté est aa (On atteint l’état final après la lecture de aa).
Après il faudra continuer à avoir un nombre paire de a. Donc quand on se trouve à
l’état d’acceptation ou l’état final, il faudra continuer à lire des séquences de 2a
pour revenir à l’état final.

Leila Ben Ayed Théorie des Langages et Compilation 38


II.1. Les automates finis déterministes
2) Construire un automate fini qui accepte le langage suivant:
{a,b}*/ ||a = 3k+2, k  0}
b b b b*ab*ab*(ab*ab*ab*)*
A
a a
q0
q0 q1
q1 q2

Le plus petit mot accepté est aa (On atteint l’état final après la lecture de aa).
Après il faudra continuer à avoir un nombre paire de a. Donc quand on se trouve à
l’état d’acceptation ou l’état final, il faudra continuer à lire des séquences de 2a
pour revenir à l’état final. Les b on peut les lire à n’importe quel état et on reste
au même état puisqu’ils n’engendrent pas une transitions contrairement à un a lu
qui nous fait passer de q0 à q1 ou de q1 à q2 ou de q2 à q0 par ce qu’il faut les
comptabiliser.

Leila Ben Ayed Théorie des Langages et Compilation 39


II.1. Les automates finis déterministes
3) Construire un automate fini qui accepte le langage suivant:
{  {a}*/ || = 3k+1, k  0}
a(aaa)*

A
a a a
q0 q1 q2 q3
a

Le plus petit mot accepté est a (On atteint l’état final après la lecture de a). Après il
faudra continuer à avoir un nombre multiple de 3a. Donc quand on se trouve à
l’état d’acceptation ou l’état final, il faudra continuer à lire des séquences de 3a
pour revenir à l’état final.

Leila Ben Ayed Théorie des Langages et Compilation 40


II.1. Les automates finis déterministes

{  {a}*/ || = 3k+1, k  0} (autre solution)


a(aaa)*
A
a a
q0 q1 q2

Le plus petit mot accepté est a (On atteint l’état final après la lecture de a). Après il
faudra continuer à avoir un nombre multiple de 3a. Donc quand on se trouve à
l’état d’acceptation ou l’état final, il faudra continuer à lire des séquences de 3a
pour revenir à l’état final.

Leila Ben Ayed Théorie des Langages et Compilation 41


II.1. Les automates finis déterministes
4) Construire un automate fini qui accepte le langage suivant:
{  {a, b, c}*/ ||a = 3k+1, k  0}
b, c b, c b, c
A
a a
q0 q1 q2

(b+c)*a(b+c)*(a(b+c)*a(b+c)*a(b+c)*)*

Leila Ben Ayed Théorie des Langages et Compilation 42


II.1. Les automates finis déterministes

5) Construire un automate fini qui accepte l’ensemble des mots


sur {a, b, c} ayant aba comme facteur (ou sous chaine)
b, c a a, b, c
a b a
q0 q1 q2 q3
c

b, c

Leila Ben Ayed Théorie des Langages et Compilation 43


II.1. Les automates finis déterministes
6) Construire un automate fini qui accepte l’ensemble des
représentations décimales des nombres entiers ayant le chiffre 1
dans les dizaines (Exemple: 12316, 13, 210)
0,1,2,3,4,5,6,7,8,9

1 0,1,2,3,4,5,6,7,8,9
q0 q1 q2

c*1c
(0+1+2+…+9)*1(0+1+2+…9)

Leila Ben Ayed Théorie des Langages et Compilation 44


II.1. Les automates finis déterministes
7) Construire un automate fini qui accepte l’ensemble des
représentations décimales des nombres entiers différents de
Zéro
0,1,2,3,4,5,6,7,8,9
0

1,2,3,4,5,6,7,8,9
q0 q1

0*(1+2+…9)(0+1+2+…+9)*

Leila Ben Ayed Théorie des Langages et Compilation 45


II.1. Les automates finis déterministes
Définition 8. Automate fini complet
Un automate fini est dit complet sur un vocabulaire X ssi pour
chaque état q et chaque symbole s, il existe au moins une transition
qui quitte q avec le symbole s.
Définition 9. Automate fini non ambigu
Un automate fini est dit non ambigu sur un vocabulaire X ssi pour
chaque état q et chaque symbole s, il existe au plus une transition
qui quitte q avec le symbole s.
Définition 10. Automate fini déterministe
Un automate fini est dit déterministe sur un vocabulaire X ssi il est
complet et non ambigu (pour chaque état q et chaque symbole s, il
existe une et une seule transition qui quitte q avec le symbole s).

Leila Ben Ayed Théorie des Langages et Compilation 46


II.1. Les automates finis déterministes

a,b a,b a
a a
q0 q1 q0 q1
b
Non complet sur {a, b} car
Ambigu sur {a, b} car
(q0, b) = 
(q0, a) = {q0, q1}
L(A) = a(a+b)*
L(A) = ((a+b)*a+)+
b a
a
q0 q1 L(A) = (b*a+)+
b
Automate fini déterministe sur {a, b} car il est complet et non ambigu:
(q0, a) = {q1} (q0, b) = {q0} (q1, a) = {q1} (q1, b) = {q0}
Leila Ben Ayed Théorie des Langages et Compilation 47
II.2. Langage accepté par un automate fini
Définition 11. Configuration
Une configuration est un couple
(q, )
où q est l’état courant et  est le reste du mot à lire.

Pour l’automate suivant, des configurations possibles sont:

b b b
A
a a
q0
q0 q1
q1 q2

a
(q0, aa) (q1, a) (q2, )
(q0, bba) (q0, ba) (q0, a) (q1, )
Leila Ben Ayed Théorie des Langages et Compilation 48
II.2. Langage accepté par un automate fini

Définition 12. Configuration successeur


Une configuration (p, y) est successeur d’une
configuration (q, x) qu’on note:

(q, x) |-- (p, y) q a p

ssi a
x
y
 a / x = a y et (q, a) = {p}

Leila Ben Ayed Théorie des Langages et Compilation 49


II.2. Langage accepté par un automate fini

Pour l’automate suivant, des configurations possibles sont:

b b b
A
a a
q0
q0 q1
q1 q2

(q0, aa) |-- (q1, a) |-- (q2, )


(q0, bba) |-- (q0, ba) |-- (q0, a) |-- (q1, )
Leila Ben Ayed Théorie des Langages et Compilation 50
II.2. Langage accepté par un automate fini
Définition 13. Configuration kème successeur
Une configuration (p, y) est kème successeur d’une
configuration (q, x) qu’on note:
k

(q, x) |-- (p, y) ssi (q, x) |-- (q1, x1) |-- (q2, x2) |--…(qk, xk) = (p, y)

* k

(q, x) |-- (p, y) ssi  k  0 / (q, x) |-- (p, y)

Leila Ben Ayed Théorie des Langages et Compilation 51


II.2. Langage accepté par un automate fini
Pour l’automate suivant, nous avons :
b b b
A
a a
q0
q0 q1
q1 q2

* k

(q0, aa) |-- (q2, ) puisque:  k  0 / (q0, aa) |-- (q2, )


(q0, aa) |-- (q1, a) |-- (q2, ) (k = 2)
3

(q0, bba) |-- (q1, )


En effet, (q0, bba) |-- (q0, ba) |-- (q0, a) |-- (q1, )
Leila Ben Ayed Théorie des Langages et Compilation 52
II.2. Langage accepté par un automate fini

Définition 14. Langage reconnu par un automate


fini
Soit A = (Q, X, , q0, F) un automate fini. Le
langage accepté (ou reconnu par A) est noté
L(A) /

L(A) = {/ (q0, ) |-- (qf, ) , qf  F}


 est accepté par A ssi   L(A)
Leila Ben Ayed Théorie des Langages et Compilation 53
II.2. Langage accepté par un automate fini
Exercice : Soit l’automate fini A suivant :

b b b
A
a a
q0
q0 q1
q1 q2

Montrer que aa  L(A) et que bba  L(A)

Corrigé:
*

aa  L(A) par ce que : (q0, aa) |-- (q2, ) puisque:


(q0, aa) |-- (q1, a) |-- (q2, ) (k = 2)
k

bba  L(A) par ce que :  k / (q0, bba) |-- (q2, )


En effet, (q0, bba) |-- (q0, ba) |-- (q0, a) |-- (q1, )
Leila Ben Ayed Théorie des Langages et Compilation 54
II.2. Langage accepté par un automate fini
Exercice: Considérons l’automate A suivant :
1) Quel est le langage reconnu par A
b b b
A
a a
q0
q0 q1
q1 q2

2) Est-ce que le mot  est accepté par A


Corrigé:
1) L(A) = {  {a, b}*/ ||a = 3k+2, k  0} + {  {a, b}*/ ||a = 3k, k  0}
2)  L(A) par ce que : q0  F
(q0, ) est une configuration initiale et finale.
Leila Ben Ayed Théorie des Langages et Compilation 55
II.2. Langage accepté par un automate fini
(Lemme d’Arden)
Soit A un automate fini sur un vocabulaire X
Avec x  X
A
x
qi qj

On dénote par Li, le langage reconnu par l’automate A en considérant que qi


est l’état initial. Ainsi, L0 est le langage reconnu par A
j  Lj   i  Li / i = x j en conséquence Li = xLj
Si qi est un état final alors Li = x Lj + {} par ce que si qi est un état initial
et final alors le langage Li contient le mot 

Leila Ben Ayed Théorie des Langages et Compilation 56


II.2. Langage accepté par un automate fini
(Lemme d’arden)
Exercice : Soit A un automate fini sur un vocabulaire X= {a,b}, Chercher le
langage L0 reconnu par l’automate A

A
a a
q0 q1 q2

a
Corrigé :
L0 = {a} L1 (1) L1 = {a} L2 (2)
L2 = {a} L0 + {} (3)
(1) + (2)  L0 = {a}{a}L2 = {aa}L2 (4)
(4) + (3)  L0 = {aa} L2 = {aa}({a}L0 + {})  L0 = {aaa}L0 + {aa}
 L0 = {aaa}*{aa} = (aaa)*aa
D’après le lemme d’Arden

Leila Ben Ayed Théorie des Langages et Compilation 57


II.2. Langage accepté par un automate fini
(Lemme d’arden)
Exercice :
1) Construire un automate qui accepte le langage a*b*
2) Vérifier que l’automate construit reconnaît le langage a*b*
Corrigé :
1) a b
A
b
q0 q1

2) Calculons L0
L0 = {a} L0 + {b}L1 + {} (1)
L1 = {b} L1 + [] (2)
(2)  L1 = {b}*{} d’après le lemme d’Arden  L1 = b* (3)
(1) + (3)  L0 = {a}L0 + {b} b* + {}
 L0 = {a}L0 + b+ + {}
 L0 = {a}L0 + b* car b++{} = b*
 L0 = {a}*b* = a*b*d’après le lemme d’Arden
L(A) = L0 = a*b* donc l’automate A reconnaît le langage a*b*
Leila Ben Ayed Théorie des Langages et Compilation 58
II.2. Langage accepté par un automate fini
(Lemme d’arden)
Exercice :
1) Construire une automate qui accepte le langage (a+b)*
2) Vérifier que l’automate construit reconnaît le langage (a+b)* (L0 est le langage accepté par
l’automate puisque c’est le langage où q0 est l’état initial)
Corrigé:
1)
a,b
A
q0

2) L0 = {a} L0 + {b}L0 + {} (1)


(1) L0 = {a,b} L0 + {}
 L0 = {a,b}*{} d’après le lemme d’Arden
 L0 = {a,b}* = (a+b)*

Leila Ben Ayed Théorie des Langages et Compilation 59


II.3. Rendre déterministe un automate fini
non déterministe
II.3.1. Automate fini non complet
Si l’automate fini est non déterministe par ce qu’il est non complet, alors pour le rendre
déterministe, il suffit d’ajouter un état puit et ajouter toutes les transitions manquantes
vers cet état.
a,b a,b
a a
q0 q1 q0 q1

Non complet sur {a, b} car b


(q0, b) = 
p
L(A) = a(a+b)* a,b

Complet sur {a, b}

Leila Ben Ayed Théorie des Langages et Compilation 60


II.3. Rendre déterministe un automate fini
non déterministe
II.3.2. Automate fini ambigu
Si l’automate fini est non déterministe par ce qu’il est ambigu
alors on doit construire un automate en groupant les états visités
par un même symbole à partir d’un état, ces états groupés
forment les nouveaux états de l’automate déterministe. La
construction de l’automate déterministe suit les étapes suivantes:
Etape 1. Définir les nouveaux groupes d’états
Etape 2. Renommer les nouveaux groupes et définir les états
finaux. Un nouvel état (Groupe d’état) est un état final ssi il
contient un ancien état final
Etape 3. Construire l’automate déterministe

Leila Ben Ayed Théorie des Langages et Compilation 61


II.3. Rendre déterministe un automate fini
non déterministe
Exemple1
Etape 1. Définir les nouveaux groupes d’états

a a,b
a b
a,b
q0 q1
{q0} {q0, q1} {q1}

{q0, q1} {q0, q1} {q1}


L(A) = a*(a+b)+ {q1} {q1} {q1}

Leila Ben Ayed Théorie des Langages et Compilation 62


II.3. Rendre déterministe un automate fini
non déterministe
Exemple1
Etape 2. Renommer les états et définir les états finaux

a a,b
a b
a,b
q0 q1
{q0} A {q0, q1} B {q1} C

{q0, q1} B {q0, q1} B {q1} C

{q1} C {q1} C {q1} C

Leila Ben Ayed Théorie des Langages et Compilation 63


II.3. Rendre déterministe un automate fini
non déterministe
Exemple1
Etape 3. Construire l’automate déterministe

a
a b
a
A B
{q0} A {q0, q1} B {q1} C
a,b
b b {q0, q1} B {q0, q1} B {q1} C
C
{q1} C {q1} C {q1} C

Leila Ben Ayed Théorie des Langages et Compilation 64


II.3. Rendre déterministe un automate fini
non déterministe
Exercice : Soit l’automate A suivant, construire un automate fini déterministe
qui reconnaît le même langage
a a,b
a
q0 q1

Corrigé :
Etape1. Définir les nouveaux groupes d’états
a b

L(A) = a+(a+b)* {q0} {q0, q1} 

{q0, q1} {q0, q1} {q1}

{q1} {q1} {q1}

Leila Ben Ayed Théorie des Langages et Compilation 65


II.3. Rendre déterministe un automate fini
non déterministe

Etape 2. Renommer les états et définir les états finaux

a a,b
a b
a
q0 q1
{q0} A {q0, q1} B  P

{q0, q1} B {q0, q1} B {q1} C

{q1} C {q1} C {q1} C

Leila Ben Ayed Théorie des Langages et Compilation 66


II.3. Rendre déterministe un automate fini
non déterministe
Etape 3. Construire l’automate déterministe

a
a b
a
A B {q0} A {q0, q1} B
a,b  P

b a,b b {q0, q1} B {q0, q1} B {q1} C


C {q1} C {q1} C {q1} C
P

Leila Ben Ayed Théorie des Langages et Compilation 67


II.4. Les langages réguliers

II.4.1. Définition
Un langage L est dit régulier s’il existe un automate fini A
qui l’accepte (L(A) = L)

Leila Ben Ayed Théorie des Langages et Compilation 68


II.4. Les langages réguliers

Le lemme de pompage
Soit L un langage régulier reconnu par
un automate à n états.
Pour tout mot z de L, z est de longueur
≥ n, il existe une factorisation z = uvw,
où |uv| ≤ n, v ≠  et,
pour tout i ≥ 0, on a uviw  L.

Leila Ben Ayed Théorie des Langages et Compilation 69


II.4. Les langages réguliers
Exemple d’application : montrer que certains
langages ne sont pas réguliers.
L = {0n1n : n ≥ 0} n'est pas régulier.
Si L est reconnu par un automate à n états, la
factorisation de 0n1n conduit à une
contradiction.
L = {écritures binaires de p, où p est premier}
n'est pas régulier.

Leila Ben Ayed Théorie des Langages et Compilation 70


II.4. Les langages réguliers
II.4.2. Propriétés des langages réguliers
(LR) X
-  est un langage régulier (Il existe un automate fini qui
l’accepte) q0
- Si L1 et L2 sont des langages réguliers alors
L1+L2 (Union), L1.L2 (Concaténation) et L1L2
(Intersection) sont des langages réguliers
- Si L est un langage régulier alors
L* (Fermeture transitive), L+ (Fermeture transitive
réflexive), (Complément X-L) et L (Image miroir) sont des
langages réguliers

Leila Ben Ayed Théorie des Langages et Compilation 71


II.4. Les langages réguliers

II.4.2. Propriétés des langages réguliers (LR)


- Si L1 et L2 sont des langages réguliers alors L1+L2 (Union) est un langage régulier.
On peut toujours construire un automate fini qui accepte L1 + L2 à partir des
automates finis qui acceptent respectivement L1 et L2²²
Soit A1 = (Q1, X1, 1, q01, F1) / L(A1) = L1
A2 = (Q2, X2, 2, q02, F2)/ L(A2) = L2
On construit A = (Q, X, , q0, F)/ L(A) = L1+L2
Q = Q1Q2{q0}
X = X1  X2
d= 12{(q0, x, q)/ (q01, x, q) 1 ou (q02, x, q) 2}
F = F1 F2  {q0} si q01  F1 ou q02  F2
F1  F2 sinon

Leila Ben Ayed Théorie des Langages et Compilation 72


II.4. Les langages réguliers
Exercice: Soient les automates A1 et A2, construire un automate A qui reconnaît L(A1) + L(A2)
(l’union des deux langages reconnus par A1 et A2)
a b
a,b
a a,b
A1 q01 q1 A2 q02 q2

a a,b
Corrigé:
a
q01 q1
A
a a
q0
b
b
a,b
a,b q02 q2

Leila Ben Ayed Théorie des Langages et Compilation 73


II.4. Les langages réguliers
II.4.2. Propriétés des langages réguliers (LR)
- Si L1 et L2 sont des langages réguliers alors L1.L2 (concaténation) est un langage régulier.
On peut toujours construire un automate fini qui accepte L1.L2 à partir des automates finis
qui acceptent respectivement L1 et L2

Soit A1 = (Q1, X1, 1, q01, F1) / L(A1) = L1


A2 = (Q2, X2, 2, q02, F2)/ L(A2) = L2
On construit A = (Q, X, , q0, F)/ L(A) = L1.L2
Q = Q1Q2
X = X1  X2
q0 = q01
d= 12{(p, x, q)/ (q02, x, q) 2 et p  F1}
F = F1 F2 si q02  F2
F2 sinon

Leila Ben Ayed Théorie des Langages et Compilation 74


II.4. Les langages réguliers
Exercice: Soient les automates A1 et A2 suivants, construire un automate A qui accepte L(A1) .
L(A2)
a b
a,b
a a,b
A1 q01 q1 A2 q02 q2

Corrigé:
a a,b
b
a b a,b
A q01 q1 q02 q2
b a,b

a,b

Leila Ben Ayed Théorie des Langages et Compilation 75


II.4. Les langages réguliers
Exercice: Soient les automates A1 et A2 suivants, construire un automate A qui accepte L(A1) .
L(A2)
a b
a,b
a a,b
A1 q01 q1 A2 q02 q2

a a,b
b
a b a,b
A q01 q1 q02 q2
b a,b

a,b

Leila Ben Ayed Théorie des Langages et Compilation 76


II.4. Les langages réguliers
II.4.2. Propriétés des langages réguliers (LR)
- Si L est un langage régulier alors L* est un langage régulier
On peut toujours construire un automate fini qui accepte L* à partir de l’automate fini qui
accepte L

Soit A1 = (Q1, X1, 1, q01, F1) / L(A1) = L1


On construit A = (Q, X, , q0, F)/ L(A) = L*
Q = Q1{q0}
X = X1
d= 1{(q0, x, q)/ (q01, x, q) 1}  {(qf, x, q)/
(q01, x, q)  1 et qfF1}
F = F1 {q0}

Leila Ben Ayed Théorie des Langages et Compilation 77


II.4. Les langages réguliers
Exercice: Soit l’automate A1 suivant. Construire un automate A qui accepte (L(A1))*

a a L(A1) = a*ba*
L(A) = (L(A1))* = (a*ba*)*
b Par ce que on a :
A1 q01 q1
(q01, a q01) et (q01, b, q1)
dans 1 qu’on ajoute :
(q0, a, q01) et (q0, b, q1) à 
_____
Corrigé: Par ce que on a :
a a,b (q01, a, q01) et (q01, b, q1)
A
b dans 1 qu’on ajoute :
a q01 q1 (q1, a, q01) et (q1, b, q1) à 
q0

b
a

Leila Ben Ayed Théorie des Langages et Compilation 78


II.4. Les langages réguliers
II.4.2. Propriétés des langages réguliers (LR)
- Si L est un langage régulier alors L+ est un langage régulier
On peut toujours construire un automate fini qui accepte L + à partir de l’automate fini qui accepte
L

Soit A1 = (Q1, X1, 1, q01, F1) / L(A1) = L1


On construit A = (Q, X, , q0, F)/ L(A) = L1+
Q = Q1{q0}
X = X1
d= 1{(q0, x, q)/ (q01, x, q) 1}  {(qf, x, q)/
(q01, x, q)  1 et qfF1}
F = F1

Leila Ben Ayed Théorie des Langages et Compilation 79


II.4. Les langages réguliers
Exercice: Soit l’automate A1 suivant. Construire un automate A qui accepte (L(A1)) +

a a L(A1) = a*ba*
L(A) = (L(A1))+ = (a*ba*)+
b Par ce que on a :
A1 q01 q1
(q01, a q01) et (q01, b, q1)
dans 1 qu’on ajoute :
(q0, a, q01) et (q0, b, q1) à 
_____
Corrigé: Par ce que on a :
a a,b (q01, a, q01) et (q01, b, q1)
A
b dans 1 qu’on ajoute :
a q01 q1 (q1, a, q01) et (q1, b, q1) à 
q0

b
a

Leila Ben Ayed Théorie des Langages et Compilation 80


II.5. Minimisation d’un automate fini
déterministe
Soit A un automate fini déterministe A = (Q, X, , q0, F)
Pour obtenir un automate A minimal en nombre d’états, suivre les étapes suivantes:
1) Construire une partition initiale 0 composée de deux groupes: Groupe des états
finaux G1 et Groupe des états non finaux G2
2) Répéter Jusqu’à  i+1 =  i / i0
- Pour obtenir  i+1, Partitionner chaque groupe de i en mettant ensemble des
états p et q si pour chaque symbole s du vocabulaire, p et q transitent vers des
états d’un même groupe d’états.
- Construire les nouveaux groupes
3) Associer à chaque groupe un nom
4) Construire les transitions des groupes en utilisant les transitions des états des
groupes.
5) Un groupe qui contient un état final est un état final dans l’automate minimal

Leila Ben Ayed Théorie des Langages et Compilation 81


II.5. Minimisation d’un automate fini
déterministe
Exercice : Soit l’automate A suivant. Construire un automate minimal qui accepte le
même langage (Minimiser le nombre d’états de l’automate A)
A
a a a
q0 q1 q2 q3
a

Corrigé:G1 G2
0 (q0, q2, q3) (q1)
G1 G2 G3
P1 (q0, q3) (q2) (q1) (q2, a, q0) est
P2 (q0, q3) (q2) (q1) dans A minimal
q0 q2 q1 car (q2, a, q3) était
On obtient le dans A et que le
A minimal a a group d’états (q0,
q0 q1 q2
q3) est renommé
a q0

Leila Ben Ayed Théorie des Langages et Compilation 82


II.6. Expressions régulières et automates finis
Une expression régulière (e.r) est définie récursivement comme suit:
-  est une e.r
- Un symbole a de X est une e.r
- Si E est une e.r alors E+, E*, (E) sont des e.r
- Si E1 et E2 sont des e.r alors E1.E2 et E1+E2 sont des e.r

Lemme
{langages réguliers} = {langages représentés par une expression
régulière}

Rq. Un langage est dit régulier s’il existe un automate fini qui l’accepte ou une
expression régulière qui le représente

Leila Ben Ayed Théorie des Langages et Compilation 83


II.6. Expressions régulières et automates finis

Exemples:
a*b*
(a+b)*c+
(0+1+2+…9)+représentations décimales des entiers
(a+b+…z+A+B+…Z)(a+b+…z+A+B+…Z+0+1+…9)*
les identificateurs alphanumériques qui

commencent par un caractère

alphabétique

Leila Ben Ayed Théorie des Langages et Compilation 84


II.6. Expressions régulières et automates finis

Exemples:
(a+b)*aa mots sur {a, b} ayant aa comme facteur droit
(a+b+c)*abc(a+b+c)* mots sur {a,b,c} ayant abc comme facteur
0*(1+2+…9)(0+1+…9)* représentations décimales des entiers non nuls

(0+1+2+…9)*1(0+1+2+…9) représentation décimale des entiers


naturels ayant 1 dans les dizaines
(0+1+2+…9)*10 représentation décimale des entiers
naturels ayant 1 dans les dizaines et 0 dans les unités

Leila Ben Ayed Théorie des Langages et Compilation 85


II.7. Limites des automates finis
Exercice : Prouver que le langage L suivant n’est pas un langage régulier:
L = {aibi, i  0}
C-a-d, il n’existe pas un automate fini qui l’accepte

Corrigé:
Supposons qu’il existe un automate fini A à n états qui accepte L (L(A) = L) (1)
Alors A accepte en particulier anbn,
Considérons la séquence de configurations aceptables pour anbn
(q0, anbn) |-- (q1, an-1bn) |--…..(q2n-1, b) |-- (q2n, ) où q2n  F
Cette séquence contient 2n+1 états
Donc un état au moins doit apparaître plus qu’une fois dans les n premiers mouvements. Soit q cet état, si = sj
= q pour certaines valeurs de i et j telles que 0  i  j  n
Ceci entraine
+ + +
(q0, anbn) |-- (q, an-ibn) |--…..(q, an-jbn) |-- (q2n, )

+ +
(q0, an-j+ibn) |-- (q, an-jbn) |--…..(q2n, )
C-a-d an-j+i bn L(A)
C-a-d L  L(A) (absurde) avec l’hypothèse (1)

Leila Ben Ayed Théorie des Langages et Compilation 86


III. Les grammaires

Plan
III.1. Définition d’une grammaire
III.2. Langage généré par une grammaire
III.3. Grammaire régulière
III.4. Langages réguliers et grammaires
régulières
III.5. Les formes normales de grammaires
Leila Ben Ayed Théorie des Langages et Compilation 87
III.1. Définition d’une grammaire

Une grammaire est un quadruplet:


G = (V, T, S, R)

V est un alphabet non terminal
T est un ensemble de terminaux
S est l’axiome de la grammaire (Symbole de départ) (S
 V)
R est l’ensemble des règles de production

Leila Ben Ayed Théorie des Langages et Compilation 88


III.1. Définition d’une grammaire
Exemple: Une grammaire Le mot aabbcc est généré
avec les règles suivantes: par la grammaire:

S  abNSc
S S  abNSc
bNa  abN  abNabNScc
bNb  bbN  abNabNcc
bNc  bc  aabNbNcc
 aabNbcc
Génère {anbncn, n  0}  aabbNcc
 aabbcc

Leila Ben Ayed Théorie des Langages et Compilation 89


III.1. Définition d’une grammaire
Exercice : Soit le langage L suivant :
L = {anbn, n  0}
1) Construire une grammaire G qui génère L
2) Vérifier que les mots ab et aabb sont générés par la
grammaire G
Corrigé:
1) G = (V, T, S, R)
Où V = {S} T = {a, b} R = {S  , S  aSb }

2) Le mot ab est généré par la Le mot aabb est généré par la


grammaire G en effet: grammaire G en effet:
S  aSb  ab = ab S  aSb  aaSbb  aabb =
Leila Ben Ayed
aabb
Théorie des Langages et Compilation 90
III.1. Définition d’une grammaire
L = {anbn, n  0} = {e, ab, aabb, aaabbb, ……….}
L = {w / w = e ou w = a w1 b, w1 L}
L1 = {aibj, i, j > 0} a+b+
S S S S -> aSb
S -> e
e a S b a S b

e a S b
aeb = ab
e
e
aeb
aaebb
Leila Ben Ayed Théorie des Langages et Compilation 91
III.1. Définition d’une grammaire
Exercice : Soit le langage L suivant :
L = a* ={ai, i>=0}

S -> aS
S S S S -> e

e a S

e
ae = a

Leila Ben Ayed Théorie des Langages et Compilation 92


III.1. Définition d’une grammaire
L = { formules logiques sur le vocabulaire
{p, ->, (, ), V, /\, !} } ! Repr not

S -> p
S -> S V S
S -> S /\ S
S -> (S)
S -> ! S
S -> S -> S

L = { w / w = p ou w = w1 V w2 ou w = w1 /\w2 ou w = (w1)
ou w = ! W1 ou w = w1 ->w2, w1  L et w2  L}

Leila Ben Ayed Théorie des Langages et Compilation 93


Leila Ben Ayed Théorie des Langages et Compilation 94
III.1. Définition d’une grammaire
Exercice:
1) Construire une grammaire G qui génère le langage a+
2) Vérifier que les mots aa et a sont générés par la grammaire
Corrigé :
1) Une grammaire qui génère {an, n > 0} = a+
G = (V, T, A, R) Où V = {A}, T = {a}
R = { A  a, A  aA }
2) Le mot aa est généré par la grammaire G en effet:
A  aA  aa
Le mot a est généré par la grammaire G en effet:
Aa

Leila Ben Ayed Théorie des Langages et Compilation 95


III.1. Définition d’une grammaire
Exercice:
1) Construire une grammaire G qui génère {an, n  0} = a*

2) Vérifier que les mots aa et  sont générés par G.


Corrigé:
1) G = (V, T, A, R) Où
V = {A} T = {a, b} R = { A  , A  aA }
2) Le mot aa est généré par la grammaire G en effet:
A  aA  aaA  aa = aa
Le mot  est généré par la grammaire G en effet:
A

Leila Ben Ayed Théorie des Langages et Compilation 96


III.1. Définition d’une grammaire
Exercice :
1) Construire une grammaire G qui génère les représentations
décimales des entiers naturels :
(0+1+…9)+ = {0, 1, 2, …9}+
2) Vérifier que le mot 0129 est généré par la grammaire G
Corrigé:
1) G = (V, T, S, R)
Où V = {C}
T = {0, 1, …, 9}
R = { C  0|1|2|…|9| 0C|1C|…9C}
2) Le mot 0129 en effet:
C  0C  01C  012C  0129
Leila Ben Ayed Théorie des Langages et Compilation 97
III.1. Définition d’une grammaire
Exercice : Soit le langage L suivant :

L est l’ensemble des représentations décimales des entiers


naturels non nuls

1) Donner une expression régulière qui représente le langage L


2) Donner une grammaire G qui génère L
3) Vérifier que le mot 0129 est généré par la grammaire G
4) Construire un automate fini qui accepte le langage L

Leila Ben Ayed Théorie des Langages et Compilation 98


III.1. Définition d’une grammaire
Corrigé: 3) Le mot 0129 en effet:
1) 0*(1+…+9)(0+1+…+9)* A  0A
2) G = (V, T, S, R)  01B
Où  012B
V = {A, B}  0129B
T = {0, 1, …, 9}  0129
R = {A  0A|1B|2B|…|9B,
B  0B|1B|…9B|} 4)
0,1,2,3,4,5,6,7,8,9
0

1,2,3,4,5,6,7,8,9
A B

Leila Ben Ayed Théorie des Langages et Compilation 99


III.2. Langage généré par une grammaire

Définition:
Soit G = (V, T, S, R) une grammaire. Si T  X où X est un
alphabet alors on dit que G est une grammaire sur X.

Définition:
L(G) = {  T* /  est dérivé de S}
On dit que L(G) est le langage généré par G.

Leila Ben Ayed Théorie des Langages et Compilation 100


III.2. Langage généré par une grammaire

Exercice : Construire une grammaire G qui génère le langage L


suivant:
L = {anbmcn, m, n  |N}
Corrigé:
La grammaire G est définie comme suit :
G = (V, T, S, R)
V = {S, B}, T = {a, b, c}, R = {S  aSc, S  B, B  |bB}
G Génère le langage L(G) = {anbmcn, m, n  |N}

Leila Ben Ayed Théorie des Langages et Compilation 101


III.3. Grammaires régulières
Définition: (Grammaires régulières)
Une grammaire régulière est une grammaire avec les
restrictions suivantes:
• Le coté gauche de chaque production consiste en un seul
symbole non terminal.
• Le coté droit est :
• Soit un symbole terminal suivi d’un symbole non
terminal
• Soit un seul symbole terminal
• Soit 

Leila Ben Ayed Théorie des Langages et Compilation 102


III.3. Grammaires régulières
Exemple :
C  bD, C  a, B  
Est une grammaire régulière mais pas :
bD  A, A  acb, BA  Dec

Remarque:
Il est possible d’éliminer les règles de la forme : N  a en les
remplaçant par N  aX
X 
Où X est le nouveau symbole n’apparaissant pas dans la
grammaire initiale.

Leila Ben Ayed Théorie des Langages et Compilation 103


III.4. Langages réguliers et grammaires
régulières

Théorème
Pour chaque alphabet X,
{Langages réguliers sur X}
=
{L(G) / G est une grammaire régulière sur X}
=
{L(M) / M est un automate fini sur X}

Rq. Un langage est dit régulier s’il existe un automate fini qui
l’accepte ou bien une grammaire régulière qui le génère ou
bien une expression régulière qui le représente.
Leila Ben Ayed Théorie des Langages et Compilation 104
III.4. Langages réguliers et grammaires
régulières
Preuve:
• Conversion grammaire / automate
Soit G = (V, T, S, R) une grammaire régulière.
1) On peut transformer la grammaire G en une grammaire
G’ = (V’, T, S, R’)
Qui génère le même langage sur G, mais n’ayant pas de règle dont le coté droit
consiste en un seul symbole terminal (remplacer N  a par
N  aX, X  }.
2) On définit un automate fini M = (Q, X, , q0, F)
Q = V’
X=T
 = { (p, x, q} / p  xq  R’}
q0 = S
F = {q / (q )  R’}

Leila Ben Ayed Théorie des Langages et Compilation 105


III.4. Langages réguliers et grammaires
régulières
Exercice 1 : Soit la grammaire régulière G ayant les règles de
production suivantes, construire un automate A / L(G) = L(A)
G = (V, T, A, R)/ V = {A, B}, T = {a, b}, R = {A  bB | aA|, B  bB |}
Corrigé Exercice 1:
A  bB
a b
A  aA
b
A
A B
B  bB
B

Leila Ben Ayed Théorie des Langages et Compilation 106


III.4. Langages réguliers et grammaires
régulières
• Conversion automate/grammaire
Soit M = (Q, X, , q0, F) un automate fini,
On définit une grammaire G / L(G) = L(M) comme suit:
G = (V, T, S, R)/
V=Q
T=X
S = q0
R = {p  xq / (p, x, q)  }  {q  / q  F}

Leila Ben Ayed Théorie des Langages et Compilation 107


III.4. Langages réguliers et grammaires
régulières
Exercice : Soit l’automate fini A suivant :
A = (Q, X, , q0, F) / Q = {A, B}, X = {a, b},  = {(A, a, A), (A, b, B), (B, b, B)}, q0 = A,
F = {A, B}
Construire une grammaire régulière G / L(G) = L(A)

Corrigé Exercice 2:
G = (V, T, A, R)/ V = {A, B}, T = {a, b}, R = {A  bB | aA|, A  bB |}

A  bB
a b A  aA
b
A B A
B  bB
B

Leila Ben Ayed Théorie des Langages et Compilation 108


III.5. Les formes normales des grammaires

III.5.1. Forme standard binaire (CHOMSKY)


C’est la forme des règles de production suivantes :

A  BC ; A  a

A, B, C  V et a  X  {}

Leila Ben Ayed Théorie des Langages et Compilation 109


III.5. Les formes normales des grammaires
Exercice 1 : Soit la grammaire G suivante. Construire une grammaire G’ sous
forme de CHOMSKY qui génère L(G) (le langage généré par G)
G = ({S, A, B}, {a, b}, S, R)
R = { S  bA, S  aB,
A  a, B  b,
A  aS, B  bS,
A  bAA, B  aBB }

Corrigé Exercice 1: La forme standard binaire associée aux règles de production de la


grammaire G est :
R’= { S  C1A, A  C1C3, B  C2C4,
C1  b, C3  AA, C4  BB,
A  a, S  C2B,
A  C2S, B  b,
C2  a, B  C1S, }
La mise en forme standard binaire de la grammaire G donne la grammaire G’
G’ = ({S, A, B, C1, C2, C3, C4}, {a, b}, S, R’)
Leila Ben Ayed Théorie des Langages et Compilation 110
III.5. Les formes normales des grammaires

III.5.2. Forme standard de GREIBACK


C’est la forme des règles de production suivantes :

A  av

a  X, A  V, v  V*

Leila Ben Ayed Théorie des Langages et Compilation 111


III.5. Les formes normales des grammaires

Exercice 2: Soit la grammaire G suivante. Construire une


grammaire G’ sous forme GREIBACK qui génère L(G)
G = ({A1, A2, A3}, {a, b}, A1, R)
R = { A1  A2A3,
A3  A4A3,
A2  aA3,
A4  b,
A3  b }
Corrigé Exercice 2: La forme standard de GREIBACK associée est :
R’= { A1  aA3A3
A3  b A3
A3  b }
La mise en forme standard de GREIBACK de la grammaire G donne la grammaire G’
G’ = ({A1, A3}, {a, b}, A1, R’)

Leila Ben Ayed Théorie des Langages et Compilation 112


IV. Les grammaires non contextuelles
Plan
IV.1. Définition d’une grammaire non
contextuelle
IV.2. Dérivation
IV.3. Langage généré par une grammaire
IV.4. Langage hors contexte
IV.5. Dérivation, arbre et ambiguïté
IV.6. Propriétés des langages non
contextuels
Leila Ben Ayed Théorie des Langages et Compilation 113
IV.1. Définition d’une grammaire non
contextuelle (GNC)
Une grammaire non contextuelle G est un quadruplet:
G = (V, T, S, R)

V est un alphabet non terminal
T est un ensemble de terminaux
R est l’ensemble des règles de production de la forme
A  U / A V et U  (V  T)*
S est l’axiome de la grammaire (Symbole de départ) (S
 V)

Leila Ben Ayed Théorie des Langages et Compilation 114


IV.2. Dérivation
• U  V dénote la dérivation de V à partir de U
• U  V ssi il existe des chaines x, y, t  (V T)* et A  V
telles que : U = x Ay, V = x t y et A  t
G

Exemple
G = ({S}, {a, b}, S, {S  aSb |})
S  aSb ici U = S x =  et y = 
V = aSb A = S et t = aSb
aSb  aaSbb ici U = aSb x = a et y = b
V = aaSbb A = S et t = aSb
k
UV  U  U1  U2 … Uk = V

Leila Ben Ayed Théorie des Langages et Compilation 115


IV.3. Langage généré par une grammaire
*
• La relation  est la fermeture réflexive et transitive de 

G G

* k

S  k1/S
*
Par exemple S  aabb Puisque S aSb  aaSbb  aabb

Le langage généré par une grammaire G est L(G)


*
L(G) = { X* / S  }
*
Leila Ben Ayed Théorie des Langages et Compilation 116
aabb  L(G) par ce que S  aabb
IV.4. Langage hors contexte ou indépendant
du contexte

Un langage L est dit non-contextuel


ssi
Il existe une grammaire non-contextuelle G
telle que
L(G) = L

Si LR est l’ensemble des langages réguliers et LIC est l’ensemble des


langages indépendants du contexte, alors on a
LR  LIC

Leila Ben Ayed Théorie des Langages et Compilation 117


IV.4. Langage hors contexte ou indépendant
du contexte
Exemple : G génère la chaine (x1*x2+x1)*(x1+x2) par la
G = (V, X, E, R) dérivation suivante
V = {T, F, E} E  T (2)  T*F (3)  F*F (4)
X = {x1, x2, +, *, (, )}  (E)*F (5)  (E+T)*F (1)
R={ EE+T (1)  (T+T)*F (2)  (T*F+T)*F (3)
ET (2)  (F*F +T)*F (4)  (x1*F+T)*F (6)
T  T *F (3)  (x1*x2+T)*F (7)  (x1*x2+F)*F (4)
TF (4)  (x1*x2+x1)*F (6)  (x1*x2+x1)*(E) (5)
F  (E) (5)  (x1*x2+x1)*(E+ T) (1)
F  x1 (6)  (x1*x2+x1)*(T+ T) (2)
F  x2 (7)  (x1*x2+x1)*(F+ T) (4)
}  (x1*x2+x1)*(x1+ T) (6)
 (x1*x2+x1)*(x1+ F) (4)
 (x1*x2+x1)*(x1+ x2) (7)
L(G) est (ou bien G génère) l’ensemble des expressions arithmétiques
parenthèsées utilisant x1, x2 et les opérateurs arithmétiques + et *.
Leila Ben Ayed Théorie des Langages et Compilation 118
IV.4. Langage hors contexte ou indépendant
du contexte

Exercice :
1) Construire une grammaire G qui génère des expressions booléennes sur les
nombres entiers, les opérateurs arithmétiques {+, *}, les opérateurs booléens {et,
ou, non} et les opérateurs relationnels {>, <, = }
2) Vérifier que le mot (nb + nb) > nb est généré par la grammaire

Corrigé :
G = (V, X, Eb, R)
V = {Ea, Eb, Er}
X = {nb, +, *, (, ) , >, <, = , et, ou, non} où nb représente un nombre entier.
R={ Ea  Ea + Ea | Ea * Ea | nb | (Ea)
Er  Ea > Ea | Ea < Ea | Ea= Ea
Eb  Er | non Eb | Eb et Eb | Eb ou Eb | (Eb)
}

Leila Ben Ayed Théorie des Langages et Compilation 119


Exemple d’un langage indépendant du
contexte (LIC)

Lemme1
Tout langage L hors-contexte tel que  L
peut être engendré par une grammaire
hors-contexte sous forme normale de
GREIBACK

Leila Ben Ayed Théorie des Langages et Compilation 120


IV.5. Dérivation, arbre et ambiguïté
A chaque dérivation, on associe un arbre dont:
-La racine est étiquetée par le symbole de départ de la grammaire
-A un nœud étiqueté A, on associe les fils X1X2… Xn si la règle A X1X2…Xn a été
appliquée.

-Exemple
S  AB
Aa
Bb
Pour le mot ab, on a deux dérivations possibles :

1) S  AB  aB  ab
2) S  AB  Ab  ab

Leila Ben Ayed Théorie des Langages et Compilation 121


IV.5. Dérivation, arbre et ambiguïté
1) S  AB  aB  ab
2) S  AB  Ab  ab

Ces deux dérivations ne diffèrent que par l’ordre d’application des règles. En
conséquence, on fait correspondre le même arbre.

A B

a b

Leila Ben Ayed Théorie des Langages et Compilation 122


IV.5. Dérivation, arbre et ambiguïté
Dérivation la plus à gauche (lpg)
*
Pour un arbre donné correspondant à la dérivation : A  
Où   X*, il existe une dérivation unique ayant la propriété suivante :

A = 0  1  2 ……  n = 
et
 i = 0, …, n-1 : i = ui Ai yi
i+1 = ui Zi yi

(Ai  Zi)  R ; ui  X*

On l’appelle la dérivation la plus à gauche

Leila Ben Ayed Théorie des Langages et Compilation 123


IV.5. Dérivation, arbre et ambiguïté
Dérivation la plus à gauche (Exemple)
Soit G = ({S, A}, {a, b}, S, R) R = {S  aAb, S  a, S  abSbS, A  bS}
Soit  = ababa

Au mot , correspond la dérivation la plus à gauche suivante :

S  abSbS  ababS  ababa S

L’arbre correspondant est le suivant:


a b S b S
La dérivation S  abSbS  abSba  ababa
N’est pas une dérivation la plus àgauche a a

Leila Ben Ayed Théorie des Langages et Compilation 124


IV.5. Dérivation, arbre et ambiguïté

Lemme 2
Pour tout mot d’un langage L(G), il
existe une dérivation la plus à gauche

Leila Ben Ayed Théorie des Langages et Compilation 125


IV.5. Dérivation, arbre et ambiguïté
Exemple
Soit G = ({S, A}, {a, b}, S, R) R = {S  aAb, S  a, S  abSbS, A  bS}
Le mot  = abababab  L(G)
Une dérivation possible est qui n’est pas la plus à gauche:
S  abSbS (3)
 abSbaAb (1)
 abSbabSb (4)
 abSbabab (2)
L’arbre de dérivation est : S  abababab (2)

a b S b S

a a A b
b S
a
Leila Ben Ayed Théorie des Langages et Compilation 126
IV.5. Dérivation, arbre et ambiguïté
Exercice :
Soit une grammaire avec les règles de production suivantes :
R = {S  aAb, S  a, S  abSbS, A  bS, S  abSb}
1) Donner une dérvation la plus à gauche du mot abababab
2) Construire un arbre associé à cette dérivation
3) Construire deux dérivations les plus à gauche pour le mot abab
Corrigé:
1) La dérivation la plus à gauche : 2)
S  abSbS (3) S
 ababS (2)
 ababaAb (1) a b S b S
 abababSb (4)
 abababab (2) a
a A b

b S

a
Leila Ben Ayed Théorie des Langages et Compilation 127
IV.5. Dérivation, arbre et ambiguïté
R = {S  aAb, S  a, S  abSbS, A  bS, S  abSb}

3) S  aAb  abSb  abab S  abSb  abab

S S

a A b a b S b

b S a

Leila Ben Ayed Théorie des Langages et Compilation 128


IV.5. Dérivation, arbre et ambiguïté
Ambiguïté
Une grammaire G est dite ambiguë s’il existe un mot de L(G) qui a au moins 2
dérivations lpg à partir de S (donc deux arbres différents sont associés à ce mot).
Sinon G est non – ambiguë.

Exercice : Montrer que la grammaire G


suivante est ambigüe:
G = ({S, A}, {a, b}, b, R)
R = { S  aAb, S  a, S  abSb, A  bS}
Corrigé:
en effet, pour le mot abab il y a deux
dérivations lpg
S  aAb  abSb  abab
S  abSb  abab

Leila Ben Ayed Théorie des Langages et Compilation 129


IV.6. Propriétés des langages non contextuels
(LNC)

Soit LNC, l’ensemble des langages non contextuels:


-Si L1  LNC et L2  LNC alors
- L1  L2  LNC
- L1.L2  LNC
-Si L  LNC alors L*  LNC, L+  LNC et L  LNC
-On n’a pas la propriété pour L1L2 et pour L

Leila Ben Ayed Théorie des Langages et Compilation 130


IV.6. Propriétés des langages non contextuels
(LNC)
-Si L1  LNC et L2  LNC alors
L1  L2  LNC
En effet, on peut construire une grammaire non contextuelle
qui génère L1  L2 à partir des grammaires non contextuelles
qui génèrent L1 et L2
Soit G1 = (V1, T1, S1, R1) / L(G1) = L1 et
G2 = (V2, T2, S2, R2)/ L(G2) = L2
On peut construire G = (V, T, S, R) / L(G) = L(G1) L(G2)
- V= V1V2  {S} où S n’apparaît ni dans V1 ni dans V2 et
V1 et V2 sont disjoints si non on doit renommer les non
terminaux
- T = T1 T2
- R = R1  R2  {S  S1, S  S2}
Leila Ben Ayed Théorie des Langages et Compilation 131
IV.6. Propriétés des langages non contextuels
(LNC)
Exercice : Soient les langages L1 et L2 générés respectivement par G1 et
G2.
L1 = {anbn / n0}
L2 = {a2nbn / n  0}
G1 = ({S1}, {a, b}, S1, {S1 | aS1b})
G2 = ({S2}, {a, b}, S2, {S2 | aaS2b})
1) Construire une grammaire G / L(G) = L1  L2
2) Vérifier que le mot aab est généré par la grammaire G
Corrigé :
1) G = ({S1, S2, S}, {a, b}, S, {SS1, SS2, S1, S1aS1b, S2,
S2aaS2b})
2) Le mot aab est généré par G en effet S * aab
S  S2  aaS2b  aab donc aab  L(G)

Leila Ben Ayed Théorie des Langages et Compilation 132


IV.6. Propriétés des langages non contextuels
(LNC)
-Si L1  LNC et L2  LNC alors
L1 .L2  LNC
En effet, on peut construire une grammaire non contextuelle
qui génère L1.L2 à partir des grammaires non contextuelles
qui génèrent L1 et L2
Soit G1 = (V1, T1, S1, R1) / L(G1) = L1 et
G2 = (V2, T2, S2, R2)/ L(G2) = L2
On peut construire G = (V, T, S, R) / L(G) = L(G1).L(G2)
- V= V1V2  {S} où S n’apparaît ni dans V1 ni dans V2 et
V1 et V2 sont disjoints si non on doit renommer les non
terminaux
- T = T1 T2
- R = R1  R2  {S  S1 S2}
Leila Ben Ayed Théorie des Langages et Compilation 133
IV.6. Propriétés des langages non contextuels
(LNC)
Exercice: Construire une grammaire qui génère L1.L2
L1 = l+
L2 = (l+c)+ où l  {a, b, c, …z, A, B, C, …Z}= L et
c  {0, 1, 2, 3, …, 9}= C
G1 = ({S1}, L, S1, R1)
G2 = ({S2}, L C, S2, R2)
R1 = { S1 a, S1 b,…. S1 z , R2 = { S2 a, S2 b,…. S2 z ,
S1 A, S1 B, … S1 Z, S2 A, S2 B, … S2 Z,
S1 aS1, S1 bS1,…. S1 zS1, S1 S2 0, S2 1,…. S2 9,
AS1, S1 BS1, … S1 ZS1} S2 aS2, S2 bS2,…. S1 zS2, S2
AS2, S2 BS2, … S2 ZS2,
S2 0S2, S2 1S2, … S2 9S2}

Corrigé: G / L(G) = L1.L2 = l+(l+c)+


G = ({S1,S2,S}, LC, S, R1R2  {SS1S2})
Leila Ben Ayed Théorie des Langages et Compilation 134
IV.6. Propriétés des langages non contextuels
(LNC)
Exercice :
1) Construire une grammaire G qui génère L1. L2
2) Vérifier que le mot temp1 est généré par G L1 = l+
L2 = (l+c)* où l  {a, b, c, …z, A, B, C, …Z}= L et
c  {0, 1, 2, 3, …, 9}= C
G1 = ({S1}, L, S1, R1)
= a,
R1 = { G2S1 S1 b,….
({S2}, L R2)z ,
C, S2, S1 R2 = { S2 
S1 A, S1 B, … S1 Z, S2 aS2, S2 bS2,…. S1 zS2, S2
S1 aS1, S1 bS1,…. S1 zS1, S1 AS2, S2 BS2, … S2 ZS2,
AS1, S1 BS1, … S1 ZS1} S2 0S2, S2 1S2, … S2 9S2}

Corrigé :
1) G / L(G) = L1.L2 = l+(l+c)*
G = ({S1,S2,S}, LC, S, R1R2  {SS1S2})
Leila Ben Ayed Théorie des Langages et Compilation 135
IV.6. Propriétés des langages non contextuels
(LNC)

G / L(G) = L1.L2 = l+(l+c)*


G = ({S1,S2,S}, LC, S, R1R2  {SS1S2})

2) Vérifier que le mot temp1 est généré par G


Mq S * temp1
S  S1S2  tS1S2 teS1S2 temS1S2 tempS2 temp1S2
temp1

Leila Ben Ayed Théorie des Langages et Compilation 136


IV.6. Propriétés des langages non contextuels
(LNC)
-Si L  LNC alors L*  LNC
En effet, on peut construire une grammaire non contextuelle
qui génère L* à partir d’une grammaire non contextuelles qui
génère L
Soit G1 = (V1, T1, S1, R1) / L(G1) = L
On peut construire G = (V, T, S, R) / L(G) = (L(G1))*
- V= V1 {S} où S n’apparaît pas dans V1
- T = T1
- R = R1  {S  , S  S1 S}

Leila Ben Ayed Théorie des Langages et Compilation 137


IV.6. Propriétés des langages non contextuels
(LNC)
Exercice : Soit la grammaire G1 suivante qui génère le
langage L = {a, b}
G1 = ({S1}, {a, b}, S1, {S1a |b})
1) Construire une grammaire G / L(G) = L*
2) Vérifier que le mot aab est généré par la grammaire G
Corrigé :
1) G = ({S1, S}, {a, b}, S, {S  , S  S1 S, S1a,
S1b})
2) Vérifier que le mot aab est généré par G. Mq S * aab
S  S1S  S1S1S  S1S1S1S  aS1S1S  aaS1S  aabS  aab

Leila Ben Ayed Théorie des Langages et Compilation 138


IV.6. Propriétés des langages non contextuels
(LNC)
-On n’a pas Si L1  LNC et L2  LNC alors L1 L2  LNC
Contre exemple:
L1 = {aibick/ i 0, k0}  LNC
G1 = ({S, S1, S2}, {a, b, c}, S, {SS1 S2, S1  |aS1b,
S2  |cS2})
L2 = {akbici/ i 0, k0}  LNC
G2 = ({A, B, C}, {a, b, c}, C, {CAB, A  |aA,
B  |bBc})
L1  L2 = {aibici/ i 0}  LIC car il n’existe aucune
grammaire non
contextuelle qui le génère
Leila Ben Ayed Théorie des Langages et Compilation 139
V. Les automates à Piles
Plan

V.1. Présentation
V.2. Définition d’un automate à pile
V.3. Description d’un automate à pile
V.4. Exemple d’automate à Pile
V.5. Fonctionnement d’un automate à pile
V.6. Langages acceptés par des automates à pile
V.7. Construction d’un automate à pile à partir d’une
grammaire non contextuelle

Leila Ben Ayed Théorie des Langages et Compilation 140


V.1. Présentation
L’automate fini permet de représenter une grammaire régulière. Par suite, il permet de
reconnaître des mots d’un langage régulier (associé à une grammaire régulière).
À une règle (A  x B) d’une grammaire régulière, on peut associer une transition
(A, x, B)

A x B

Partant d’une grammaire non contextuelle ayant une règle de production de la forme
(A  x B y), l’automate doit se souvenir qu’il doit lire la chaine y après avoir lu la sous
chaine dérivant de B. Pour cette raison, on ajoute une pile à l’automate fini où on
empile ce que nous avons à lire (x) et après avoir dérivé la sous chaine dérivant de B,
on doit lire y et dépiler le y de la pile.
On parle d’automate à pile

Leila Ben Ayed Théorie des Langages et Compilation 141


V.2. Définition d’un automate à pile
Un automate à pile A est un septuplet

A = < X, Q, q0, F, , Z0, >

X est un alphabet
Q est un ensemble d’états
q0  Q est l’état initial
F  Q est l’ensemble des états finaux
 est le vocabulaire de la pile
Z0 est le symbole initial de la pile (symbole de fond de pile)
d est une fonction de transition
d : Q x (X  {}) x   { parties finies de Q x *}

Leila Ben Ayed Théorie des Langages et Compilation 142


V.3. Description d’un automate à pile
Z0 Pile

Tête de lecture/écriture

q Unité de contrôle

Tête de lecture

U V Ruban d’entrée

L’unité de contrôle, se trouve à un état q munie de deux têtes (L/E sur pile
et L sur ruban d’entrée). Le ruban d’entrée sert de support à un mot de X *.
La lecture se fait de gauche à droite. La pile est un ruban infini du côté droit
où sont lus et écrits les symboles de la pile (*). La case lue est toujours
celle qui contient le symbole le plus à droite.
Leila Ben Ayed Théorie des Langages et Compilation 143
V.4. Exemple d’un automate à pile qui
accepte {ancbn / n 0}
(a, Z0, Z0a)
(a, a, aa) •Commencer par empiler tous les a
q0 •On doit lire un c
• Le c peut être précédé d’un a
comme il peut être le seule
symbole dans le mot
(c, a, a) • Dans les deux cas, il ne doit pas
(c, Z0 , Z0) être empilé et il faut changer
d’état pour séparer la lecture
des a de la lecture des b.
•si on lit un b alors il doit être
q1 (b, a, ) précédé d’un a. On le dépile et on
(, Z0, ) continue à accepter uniquement des
b et dépiler les a correspondants.
•A la fin, il faut arriver à vider la pile

Leila Ben Ayed Théorie des Langages et Compilation 144


Exemple d’un automate à pile qui accepte
{ancbn / n 0} suite
Acceptation du mot aacbb

aacbb aacbb aacbb aacbb aacbb aacbb aacbb


q0 q0 q0 q1 q1 q1 q1

Z0 Z0a Z0aa Z0aa Z0a Z0

Le mot aacbb est lu et la pile est vide alors il est accepté

Rejet du mot acbb


Le mot acbb n’est pas
acbb acbb acbb acbb accepté par ce que le mot
n’est pas entièrement lu.
q0 q0 q1 q1
La transition de q1 avec b,
Z0 n’est pas définie.
Z0 Z0a Z0a Z0

Leila Ben Ayed Théorie des Langages et Compilation 145


Exemple d’un automate à pile qui accepte
{ancbn / n 0} suite
Le mot c est accepté

C C C
q0 q1 q1

Z0 Z0

Le mot c est lu et la pile est vide alors il est accepté

Rejet du mot aacb

aacb aacb aacb aacb aacb


q0 q0 q0 q1 q1

Z0 Z0a Z0aa Z0aa Z0a

Le mot aacb n’est pas accepté par ce que on n’arrive pas à vider la pile
Leila Ben Ayed Théorie des Langages et Compilation 146
V.5. Fonctionnement d’un automate à pile
a- Configuration
Une configuration d’un automate à pile est le contenu des deux rubans, d’un état
et de la lettre à lire

 = (U, q, aV, Z)


Où Le contenu du ruban d’entrée est : UaV
Le contenu de la pile est : Z avec  *
Z   : sommet de pile

La configuration initiale est : (, q0, , Z0)


U =  par ce que rien n’a été lu donc  lu
aV =  puisqu’il reste tout le mot à lire
L’état initial est q0
Le symbole sommet de pile est le symbole fond de pile Z0 puisque la pile est

vide
Leila Ben Ayed initialement Théorie des Langages et Compilation 147
V.5. Fonctionnement d’un automate à pile
b- Configuration successeur de  = (U, q, aV, Z)
 est une configuration successeur de  qu’on note  |--  si

Si (qi, i)  δ(q, a, Z) alors  = (Ua, qi, V,  i)


(qi, i)  δ(q, , Z) alors  = (U, qi, aV,  i)

Autrement dit, le symbole a peut ou non être lu ( transition, sans consommer un


symbole), l’unité de contrôle passe de l’état q à l’état qi. Le symbole au sommet Z
est remplacé par i

c- Configuration k successeur
k
 |--    |-- 1 |-- 2 |-- … k / k = 
* k
 |--   k0  |-- 
+ k

Leila 
|--Ayed
Ben k>0  |--  Théorie des Langages et Compilation 148
V.5. Langages acceptés par un automate à
pile
Deux critères d’acceptation sont définis pour un automate à pile
- Le critère pile vide (mot accepté = mot lu + pile vide)
- Le critère état final (mot accepté = mot lu + état final)

Pour un automate à pile A= <X, Q, q0, F, , Z0,  >,


L(A) désigne le langage accepté avec le critère pile vide
c-a-d un mot  est accepté par A ssi en partant d’une pile contenant Z0 comme
symbole de fond de pile, après la lecture du mot, on arrive à vider la pile.
N(A), le langage accepté avec le critère état final
c-a-d un mot  est accepté par A ssi en partant d’une pile contenant Z0 comme
symbole de fond de pile, après la lecture du mot, on arrive à un état final ; pas de
soucis sur le contenu de la pile.

Leila Ben Ayed Théorie des Langages et Compilation 149


V.5. Langages acceptés par un automate à
pile

Pour un automate à pile A, deux langages sont acceptés L(A) et N(A) qui peuvent être
vides (cas de N(A) lorsqu’il n’ya pas d’état final N(A) =  si F = )
*
L(A) = {  X* / (, q0,  , Z0) |-- ( , q, , )}
*
N(A) = {  X* / (, q0,  , Z0) |-- (, qF, , )/ qF  F}

On n’a pas toujours L(A) = N(A) mais on a :


$ A’ / L(A) = N(A’) et
 A’’/ L(A’’) = N(A)

Leila Ben Ayed Théorie des Langages et Compilation 150


V.5. Langages acceptés par un automate à
pile
Pour un automate à pile A sans état final,N(A) = 
(a, Z0, Z0a)
A (a, a, aa) Pour l’automate A suivant :
q0 L(A) = {anbn / n 1}
N(A) = {aibj / i j>0}

a2b2  L(A) en effet


(b, a, )
(, q0, aabb, Z0) |-- (a, q0, abb, Z0 a)
|-- (aa, q0, bb, Z0 aa) |-- (aab, q1, b, Z0 a)
|-- (aabb, q1, , Z0 )|-- (aabb, q1,  ,  )
(b, a, )
q1
(, Z0, )
a2b  N(A) en effet
( , q0, aab , Z0) |-- (a, q0, ab, Z0 a)
|-- (aa, q0, b, Z0 aa) |-- (aab, q1,  , Z0 a)

Leila Ben Ayed Théorie des Langages et Compilation 151


V.6. Construction d’un automate à pile à partir
d’une grammaire non contextuelle (GNC)
Définition. Un langage est dit non contextuel ou indépendant du contexte ou hors
contexte s’il existe un automate à pile qui l’accepte

Construction d’un automate à pile à partir d’une


grammaire non contextuelle
Soit G = (V, T, S, R) une GNC, il existe un automate
à pile A / N(A) = L(G)
A = < X, Q, q0, F, , Z0, >

X=T
Q = {q0, q1}
F = {q1}
G= X  {Z0}
 / (q0, , Z0) = (q1, S)
(q1, , A) = (q1, )  A  ~  R
(q1, a, a) = (q1, )  a  X

Leila Ben Ayed Théorie des Langages et Compilation 152


 / (q0, , Z0) = (q1, S)
(q1, , A) = (q1, )  A  ~  R
(q1, a, a) = (q1, )  a  X

Exercice : Soit la grammaire G suivante.


G = ({S} , {a, b}, S, R)
R = {S  aSb, S  }
1) Construire un automate à pile qui accepte L(G) q0
avec le critère état final
2) Vérifier que le mot aabb est accepté par
l’automate
Corrigé : (, Z0, S)
1)  / (q0, , Z0) = (q1, S)
(q1, , S) = (q1, bSa)
(q1, , S) = (q1, )
(q1, a, a) = (q1, ) q1
(q1, b, b) = (q1, ) (, S, bSa) (, S, )
(a, a, ) (b, b, )

Leila Ben Ayed Théorie des Langages et Compilation 153


V.6. Construction d’un automate à pile à partir
d’une grammaire non contextuelle (GNC)

q0
1)  / (q0, , Z0) = (q1, S)
(q1, , S) = (q1, bSa)
(q1, , S) = (q1, )
(q1, a, a) = (q1, ) (, Z0, S)
(q1, b, b) = (q1, )

q1
(, S, bSa) (, S, )
(a, a, ) (b, b, )

Leila Ben Ayed Théorie des Langages et Compilation 154


V.6. Construction d’un automate à pile à partir
d’une grammaire non contextuelle (GNC)

2) Vérifier que le mot  = aabb est accepté par


l’automate q0
(, q0, aabb, Z0) |-- (, q1, aabb, S)
|-- (, q1, aabb, bSa)
|-- (a, q1, abb, bS)
|-- (a, q1, abb, bbSa) (, Z0, S)
|-- (aa, q1, bb, bbS)
|-- (aa, q1, bb, bb)
|-- (aab, q1, b, b)
|-- (aabb, q1, , ) q1
(, S, bSa) (, S, )
(a, a, ) (b, b, )

Leila Ben Ayed Théorie des Langages et Compilation 155


Exercices
Exercice 1 : Construire un automate à pile qui accepte {ancbn / n1}

(a, Z0, Z0a)


•Commencer par empiler tous les a
(a, a, aa) •On doit lire un c
q1 • Le c doit être précédé d’un a. Le
c ne doit pas être empilé et il
faut changer d’état pour séparer
la lecture des a de la lecture des
(c, a, a)
b.
•si on lit un b alors il doit être
précédé d’un a. On le dépile et on
continue à accepter uniquement des
b et dépiler les a correspondants.
q2 (b, a, )
•A la fin, il faut arriver à vider la pile
(, Z0, )

Leila Ben Ayed Théorie des Langages et Compilation 156


Exercices
Exercice 1 : Construire un automate à pile qui accepte {xnyzn+1 / n0}

(x, Z0, Z0x)


(x, x, xx) (, q0, xyzz, Z0) |-- (x, q0, yzz, Z0x)
q0 |-- (xy, q1, zz, Z0x)
|-- (xyz, q1, z, Z0)
|-- (xyzz, q1, , )
(y, x, x),
(y, Z0, Z0) Donc le mot xyzz est accepté par
l’automate

q1 (z, x, ) (, q0, yz, Z0) |-- (y, q1, z, Z0)


(z, Z0 , ) |-- (yz, q1, , )
Donc le mot yz est accepté par
l’automate

Leila Ben Ayed Théorie des Langages et Compilation 157


Exercices
Exercice 2 :
1) Construire un automate à pile qui accepte {anbn / n0} avec le critère pile vide
2) Vérifier que le mot aabb est accepté par l’automate

•Commencer par empiler tous les a


1) (, Z0, ) •si on lit un b alors il doit être
(a, Z0, Z0a) précédé d’un a. On le dépile et on
q0 (a, a, aa) change d’état pour accepter
uniquement un b et dépiler un a
correspondant.
•A la fin il faut arriver à vider la pile
(b, a, )
2) Vérifier que le mot  = aabb est accepté par
l’automate
(, q0, aabb, Z0) |-- (a, q0, abb, Z0a)
|-- (aa, q0, bb, Z0aa)
q1 (b, a, ) |-- (aab, q1, b, Z0a)
(, Z0, ) |-- (aabb, q1, , Z0)
|-- (aabb, q1, , )
Leila Ben Ayed Théorie des Langages et Compilation 158
Exercices
Exercice 3 :
1) Construire un automate à pile qui accepte {anbn / n0} avec le critère état final
2) Vérifier que le mot aabb est accepté par l’autmoate
a, Z0, Z0a)
1) (a, a, aa)
Un mot est accepté si après la lecture du
q0
mot, on atteint un état final

2) Vérifier que le mot  = aabb est accepté


(b, a, ) par l’automate
(, Z0, Z0) (, q0, aabb, Z0) |-- (a, q0, abb, Z0a)
|-- (aa, q0, bb, Z0aa)
|-- (aab, q1, b, Z0a)
|-- (aabb, q1, , Z0)
q1
|-- (aabb, q2, , Z0)
(b, a, )

(, Z0, Z0)


q2
Leila Ben Ayed Théorie des Langages et Compilation 159
Exercices
Exercice 4 :
1) Construire un automate à pile qui accepte {anbm / m>n} avec le critère état final
2) Vérifier que le mot abb est accepté par l’automate
(a, Z0, Z0a)
1) (a, a, aa)
q0
2) Vérifier que le mot  = abb est accepté
par l’automate
(, q0, abb, Z0) |-- (a, q0, abb, Z0a)
(b, a, ) |-- (ab, q1, b, Z0)
(b, Z0, Z0)
|-- (abb, q2, , Z0)

q1
(b, a, )
(b, Z0, Z0)
q2
Leila Ben Ayed
(b, Z0, Z0Théorie
) des Langages et Compilation 160
Exercices
Exercice 5 :
1) Construire un automate à pile qui accepte {anbm / m>n} avec le critère pile vide
2) Vérifier que le mot abb est accepté par l’automate
(a, Z0, Z0a)
1) (a, a, aa)
q0
2) Vérifier que le mot  = abb est accepté
par l’automate
(, q0, abb, Z0) |-- (a, q0, bb, Z0a)
(b, a, )
(b, Z0, Z0) |-- (ab, q1, b, Z0)
|-- (abb, q2, , Z0)
|-- (abb, q2, , )

q1 (b, a, )

(b, Z0, Z0)


q2 (b, Z0, Z0)
Leila Ben Ayed ) des Langages
(, Z0,Théorie et Compilation 161
Exercices
Exercice 6 :
1) Construire un automate à pile qui accepte {anbm / n>m} avec le critère état final
2) Vérifier que le mot aab est accepté par l’automate

(a, Z0, Z0a)


q0 •Il n’est pas nécessaire de vider la pile
(a, a, aa) Il suffit d’atteindre un état final (avoir
un a au moins dans la pile

(b, a, ) Vérifier que le mot  = aab est accepté


(, a, a) par l’automate
(, q0, aab, Z0) |-- (a, q0, ab, Z0a)
|-- (aa, q0, b, Z0aa)
|-- (aab, q1, , Z0a)
q1 |-- (aab, q2, , Z0a)
(b, a, )
(, a, a)
q2

Leila Ben Ayed Théorie des Langages et Compilation 162


Exercices
Exercice 7 :
1) Construire un automate à pile qui accepte {anbm / n>m} avec le critère pile vide
2) Vérifier que le mot aab est accepté par l’automate
3) Calculer L(A ) et N(A)

1) (a, Z0, Z0a)


q0 •Il est nécessaire de vider la pile
(a, a, aa) Même si il ya des états finaux
2) Vérifier que le mot  = aab est accepté
par l’automate (aabL(A))
(b, a, )
(, a,  ) (, q0, aab, Z0) |-- (a, q0, ab, Z0a)
|-- (aa, q0, b, Z0aa)
|-- (aab, q1, , Z0a)
|-- (aab, q2, , Z0)
q1 |-- (aab, q2, , )
(b, a, )
(, a,  ) 3) L(A) = {anbm / n>m}
N(A) =  car F = 
q2 (, a,  )
(, Z0,  )
Leila Ben Ayed Théorie des Langages et Compilation 163
Exercices
Exercice 8 : Soit l’automate à pile suivant :
1) Quel est le langage accepté par l’automate suivant
2) Vérifier que le mot aaab est accepté avec le critère état final et le critère pile vide
(a, Z0, Z0a)
(a, a, aa) 1) On obtient : L(A) = N(A) = {anbm/n>m}
q0
2) Vérifier que le mot  = aaab  L(A)
(, q0, aaab, Z0) |-- (a, q0, aab, Z0a)
|-- (aa, q0, ab, Z0aa)
(b, a, ) |-- (aaa, q0, b, Z0aaa)
(, a,  )
|-- (aaab, q1, , Z0aa)
|-- (aaab, q2, , Z0a)
|-- (aaab, q2, , Z0)
q1 |-- (aab, q2, , )
Vérifier que le mot  = aaab  N(A)
(b, a, )
(, q0, aaab, Z0) |-- (a, q0, aab, Z0a)
(, a,  ) |-- (aa, q0, ab, Z0aa)
q2 |-- (aaa, q0, b, Z0aaa)
(, a,  ) |-- (aaab, q1, , Z0aa)
Leila Ben Ayed (, Z0,  ) Théorie des Langages et Compilation|-- (aaab, q2, , Z0a) 164
Exercices
Exercice 9 :
1) Construire un automate fini qui accepte {anbm / nm} avec le critère état final
2) Vérifier que le mot aabb est accepté par l’automate
3) Déduire le langage accepté avec le critère pile vide
(a, Z0, Z0a)
1) •Il n’est pas nécessaire de vider la pile
q0 (a, a, aa)
2) Vérifier que le mot  = aabb est accepté par
l’automate
(, a, a) (, q0, aabb, Z0) |-- (a, q0, abb, Z0a)
(b, a, )
(, Z0, Z0) |-- (aa, q0, bb, Z0aa)
|-- (aab, q1, b, Z0a)
|-- (aabb, q1, , Z0)
|-- (aabb, q2, , Z0)
q1
(b, a, ) 3)
(, a, a) N(A) = {anbm / nm}
(, Z , Z ) Le langage accepté avec le critère pile vide
q2 0 0
L(A) =  car on n’arrive pas à vider la pile
Leila Ben Ayed Théorie des Langages et Compilation 165
Exercices
Exercice 10 :
1) Construire un automate fini qui accepte {anbm / nm} avec le critère pile vide
2) Vérifier que le mot aabb est accepté par l’automate
(a, Z0, Z0a)
1) (a, a, aa) •Il est nécessaire de vider la pile
q0 (, Z0,  )

2) Vérifier que le mot  = aabb est accepté par


(b, a, ) l’automate
(, a,  ) (, q0, aabb, Z0) |-- (a, q0, abb, Z0a)
|-- (aa, q0, bb, Z0aa)
|-- (aab, q1, b, Z0a)
q1 |-- (aabb, q1, , Z0)
(b, a, ) |-- (aabb, q2, , )

(, a,  )
q2 (, Z0,  )
(, a,  )
(, Z0,  )
Leila Ben Ayed Théorie des Langages et Compilation 166
Exercices
Exercice 11 :
1) Construire un automate à pile qui accepte {anbmct/ t = n+ m} avec le critère pile
vide
2) Vérifier que le mot abcc est accepté par l’automate
(a, Z0, Z0a)
1) (a, a, aa) •Il est nécessaire de vider la pile
q0 (, Z0,  )
n=m=0
(b, Z0, Z0b) 2) Vérifier que le mot  = abcc est accepté par
(b, a, ab) l’automate
(c, a,  ) (, q0, abcc, Z0) |-- (a, q0, bcc, Z0a)
q1
(b, b, bb) |-- (ab, q1, cc, Z0ab)
|-- (abc, q2, c, Z0a)
(c, b, ) |-- (abcc, q2, , Z0)
n=0 |-- (abcc, q2, , )
q2
(c, b,  )
(c, a,  )
m=0 (, Z0,  )
Leila Ben Ayed Théorie des Langages et Compilation 167
Exercices
Exercice 11 :
1) Construire un automate à pile qui accepte {anbmct/ t = n+ m} avec le critère état
final
2) Vérifier que le mot abcc est accepté par l’automate
(a, Z0, Z0a)
1) (a, a, aa) •Il est nécessaire d’atteindre un état
q0 final

(b, Z0, Z0b)


(b, a, ab)
(c, a,  ) (, Z0,  )
q1
(b, b, bb) n=m=0

(c, b, )
n=0
q2
(c, b,  ) (, Z0,  )
(c, a,  )
m=0
Leila Ben Ayed Théorie des Langages et Compilation 168
Exercices
Exercice
1) Construire un automate fini qui accepte {anb2nck/ k >0} avec le critère pile vide

(a, Z0, Z0aa)


(a, a, aaa) •Il est nécessaire de vider la pile
q0

(b, a,  ) 2) Vérifier que le mot  = abbcc est accepté


par l’automate
(c, Z0, Z0 ) (, q0, abbcc, Z0) |-- (a, q0, bbcc, Z0aa)
q1
(b, a,  ) |-- (ab, q1, bcc, Z0a)
|-- (abb, q1, cc, Z0)
(c, Z0, Z0) |-- (abbc, q2, c, Z0)
|-- (abbcc, q2, , Z0)
q2 |-- (abbcc, q2, , )
(c, Z0, Z0)
(, Z0,  )
n=0
Leila Ben Ayed Théorie des Langages et Compilation 169
Exercices
Exercice
1) Construire un automate fini qui accepte {anb2nck/ k >0} avec le critère état final

(a, Z0, Z0aa)


(a, a, aaa) •Il est nécessaire de vider la pile
q0

(b, a,  ) 2) Vérifier que le mot  = abbcc est accepté


par l’automate
(c, Z0, Z0 ) (, q0, abbcc, Z0) |-- (a, q0, bbcc, Z0aa)
q1
(b, a,  ) |-- (ab, q1, bcc, Z0a)
|-- (abb, q1, cc, Z0)
(c, Z0, Z0) |-- (abbc, q2, c, Z0)
|-- (abbcc, q2, , Z0)
q2
(c, Z0, Z0)

n=0
Leila Ben Ayed Théorie des Langages et Compilation 170
Exercices
Exercice 12 :
Construire un automate à pile qui accepte les mots palindrômes sur le vocabulaire
{a,b,c} avec le critère pile vide

(a, Z0, Z0a) (b, Z0, Z0b) (c, Z0, Z0c)


(a, a, aa) (b, b, bb) (c, c, cc) L’automates accepte
q0 (a, b, ba) (b, a, ab) (c, a, ac) les mots palindromes
(a, c, ca) (b, c, cb) (c, b, bc) de longueur impaire
et les mots de
longueur paire
(a, a, ) (a, a, a) (b, b, b) (c, c, c) Avec le critère pile
(b, b, ) (a, b, b) (b, a, a) (c, a, a) vide.
(c, c, ) (a, c, c) (b, c, c) (c, b, b) -------
(a, Z0, ), (b, Z0, ), (c, Z0, ) Un mot palindrome
est identique à son
q1 (a, a, ) image miroire comme
(b, b, ) ‘abbcbcbba’
(c, c, ) Ou bien ‘abba’
(, Z0,  ) Cas des mots a, b ou c
Leila Ben Ayed Théorie des Langages et Compilation 171
VI. Les machines de Turing
Plan

VI.1. Description d’une machine de Turing


VI.2. Fonctionnement d’une machine de Turing
VI.3. Utilisation d’une machine de Turing
VI.4. Variantes de machines de Turing
VI.5. Relation avec les calculateurs et fonction T-
Calculable
VI.6. Machine de Turing et langages
VI.7. Combinaison de machines de Turing

Leila Ben Ayed Théorie des Langages et Compilation 172


VI.1. Description d’une machine de Turing
Une machine de Turing (m.t) est composée d’un ruban infini décomposé en carrés,
d’une tête de lecture/ecriture sur ce ruban et une unité de contrôle par un nombre fini
d’états. Le calcul d'une machine de Turing est formé d'une suite d'étapes de calcul qui
sont effectuées par la machine. A chaque étape, la m.t, lisant un carré du ruban, peut
changer d’état, changer le contenu du carré lu et se déplacer sur le ruban à droite ou à
gauche d’une case ou bien rester sur place. Les étapes de calcul possibles sont décrites
par les transitions de la machine.

Z0 Ruban infini

Tête de lecture/écriture

q Unité de contrôle

Leila Ben Ayed Théorie des Langages et Compilation 173


VI.1. Description d’une machine de Turing
Définition
Nous donnons la définition précise d'une machine de Turing. De manière formelle, une
machine de Turing M est un Quadruplet (Q, X, , q0, ) où

Q est l'ensemble des états de contrôle.


X ensemble fini des symboles lus et écrits sur la bande contenant # . Il contient
l’alphabet d’entrée et l’alphabet de sortie sur la bande.
δ la fonction de transition de la machine
δ : Q x X  Q x X x {1, 0, -}
est un ensemble fini de transitions de la forme (qi, sj, qij, sij, dij) où qi et qij sont des
états, sj et sij sont des symboles de bande et dij est un élément de {Droite, Gauche
et Arrêt}. Une transition (qi, sj, qij, sij, dij) est aussi notée : qi, sj → qij, sij, dij.
q0 est l'état initial. C'est un état particulier de Q dans lequel se trouve la machine au
début d'un calcul.
# est le symbole blanc qui, au départ, remplit toutes les positions de la bande autres
que celles contenant la donnée initiale.
qF est l’état final. qF  Q
Leila Ben Ayed Théorie des Langages et Compilation 174
VI.2. Fonctionnement d’une machine de
Turing
d fonction de transition de la machine :

d : Q x X  Q x X x {1, 0, -}

droite gauche arrêt

Dans un état qi, lisant un symbole sj, la machine va dans l’état qij, remplace le
symbole lu par sij et effectue un déplacement dij. Les instructions pour une
machine de Turing sont représentées par des quintuples: (qi, sj, qij, sij, dij)
sj  sij, dij
qi qj

Leila Ben Ayed Théorie des Langages et Compilation 175


VI.2. Fonctionnement d’une machine de
Turing
Exemple1: Machine M1 d’effacement des symboles non blancs

M1 = ({q0}, {a,#}, δ, q0) avec δ :


δ(q0,a)=(q0,#, 1);
δ(q0,#)=(q0,#, -);

– Cette machine permet d’effacer la bande contenant une suite de ‘a’ et les
remplacer par des ‘#’

Exemple2: Machine M2 de déplacement de la tête à gauche jusqu’au blanc ‘#’

M2 = ({q0}, {a,#}, δ, q0) avec δ :


δ(q0,a)=(q0, a, 0); et δ(q0,#)=(q0,#, -)

Leila Ben Ayed Théorie des Langages et Compilation 176


VI.2. Fonctionnement d’une machine de
Turing
(q1, a) = (q2, b, 0) Lire a Ecrire b
Se déplacer à gauche
a  b, 0
q1 q2

(q1, a) = (q2, b, 1) Lire a Ecrire b


Se déplacer à droite
a  b, 1
q1 q2

Leila Ben Ayed Théorie des Langages et Compilation 177


VI.2. Fonctionnement d’une machine de
Turing

Configuration i ………. b b b a c a ………...

q1 Etat Courant
(q1, a) = (q2, b, 1)
q1
a  b, 1 q2

………. b b b b c a ………...
Configuration i+1

q2 Etat Courant
Leila Ben Ayed Théorie des Langages et Compilation 178
VI.2. Fonctionnement d’une machine de
Turing

Configuration i ………. b b b a c a ………...

q1 Etat Courant
(q1, a) = (q2, b, 0)
q1
a  b, 0 q2

………. b b b b c a ………...
Configuration i+1

q2 Etat Courant
Leila Ben Ayed Théorie des Langages et Compilation 179
VI.2. Fonctionnement d’une machine de
Turing
Si la machine s’arrête dans un
Un mot accepté état final et le mot est
entièrement lu

Si la machine s’arrête dans un état


Un mot rejeté non-final ou
la machine entre dans une boucle
infinie

La machine halt si il n’existe aucune


Transition possible à exécuter

Leila Ben Ayed Théorie des Langages et Compilation 180


VI.2. Fonctionnement d’une machine de
Turing
Exemple : Une machine de Turing qui accepte a*

a  a, 1

q1
  , - q2

Leila Ben Ayed Théorie des Langages et Compilation 181


VI.2. Fonctionnement d’une machine de
Turing
a  a, 1
Rejet   , -
q1 q2

Le mot aba est rejeté


Configuration 1    a b a   

q1
Configuration 2 finale    a b a   
Pas de transition possible
Arrêt + rejet du mot aba
q1
Leila Ben Ayed Théorie des Langages et Compilation 182
VI.2. Fonctionnement d’une machine de
Turing
a  a, 1
Acceptation q1
  , - q2

Le mot aaa est accepté


Configuration 1    a a a   

q1
Configuration 4 finale    a a a   
Arrêt + acceptation du mot aaa
q1
Leila Ben Ayed Théorie des Langages et Compilation 183
VI.2. Fonctionnement d’une machine de
Turing
Boucle infinie
Configuration 1    a b a   
b  b, 0
a  a, 1 q1

q1
  , - q2
Configuration 2    a b a   

b  b, 0 q1
a  a, 1
Configuration 3    a b a   

q1
  , - q2
q1
Leila Ben Ayed Théorie des Langages et Compilation 184
VI.2. Fonctionnement d’une machine de
Turing
Configuration 1    a b a   
Boucle infinie
q1
b  b, 0    a b a   
Configuration 2
a  a, 1
  , - q1
q1 q2    a b a   
Configuration 3
q1
Configuration 4    a b a   

et ca reboucle q1
A cause de la boucle infinie, l’état final n’est jamais atteint, la
machine ne s’arrête jamais et le mot en entrée n’est pas accepté
Leila Ben Ayed Théorie des Langages et Compilation 185
Succession de Configurations
1 2
………. # x a y b # # ………... ………. # x a y b # # ………...

q2 q0

3 4
………. # x x y b # # ………... ………. # x x y b # # ………...

q1 q1
x, x, d a, x, d y, y, d

q 2 Ben Ayed
Leila q0 q1 Théorie des Langages
q1et Compilation ….. 186
Succession de Configurations
1 2
………. # x a y b # # ………... ………. # x a y b # # ………...

q2 q0

3 4
………. # x x y b # # ………... ………. # x x y b # # ………...

q1 q1
q2 xayb |-- x q0 ayb |-- xx q1 yb |-- xxy q1 b
Leila Ben Ayed Théorie des Langages et Compilation 187
Succession de Configurations
q2 xayb |-- x q0 ayb |-- xx q1 yb |-- xxy q1 b
*
Peut etre noté comme suit: q2 xayb |-- xxy q1 b

Configuration initiale : q0 w
Mot en entrée
w

# a a b b # #

q0
Leila Ben Ayed Théorie des Langages et Compilation 188
Succession de Configurations
Pour une machine de Turing M

Le langage L(M) accepté par M est défini comme suit :

L(M) = {w / q0 w |-- w*1 qf w2}

Etat initial Etat final

Leila Ben Ayed Théorie des Langages et Compilation 189


VI.3. Utilisation d’une machine de Turing

Une machine de Turing est utilisée pour :


- accepter
- calculer
Une machine qui accepte : Pour un mot donné en entrée, la machine répond par oui si
ce mot est accepté et par non dans le cas contraire.
Une machine accepte un mot w s'il existe au moins un calcul acceptant avec w comme
entrée, c'est-à-dire qui commence avec la configuration q0w. Un seul calcul acceptant
suffit pour que la machine accepte même si d'autres calculs bloquent ou n'atteignent
jamais une configuration acceptante.
Une machine qui calcule : Pour un mot donné en entrée, la machine retourne un ou
plusieurs mots de sortie. Quand la machine ne donne qu’un seul mot de sortie, elle
calcule une fonction qui associe le mot de sortie au mot d'entrée.
On met donc le mot d'entrée sur la bande, la machine effectue un calcul jusqu'à ce
qu'elle atteigne un état final et le contenu de la bande constitue alors un des mots de
sortie. Si la machine est déterministe alors il existe un seul mot de sortie.

Leila Ben Ayed Théorie des Langages et Compilation 190


Exemple de compteur de parité
Une procédure de reconnaissance par une machine de Turing peut être
spécifiée par une liste finie d’instructions.

Un calcul particulier est effectué par la liste d’instructions, l’état initial q0, le
contenu du ruban au départ et la position initiale de la tête de lecture/écriture
sur le ruban.

Exemple : Un compteur de parité des 1


Le ruban contient une séquence de 1 et 0 qui se termine par un délimiteur
droit #. L’état final est atteint et la case sur la quelle pointe la tête de L/E est 0
ou 1 selon que le nombre de 1 est pair ou impair
Les instructions sont les suivantes :
(q0, 0, q0, 0, 1) (q1, 0, q1, 0, 1)
(q0, 1, q1, 0, 1) (q1, 1, q0, 0, 1)
(q0, , qF, 0, -) (q1,  , qF, 1, -)
Leila Ben Ayed Théorie des Langages et Compilation 191
Exemple de compteur de parité
Illustration d’un calcul:
(q0, 0, q0, 0, 1) (q1, 0, q1, 0, 1)
(q0, 1, q1, 1, 1) (q1, 1, q0, 1, 1)
(q0, B, q2, 0, -) (q1, B, q2, 1, -) 0 0, 1
1  1,1 0 0, 1
q0 q1
1 0 1 1 0  Le nombre de 1 est
impair
1 1, 1
 0, -   1, -
1 0 1 1 0 #1

qF
(q0, 1, q1, 1, 1) (q0, 1, q1, 1, 1)
(q1, 0, q1, 0, 1) (q1, 0, q1, 0, 1)
(q1, 1, q0, 1, 1) (q1, , qF, 1 , -)
Leila Ben Ayed Théorie des Langages et Compilation 192
Exemple de compteur de parité
Illustration d’un calcul:
(q0, 0, q0, 0, 1) (q1, #, qF, 1, -)
(q0, 1, q1, 1, 1) (q1, 0, q1, 0, 1)
(q0,
(q0, #,
, qF,
qF, 0,
0, -)
-) (q1, 1,
(q1, 1, q0,
q0, 1,
1, 1)
1) 0  0, 1
(1,1,
1 1, 1)1 (0,0,
0 0, 1)1
q0
q0 q1
q1
1 0 1  Le nombre de 1 est
pair
(1,1,
1 1, 1)1
  0, -   1, -
1 0 1 0#

q2
qF

Leila Ben Ayed Théorie des Langages et Compilation 193


Exemple de compteur de parité
Si, en plus du calcul de la parité, on demande de remplacer les 1 par 0, nous
obtenons les instructions suivantes:
(q0, 0, q0, 0, 1) (q1, 0, q1, 0, 1)
(q0, 1, q1, 0, 1) (q1, 1, q0, 0, 1) 0  0, 1
(q0, , qF, 0, -) (q1, , qF, 1, -)
1  0, 1 0  0, 1
q0 q1
1 0 1 1 0  Le nombre de 1 est
impair
1 0, 1
0 0 1
1 0 10 0 1B # 0, - #  1, -

qF
(q0, 1, q1, 0, 1) (q0, 1, q1, 0, 1)
(q1, 0, q1, 0, 1) (q1, 0, q1, 0, 1)
(q1, 1, q0, 0, 1) (q1, , qF, 1, -)
Leila Ben Ayed Théorie des Langages et Compilation 194
Exercice

Exercice : Vérification des parenthèses


On dispose au départ d’une chaine qui contient des parenthèses. La chaine est
délimitée à droite et à gauche par le symbole #. A l’arrêt de la machine, le symbole
sous la tête de lecture/écriture est 0 si les parenthèses sont bien équilibrées et 1 dans
le cas contraire.
Donner les instructions pour une machine de Turing qui permet de répondre par 0 ou 1
si les parenthèses sont équilibrées ou non.

Leila Ben Ayed Théorie des Langages et Compilation 195


Exemple de vérification de parenthèses

Corrigé:
On démarre sur la première parenthèse. Le calcul consiste à aller chercher vers la
droite la première parenthèse fermante, l’effacer et revenir vers la gauche pour
chercher la première parenthèse ouvrante à partir de là, l’effacer puis recommencer la
recherche (fermante, ouvrante).
Nous avons besoin donc de deux états: un qui sert à se déplacer à droite (q0) pour
chercher une fermante et un qui sert à se déplacer à gauche (q1) pour chercher une
ouvrante.
Enfin, il se peut que l’on ne rencontre plus de parenthèses fermantes, auquel cas il
faut revenir au point de départ de la chaine en vérifiant qu’il n’ y a plus d’ouvrante non
plus. Un état q2 effectue cette vérification en reculant.
Nous utilisons le symbole x pour remplacer les parenthèses rencontrées pour ne pas
les reprendre une deuxième fois.

Leila Ben Ayed Théorie des Langages et Compilation 196


Exercice
X = {(, ), x, #}
Les instructions sont les suivantes :
(q0, ), q1, x, 0) (q2, (, qF, 1, -)
(q0, (, q0, (, 1) (q1, (, q0, x, 1) (q2, #, qF, 0, -)
(q0, #, q2, #, 0) (q1, #, qF, 1, -) (q2, x, q2, x, 0)
(q0, x, q0, x, 1) (q1, x, q1, x, 0) qF est l’état final
)  x, 0
( (, 1 q0 q1 x x, 0
x x, 1 (x, 1
# 1, -
# #, 0

(1, -
q2 #  0, - qF
x x, 0

Leila Ben Ayed Théorie des Langages et Compilation 197


Exercice
Une machine de Turing qui accepte {anbn, n 0}
X = {a, b, x, #}
Les instructions sont les suivantes :
(q0, a, q1, x, 1) (q1, a, q1, a, 1) (q2, x, q2, x, 0) (qv, x, qv, x, 1)
(q0, #, qF, #,-) (q1, b, q2, x, 0) (q2, a, q1, x, 1) (qv, #, qF, #, -)
(q1, x, q1, x, 1) (q2, #, qv, #, 1)
x x, 1
a  x, 1
Le mot aabb est accepté q0 q1 a a, 1
# #, -
1 0 1 1 0 
b x, 0
qF a x, 1

# #, -
qv q2 x x, 0
##, 1
xx, 1
Leila Ben Ayed Théorie des Langages et Compilation 198
Exercice
Le mot aba n’est pas accepté
# a a b b  # x x x b 
x x, 1
a  x, 1
q0 q1 a a, 1
q0 q1
# #, -
# x a b b  # x x x b  b x, 0
qF
q0 b 1, - a x, 1
q1 q1 b 1, -
# #, -
# x a b b  # x x x x  qv q2 x x, 0
##, 1
q1 q2
xx, 1
# x a x b  # x x x x 

q2 q2

Leila Ben Ayed Théorie des Langages et Compilation 199


Exercice
Le mot aabb est accepté
# x x x x  # x x x x 
x x, 1
a  x, 1
q0 q1 a a, 1
q2 qv
# #, -
# x x x x  # x x x x  b x, 0
qF a x, 1
q2 qv
# #, -
# x x x x  # x x x x  qv q2 x x, 0
##, 1
qv qF
xx, 1
# x x x x 

qv

Leila Ben Ayed Théorie des Langages et Compilation 200


Exercice
Le mot aba n’est pas accepté
# a b a #  # x x a # 
x x, 1
a  x, 1
q0 q1 a a, 1
q0 qv
# #, -
# x b a #  # x x a #  b x, 0
qF a x, 1
q1 qv
# #, -
# x x a #  # x x a #  qv q2 x x, 0
##, 1
q2 qv
# x x a #  Arrêt de la machine car (qv, a)
n’est pas définie. Le mot n’est
q2 pas lu donc le mot aba n’est pas
accepté
Leila Ben Ayed Théorie des Langages et Compilation 201
Exercice
Le mot aabb est accepté
# x x x x  # x x x x 
x x, 1
a  x, 1
q0 q1 a a, 1
q2 qv
# #, -
# x x x x  # x x x x  b x, 0
qF a x, 1
q2 qv
# #, -
# x x x x  # x x x x  qv q2 x x, 0
##, 1
qv qF
xx, 1
# x x x x 

qv

Leila Ben Ayed Théorie des Langages et Compilation 202


Exercice
Une machine de Turing qui accepte {anbncn, n 0}
X = {a, b, x, #}
Les instructions sont les suivantes :
(q0, a, q1, x,1) (q1, a, q1, a, 1) (q2, c, q3, x, 0) (q3, b, q3, b, 0)
(q0, #, qF, #,-) (q1, b, q2, x, 1) (q2, x, q2, x, 1) (q3, a, q1, x, 1)
(q1, x, q1, x, 1) (q2, b, q2, b, 1) (q3, #, qv, #, 1)
(q3, x, q3, x, 0)
(qv, x, qv, x, 1)
x x, 1
(qv, #, qF, #, -) a  x, 1
q0 q1 a a, 1
# #, -
b x, 1
qF a x, 1
c x, 0 q2 x x, 1
# #, - b b, 1
qv q3
##, 1
c x, 0
xx, 1 a x, 1
x x, 0
Leila Ben Ayed Théorie des Langages et Compilation 203
VI.4. Variantes de MT
Machines de Turing avec :
• Option d’arrêt, Bande semi-infinie, Off-Line
• Multibande, Multidimension, Non déterministe

Les différentes variantes forment différentes classes de machines


de Turing
Pour chaque machine M1 de la première classe,
Il existe une machine M2 de la deuxième classe tel que
L(M1) = L(M2)

Leila Ben Ayed Théorie des Langages et Compilation 204


Machine de Turing à bande Semi-infinie
Machine standard

......... .........

Machine à bande semi infinie


.........

Machine de Turing Standart simule la machine de Turing à bande


semi-infinie
Leila Ben Ayed Théorie des Langages et Compilation 205
Machine de Turing à bande Semi-infinie
Machine standard
......... # a b c d e # # .........

Point de référence
Machine de Turing à bande semi-infinie

Partie droite ## d e # # # .........


Partie gauche ## c b a  # #

Leila Ben Ayed Théorie des Langages et Compilation 206


Machine de Turing déterministe
Une machine de Turing déterministe est une machine qui fait un seul calcul
à chaque exécution. Pour un état donné et un symbole donné, l'action effectuée par la
machine est unique.
Une machine de Turing non-déterministe est une machine de Turing où à
chaque étape de son calcul, elle peut effectuer un choix non-déterministe: elle a le
choix entre plusieurs actions, et elle en effectue une.
Si l'un des choix l'amène à accepter l'entrée alors on dit que la machine accepte
l'entrée.
Un mot  = a1a2…an  X* est accepté par une machine non déterministe
S’il existe au moins un calcul :

a1, b1, d1 a 2, b 2, d 2 a n, bn, dn


q0 q1 q2 ….. q n-1 qn

q0 a1a2…an|-- a1 q1 a2…an |--…….|-- a1a2…an-1 qn-1 an |-- a1…an qn

Leila Ben Ayed Théorie des Langages et Compilation 207


VI.5. Relation avec les calculateurs
et fonction T-calculable

Une machine de turing est un modèle pour un ordinateur avec un temps de


calcul très grand et un bon espace de calcul. Il est possible de simuler un
ordinateur sur une machine de turing.

Fonction T- calculable
Une fonction f(x) est dite Turing calculable (T-calculable) si ses valeurs peuvent
être calculées par une machine de turing dont le ruban contient une
représentation standard de l’argument x. Quand la machine (le calculateur)
s’arrête, la valeur de f(x) apparaît dans une représentation sur le ruban. Une
représentation standard possible est une représentation en Base 1 (symbole
utilisé est 1).

Leila Ben Ayed Théorie des Langages et Compilation 208


Exercice
Exercice : Montrer que la fonction ADD(m, n) est T-Calculable pour les entiers
m et n.
Corrigé: Le B est un séparateur
La réponse est la suivante:
B 1 1 B 1 1 B

m n

B 1 1 B

m+n

Leila Ben Ayed Théorie des Langages et Compilation 209


VI.5. Relation avec les calculateurs

La fonction ADD(m, n) = m+n est calculable

Machine de Turing :

Chaîne en entrée : BmBnB

Chaîne en sortie : Bm+nB

Leila Ben Ayed Théorie des Langages et Compilation 210


VI.5. Relation avec les calculateurs
(1, 1, 1)
(1, 1, 1)
(B, B, 1) (B, B, 1)

On avance jusqu’au 2ème


(B, B, 0)
délimiteur droit B, le
décaler d’une case vers
(1, 1, 0) la gauche et ensuite
(1, B, 0) remplacer le premier
délimiteur B rencontré
(B, B, 0) par 1.
(B, 1, 0)

(1, 1, 0)
(B, B, -)

Leila Ben Ayed Théorie des Langages et Compilation 211


VI.5. Relation avec les calculateurs
Exercice: Montrer que la fonction Mul(m, n) = m x n est T-calculable et donner
l’algorithme de calcul associé
Corrigé:
On utilise une machine de turing à trois rubans
3 B B B

m*n Tant qu’il y a 1 dans le


ruban1, on copie le contenu
du ruban2 dans le ruban3
B 1 1 B
2
m

B 1 1 B
1
n
Leila Ben Ayed Théorie des Langages et Compilation 212
VI.5. Relation avec les calculateurs
Nous utilisons P1, P2 et P3 pour désigner les têtes de L/E respectivement sur
les rubans 1, 2 et 3.

Tant que P1 pointe sur 1 faire


Tant que P2 pointe sur 1 faire
écrire à la position P3 un 1
avancer P2
avancer P3
Fin tant que
Reculer P2
tant que P2 pointe sur 1 Faire
Reculer P2
Fin Tant que
Avancer P2
Avancer P1
Fin Tant que
Leila Ben Ayed Théorie des Langages et Compilation 213
VI.5. Relation avec les calculateurs
et fonction T-calculable
Une fonction f, définie sur D, est calculable si il existe une
machine de Turing T tel que à partir d’une configuration initiale
avec une entrée W, on peut atteindre une configuration où f (W),
en sortie, est calculée.

Configuration initiale Configuration finale


# W # # f #
(W)
q0 Etat initial qf Etat final
WD
Leila Ben Ayed Théorie des Langages et Compilation 214
VI.5. Relation avec les calculateurs
et fonction T-calculable

1 si x>y Entrée : x0y


f(x, y) = 0 sinon Sortie : 1 ou 0

Pseudo code pour une MT


Repeter
égaler un 1 de x avec un 1 de y
Jusqu’à tous les x ou y sont égalées
Si un 1 de x n’est pas égalé
Alors effacer la bande, ecrire 1
Sinon effacer la bande, ecrire 0

Leila Ben Ayed Théorie des Langages et Compilation 215


La thèse de Church

Thèse de Church
Si il existe un algorithme qui calcule f(x)
Alors il existe une machine de Turing qui
exécute l’algorithme qui calcule f(x)

Leila Ben Ayed Théorie des Langages et Compilation 216


VI.6. Machine de Turing et Langages
L’ensemble L de tous les mots sur {a, b}:

L = {a,b}* = {, a, b, ab, aa, ba, bb, aaa, aab, …}


Infini et dénombrable
L’ensemble des parties de L :

P(L) = {{}, {a}, {a,b}, {aa, ab, aab}, …}


L1 L2 L3 L4 
Non dénombrable
Leila Ben Ayed Théorie des Langages et Compilation 217
VI.6. Machine de Turing et Langages
Langages: non dénombrable
L1 L2 L3  Lk 

M1 M2 M3 ?
Machines de Turing : dénombrable

Il existe plus de langages que les machines


de Turing

Leila Ben Ayed Théorie des Langages et Compilation 218


VI.6. Machine de Turing et Langages

Il exite plusieurs langages non acceptés


Par des Machines de Turing
Ce sont
(Les langages qui ne peuvent pas être
décrits par des algorithmes)

Les langages récursifs : Un langage est récursif s’il existe une


machine engendrant L dans l’ordre des mots de longueur
croissante.
Les langages récursivement énumérables : Un langage L est
récursivement énumérable s’il existe une MdT M engendrant L.

Leila Ben Ayed Théorie des Langages et Compilation 219


VI.7. Combinaison de Machines de Turing

On peut combiner des machines simples (de base – sous


programmes) pour obtenir une machine composée
Machines de base
Machine d’écriture de symbole
Ecriture d’un symbole correspondant
sans déplacer la tête et indépendant
du contenu de la bande
Machine de déplacement de la tête
Une machine pour déplacer la tête de
la bande à droite ou à gauche

Leila Ben Ayed Théorie des Langages et Compilation 220


VI.7. Combinaison de Machines de Turing

Machines de base (Abréviation)

R# : qui trouve le premier blanc a droite

L # : qui trouve le premier blanc à gauche

R # : qui trouve le premier non blanc à droite

L # : qui trouve le premier non blanc à gauche

NB. Le symbole “#” représente un blanc et le symbole “”


représente un symbole quelconque du ruban
Leila Ben Ayed Théorie des Langages et Compilation 221
VI.7. Combinaison de Machines de Turing

Machines de base (Construction graphique)

R # R  #
R#

L # L  #
L#
Leila Ben Ayed Théorie des Langages et Compilation 222
Exemple
Une machine qui scanne la bande jusqu’à ce qu’elle trouve un
non blanc. Elle revient a gauche et copie le symbole qu’elle
trouve dans la case juste avant. La
X={a,b,c,#}
a Lb
 # L b
R
R c Lc
#
L : action reculer suivie de #
remplacer symbole courant par   représente a,b ou c
Leila Ben Ayed Théorie des Langages et Compilation 223
Exemple: Copie d’un mot
#w# résultat #w#w#

Un algorithme possible:
Chercher le premier blanc a gauche
T: avancer à droite d’une case
Si la case contient   # alors
ecrire #
chercher le deuxieme # à D de la Tête
ecrire 
chercher le deuxieme # à G de la tête
ecrire  (le remettre)
aller à T
Sinon
avancer à droite jusqu’au premier #

Leila Ben Ayed Théorie des Langages et Compilation 224


Exemple : Copie d’un mot
#w# résultat #w#w#

La machine C correspondante est la suivante:

L# #
R #R2# L2# 

#
C
R#
Leila Ben Ayed Théorie des Langages et Compilation 225
Exemple : Copie d’un mot
#w# résultat #w#w#

Exemple d’exécution :

#abc# > #abc > #abc > ##bc > ##bc## >
##bc#a > ##bc#a > #abc#a >#a#c#a >
#a#c#a# > #a#c#ab….
#ab##ab …>
#abc#abc …>
#abc#abc#

Leila Ben Ayed Théorie des Langages et Compilation 226


Exemple : Copie d’un mot - C
#w# q0 résultat #w#w# h

Exemple d’exécution :

#abc# > #abc > #abc > ##bc > ##bc## >
##bc#a > ##bc#a > #abc#a >#a#c#a >
#a#c#a# > #a#c#ab….
#ab##ab …>
#abc#abc …>
#abc#abc#

Leila Ben Ayed Théorie des Langages et Compilation 227


Exemple : Décalage à gauche (Shift Left) - SL
#w# q0 résultat w# h

w ne contient pas de blanc

SL
L# #
R L R

L#
Application : F(w)=ww la machine est CSL(copie suivi de Shift Left)
Leila Ben Ayed Théorie des Langages et Compilation 228
Exemple : Décalage à droite (Shift Right) - SR
#w# q0 résultat w# h

w ne contient pas de blanc

SR
L# #
R L R

L#
Application : F(w)=ww la machine est CSL(copie suivi de Shift Left)
Leila Ben Ayed Théorie des Langages et Compilation 229
Exercice
L = {w  Xo : |w|a = |w|b = |w|c}

X={a,b,c,#}

L = {w  Xo : |w|a = |w|b = |w|c}


Donner la machine de Turing qui accepte L

Leila Ben Ayed Théorie des Langages et Compilation 230


VII. Décidabilité
Plan

VII.1. Problèmes décidables


VII.2. Définitions
VII.3. Décidabilité et Calculabilité
VII.4. Exemples

Leila Ben Ayed Théorie des Langages et Compilation 231


VII. Décidabilité

Décidabilité
Intuitivement, P est décidable s’il existe un algorithme qui
pour chaque x répond par “OUI” ou par “NON” à la
question :

“Est-ce que P(x) est vrai ?”.

Leila Ben Ayed Théorie des Langages et Compilation 232


VII.1. Problème Décidable

PROBLÈMES DE DÉCISION
Définition : c’est un problème pour lequel il existe, en un temps fini, deux
réponses possibles oui ou non

Problèmes décidables : Un problème P est décidable s’il existe une Machine


de Turing Reconnaisseur qui, pour une donnée quelconque de P, s’arrête
toujours soit dans un état reconnaisseur (arret + symbole correspondant à la
réponse) qui signifie si la réponse à P pour cette instance est oui, soit dans
un état de rejet (arret + symbole de rejet) si la réponse est non.

Leila Ben Ayed Théorie des Langages et Compilation 233


VII.1. Problème Décidable

Problèmes semi-décidables : Un problème P est semi-décidable s’il existe


un Machine de Turing Reconnaisseur qui, pour une donnée quelconque de P,
lorsque la réponse est oui s’arrête dans un état accepteur, et lorsque la
réponse est non peut soit s’arrêter dans l’état de rejet comme elle peut ne
pas s’arrêter.

Les langages récursivement énumérables : Un langage L est récursivement


énumérable ssi il est semi-décidable.

Leila Ben Ayed Théorie des Langages et Compilation 234


VII.1. Problème Décidable

• Un problème P est décidable si :


il existe A tel que A résout P
(A est un algorithme)
• Problème de décision est formulé comme suit :
Etant donnés :
- un ensemble U de toutes les données possibles (un univers)
- un ensemble B de toutes les données pour lesquelles P est résolu (B ⊆ U),
pour chaque élément x ∈ U, répondre
- par “OUI” si x ∈ B et
- par “NON” si x  B

Leila Ben Ayed Théorie des Langages et Compilation 235


Exemple de problème P
• Exemple . Est-ce qu’une formule F du premier ordre donnée telle
que par exemple
∀x(H(x) → ∃yH(y))
est valide ?
• Il n’existe pas d’algorithme qui donne la bonne réponse pour une
formule du premier ordre quelconque
• Skolémiser la négation de la formule, la mettre en forme clausale
et appliquer la résolution peut ne pas terminer.
– U = { toutes les formules de la logique des prédicats }
– B = { toutes les formules valides }.
• Le problème de la validité s’écrit comme :
– “F ∈ B ?”, ou comme “B(F) ?”

Leila Ben Ayed Théorie des Langages et Compilation 236


VII.2. Décidabilité - Définitions

Pour un problème P = (U,B) donné:

Le problème P est décidable



Il existe un algorithme pour P (une procédure qui s’arrete et
répond “OUI” si l’entée x ∈ B et répond “NON” si
l’entrée x  B)

Leila Ben Ayed Théorie des Langages et Compilation 237


VII.2. Décidabilité - Définitions
Le problème P est indécidable

Il n’existe pas d’algorithme pour P.

Le problème P est semi-décidable



Il existe un semi-algorithme pour P (une procédure telle
que :
- si l’entrée x ∈ B elle répond “OUI” ;
- si l’entrée x  B dit “NON” ou
- ne donne pas de réponse.
Leila Ben Ayed Théorie des Langages et Compilation 238
VII.3. Décidabilité et Calculabilité

Le problème de décision (U,B) est le suivant :


pour x ∈ U décider si x ∈ B
Afin de décider si une entrée x ∈ B, nous allons
utiliser la fonction caractéristique de l’ensemble B
CB(x) : U → {0,1}
CB(x) = 1 si x ∈ B,
0 sinon.

Le problème (U,B) est décidable si et seulement si


CB est calculable.
Leila Ben Ayed Théorie des Langages et Compilation 239
Exemples de Problèmes Décidables ou
indécidables
• P : un mot est reconnu par un automate fini non
déterministe ?
On peut construire un algorithme pour décider si en
partant de l’état initial, il existe une séquence de
configurations qui permet d’atteindre un état final où le
mot est entièrement lu; si il n’existe aucune séquence de
configurations qui nous amène à la reconnaissance alors
le mot n’est pas accepté. le problème P est décidable

Leila Ben Ayed Théorie des Langages et Compilation 240


Exemples de Problèmes Décidables ou
indécidables
• P : un entier naturel est pair?
On peut construire un algorithme pour décider si un entier
naturel est pair ou non on fait la division par deux, si le
reste est zéro, le nombre est pair, si le reste est un, il ne
l'est pas), donc l'ensemble des entiers naturels pairs est
décidable
• P : un mot est reconnu par un automate fini déterministe ?
On peut construire un algorithme pour décider si en
partant de l’état initial, on peut atteindre un état final où le
mot est entièrement lu, le problème P est décidable

Leila Ben Ayed Théorie des Langages et Compilation 241


Exemples de Problèmes Décidables ou
indécidables
• P : un mot est reconnu par un automate fini non
déterministe ?
On peut construire un algorithme pour décider si en
partant de l’état initial, on peut atteindre un état final où
le mot est entièrement lu.
Si il existe une séquence de transitions (chemin) qui nous
mène à l’état final après la lecture du mot alors le mot est
accepté sinon, si aucun chemin ne mène à l’acceptation,
alors le mot est rejeté.

La suite est dans le cours de Complexité en II2.

Leila Ben Ayed Théorie des Langages et Compilation 242


Additif C associé à TLC
Techniques de compilation
Leila Jemni Ben Ayed

Ecole Nationale des Sciences de l’Informatique


L’objectif de ce cours est d’étendre les connaissances en théorie des
langages et des automates à la description des langages de
programmation et leur analyse syntaxique en vue de leur compilation. Ce
cours décrit les concepts fondamentaux des langages de programmation
en commençant, dans une première partie, par donner la syntaxe et la
sémantique, en insistant davantage sur la syntaxe. La traduction en code
intermédiaire et l’environnement d’exécution font l’objet de la deuxième
partie.
Additif C associé à TLC
Techniques de compilation
I. Introduction à la compilation
II. Compilateur en une seule passe
III. Analyse syntaxique
IV. Analyse sémantique
V. Traduction en code pour
machine abstraite à pile
I. Introduction à la Compilation
Plan

I.1. Compilateurs
I.2. Les Grammaires non contextuelles
I.3. Phases de Compilation
I.4. Qualité d’un Compilateur
I.5. Outils pour la construction de Compilateurs

Leila Ben Ayed Théorie des Langages et Compilation 245


I.1. Compilateurs
– Évolution des langages:
• Langage machine
• Langage assembleur
• Langages évolués : C, PASCAL, ADA (Algorithmiques)
PROLOG (Logiques)
• Langages de 4ème génération
– Un compilateur est un programme qui lit un
programme écrit dans un premier langage(langage
source) et le traduit en un programme équivalent
écrit dans un autre langage (le langage cible).
Leila Ben Ayed Théorie des Langages et Compilation 246
I.1. Compilateurs
– Au cours de ce processus de traduction, un rôle du
compilateur est de signaler à son utilisateur la
présence d’erreurs dans le programme source.

PSource Compilateur PAssembleur

Messages
d’erreur

Leila Ben Ayed Théorie des Langages et Compilation 247


I.2. Exemples de grammaires non
contextuelles
1) Une grammaire qui génère l’ensemble des expressions arithmétiques utilisant les opérateurs + et * et les chiffres
{0,1,...9}

R = { Exp  Exp + Exp G = ({Exp}, {+, *, (, ), 0, 1, …9}, Exp, R}


Exp  Exp * Exp
Exp  (Exp)
Exp  0
Exp  1
Exp  2
Exp  3
Exp  4
Exp  5
Exp  6
Exp  7
Exp  8
Exp  9 }

Leila Ben Ayed Théorie des Langages et Compilation 248


I.2. Exemples de grammaires non
contextuelles
2) Une grammaire qui génère l’ensemble des expressions booléennes utilisant les opérateurs
arithmétiques (oparith), les opérateurs relationnels (oprel) et les opérateurs booléens (non, et et ou)
sur les identificateurs (id) et les nombres entiers (nb)

R = { Expb  Expr
Expb  non(Expb) G = (V, T, Expb, R)
Expb  Expb et Expb V = {Expb, Expr, Expa}
Expb  Expb ou Expb T = {id, nb, oprel, oparith, non, et, ou, (, )}
Expr  Expa oprel Expa où oprel  {<, >, <=, >=, <>, =}
Expr  (Expr)oparith  {+, *, /, -}
Expa  Expa oparith Expa
Expa  (Expa)
Expa  id
Expa  nb
}

Leila Ben Ayed Théorie des Langages et Compilation 249


I.2. Exemples de grammaires non
contextuelles
3) Une grammaire qui génère une séquence non vide de déclarations suivie de Début, suivie d’une séquence non
vide d’instructions suivie de Fin . Chaque instruction peut être une instruction d’affectation (se termine par ;) ou
une instruction conditionnelle avec ou sans sinon (qui se termine par FinSi). Les types utilisés sont entier et réel.
La séquence générée commence par program suivi d’un nom.

R = { P  Program id S_DCL Début S_INST Fin G = (V, T, P, R)


S_DCL  DCL | DCL S_DCL V = {P, S_DCL, DCL, S_INST, INST, Expb, Expr, Expa}
DCL  Var L_id : TYPE; T = {Program, Début, Fin, Var, :, id, :=, ;, Si, Sinon, Fin Si, (, ),
L_id  id | id, L_id oparith, oprel, non, et, ou, entier, réel, nb}
TYPE  entier | réel
S_INST  INST | INST S_INST
INST  id := Expa;
INST  Si Expb alors S_INST Fin Si
INST  Si Expb alors S_INST Sinon S_INST Fin Si
Expb  Expr | non(Expb) | Expb et Expb | Expb ou Expb
Expr  Expa oprel Expa
Expr  (Expr)
Expa  Exp oparith Exp
Expa  (Expa)
Expa  id
Expa  nb
}

Leila Ben Ayed Théorie des Langages et Compilation 250


I.2. Exemples de grammaires non
contextuelles
Vérifier que la grammaire précédente génère le
programme suivant :

Program test
Var a, b : entier;
Début
a:= 10;
Si a>= 10 alors a:= 20; Fin Si
Fin

Leila Ben Ayed Théorie des Langages et Compilation 251


I.2. Exemples de grammaires non
contextuelles
Le programme est transformé en une séquence de
terminaux.

Program id
Var id, id : entier;
Début
id:= nb;
Si id oprel nb alors id:= nb; Fin Si
Fin

Leila Ben Ayed Théorie des Langages et Compilation 252


I.2. Exemples de grammaires non
contextuelles
P

Program id S_DCL Début S_INST Fin

Var L_id : TYPE ; INST S_INST

id , L_id entier id := Expa ; INST


En parcourant les feuilles
id nb Si Expb alors S_INST Fin Si
de l’arbre de gauche à
droite, on trouve le Expr INST
programme à analyser
Donc ce programme est Expa oprel Expa id := Expa ;
syntaxiquement correct
Leila Ben Ayed Théorie des Langages et Compilation id nb nb 253
I.3. Phases de Compilation
On distingue deux parties:
– Analyse
• Partitionne le programme source en ses constituants et en
crée une représentation intermédiaire.
– Synthèse
• Construit le programme cible à partir de la représentation
intermédiaire.
• L’analyse utilise les constituants d’une
grammaire non contextuelle qui génère des
programmes du langage utilisé.
Leila Ben Ayed Théorie des Langages et Compilation 254
I.3. Phases de compilation
PSource

Analyse lexicale

Gestion de la Analyse Syntaxique


table de
symboles Analyse sémantique
Gestion des
erreurs
Génération de code
intermédiaire

Table des Optimisation de code


identificateurs,
mots réservés Génération de code
et constantes machine

PCible
Leila Ben Ayed Théorie des Langages et Compilation 255
I.3. Phases de compilation
Psource Analyse
Les compilateurs
comportent ces deux
parties.
Génération de
Partie frontale code
Si on change de intermédiaire
machine, on peut ne
modifier que la partie
terminale
PLI
Partie terminale Générateur de code
machine

PASS

Leila Ben Ayed Théorie des Langages et Compilation 256


I.3. Phases de compilation
Type d’un id
Interface avec l’analyseur lexical Valeur d’un nb
Opérateur PPQ pour oprel
Passer unité
Lire caractère
lexicale et ses
Entrée Analyseur attributs Analyseur
lexical syntaxique
Rendre
caractère

• Pour l’AS, l’AL retourne l’UL


• Pour l’Asem, il retourne le type, la portée, …
• Pour le traducteur, il retourne la valeur du nombre, l’opérateur utilisé, …
• Si C est une variable caractère et le prog source est dans l’entrée standard alors
l’instruction C = getchar(); affecte le prochain caractère d’entrée à C et l’instruction
ungetc(C, stdin); rend à l’entrée standard stdin la valeur de C.
Leila Ben Ayed Théorie des Langages et Compilation 257
I.3. Phases de compilation
Implantation des interactions avec l’analyseur lexical
Retourne une
Utilise getchar();
unité lexicale
pour lire un
caractère AnalLex() à l’appelant
analyseur
Rendre caractère lexical Positionne la
En utilisant ungetc(C, stdin) variable globale à la
ValLex valeur de l’unité
lexicale

Leila Ben Ayed Théorie des Langages et Compilation 258


I.3. Phases de compilation
Analyse du programme source :
A chaque langage de programmation est associée une
grammaire non contextuelle.
L’analyse comprend quatre phases :
– Phase1: analyse linéaire (ou lexicale) au cours de laquelle
le flot de caractères formant le programme source est lu
de gauche à droite et groupé en unités lexicales qui sont
une suite de caractères ayant une signification collective.
Ces unités lexicales sont les terminaux de la grammaire.

Leila Ben Ayed Théorie des Langages et Compilation 259


I.3. Phases de compilation
– L’Al retourne une UL pour l’AS
– Pour l’Asem, si l’UL est id alors il retourne une entrée dans
la table des identificateurs pour l’identificateur trouvé.
– Pour le traducteur, si l’UL est nb, alors il retourne sa valeur
• si l’UL est oprel alors il retourne l’opérateur en question
• Si l’UL est oparith alors il retourne l’opérateur en
question
– Quand l’analyseur lexical rencontre un identificateur non
mot clé, il le cherche dans la table des id. S’il existe alors il
retourné l’entrée associée sinon il lui crêt une entrée et
retourne le numéro d’entrée.

Leila Ben Ayed Théorie des Langages et Compilation 260


I.3. Phases de compilation
par exemple si on dispose de la grammaire avec les règles
suivantes:
P  id opaff Exp
Exp  id | nb | (Exp) | Exp oparith Exp
Les unités lexicales associées au mot :
position := initiale + vitesse * 60
Sont:
1) l’identificateur position 2) Le symbole d’affectation opaff
3) L’identificateur initiale 4) Le signe d’addition oparith
5) L’identificateur vitesse
6) Le signe de multiplication oparith 7) Le nombre nb

Leila Ben Ayed Théorie des Langages et Compilation 261


I.3. Phases de compilation
Le lexème est la suite de caractères du fichier source qui forme l’unité
lexicale. Le tableau suivant présente les lexèmes et les unités lexicales
associées au mot position := initiale + vitesse * 60
lexème Unité lexicale
Résultat position Id
de l’AL
:= Opaff
initiale Id
+ Oparith
vitesse Id
* Oparith
60 nb

id opaff id oparith id oparith nb Pour l’AS


1 := 2 + 3 * 60
Leila Ben Ayed Théorie des Langages et Compilation 262
I.3. Phases de compilation
par exemple si on dispose de la grammaire avec les règles
suivantes:
DCL  Var L_ID : TYPE;
| Var L_ID : TYPE; DCL
|
L_ID  id | id, L_ID
TYPE  entier | réel
Les unité lexicales associées au mot (retournées par l’AL à l’AS):
Var a, b: entier; var c: réel;
Sont les suivantes :
Var id , id : entier ; Var id : réel ;

Leila Ben Ayed Théorie des Langages et Compilation 263


I.3. Phases de compilation
par exemple si on dispose de la grammaire avec les règles
suivantes: Table des id de variables
DCL  Var L_ID : TYPE; N° Lexème Type
| Var L_ID : TYPE; DCL 1 a entier
| 2 b entier
L_ID  id | id, L_ID 3 c réel
TYPE  entier | réel
Si l’AL retourne un résultat à l’AS et l’Asem alors le résultat de
l’AL pour le mot Var a, b: entier; var c: réel; sera :
Var Id , Id : entier ; Var Id : réel ;
0 1 0 2 0 0 0 0 3 0 0 0

Leila Ben Ayed Théorie des Langages et Compilation 264


I.3. Phases de compilation
Soit le mot a := c + 34; l’AL retourne Résultat de l’AL
Pour l’AS : id := id oparith nb; Id := Id oparith nb ;
Pour l’Asem : 1 := 3 oparith nb; 1 0 3 + 34 0

c-a-d entier := réel oparith entier


Pour le traducteur : @a := @c + 34;
Table des id de variables
N° Lexème Type Adresse
1 a entier @a
2 b entier @b
3 c réel @c

Leila Ben Ayed Théorie des Langages et Compilation 265


I.3. Phases de compilation
par exemple si on dispose de la grammaire avec les règles
suivantes: Table des id de variables
P  DCL L_I N° Lexème Type
DCL  Var L_ID : TYPE; 1 a entier
| Var L_ID : TYPE; DCL 2 b entier
| 3 c réel
L_ID  id | id, L_ID
TYPE  entier | réel
L_I  id := nb; | id := id; | id := nb; L_I | id := id; L_I
Si l’AL retourne un résultat à l’AS, l’Asem et le traducteur alors le résultat de
l’AL pour le mot Var a, b: entier; var c: réel; b := 10; sera :

Var Id , Id : entier ; Var Id : réel ; id := nb ;


0 1 0 2 0 0 0 0 3 0 0 0 2 0 10 0
Leila Ben Ayed Théorie des Langages et Compilation 266
I.3. Phases de compilation
Var a, b: entier; var c: réel; b := 10;
Table des id de variables
N° Lexème Type
1 a entier
2 b entier
3 c réel

Var Id , Id : entier ; Var Id : réel ; id := nb ;


0 1 0 2 0 0 0 0 3 0 0 0 2 0 10 0

Leila Ben Ayed Théorie des Langages et Compilation 267


I.3. Phases de compilation
Analyse du programme source :
– Phase2: analyse hiérarchique (ou syntaxique) au cours de
laquelle les unités lexicales sont regroupées
hiérarchiquement en structure grammaticale.
L’analyse syntaxique consiste à vérifier que la suite d’unités
lexicales est générée par la grammaire du langage.
Ceci revient à construire un arbre d’analyse (ou syntaxique)
dont les feuilles concordent avec la suite d’unités lexicales
en les parcourant de gauche à droite.

Leila Ben Ayed Théorie des Langages et Compilation 268


I.3. Phases de compilation
Analyse du programme source :
– Phase3: analyse sémantique au cours de laquelle on opère
certain contrôle pour s’assurer que l’assemblage des
constituants du programme a un sens. Une des opérations
principales d’un Asem est le contrôle de type des
opérandes d’une opération, le contrôle de la portée des
identificateurs au moment de l’appel d’un sous
programme, ….
– Dans le contrôle de type, l’analyseur sémantique peut
insérer des opérations de conversion pour les expr d’entier
vers réel.

Leila Ben Ayed Théorie des Langages et Compilation 269


I.3. Phases de compilation
Analyse du programme source :
– Phase3: analyse sémantique
Nous distinguons deux types d’erreurs sémantiques:
• sémantique statique, contrôlée au moment de la compilation telle
que :
– Variable non déclarée
– l’incompatibilité de type,
– la portée d’une variable…
• Sémantique dynamique, contrôlée au moment de l’exécution telle
que :
– la division par zéro
– les boucles infinies
– le débordement mémoire

Leila Ben Ayed Théorie des Langages et Compilation 270


I.3. Phases de compilation
Analyse du programme source :
– Phase4: traduction en code intermédiaire au cours de
laquelle la séquence d’instructions du programme est
traduite en une séquence d’instructions dans un langage
intermédiaire. Par exemple : le langage pour machine à
pile, le langage C, …

Leila Ben Ayed Théorie des Langages et Compilation 271


I.3. Phases de compilation
Analyse du programme source :
– La table des symboles contient des informations sur les
différents symboles et les attributs associés. Par exemple
les mots clés (ou réservés) et les identificateurs de
variables en spécifiant l’unité lexicale id et leurs attributs:
type, adresse, etc…
– A chaque fois qu’une unité lexicale id est trouvée par l’AL,
le lexème associé est inséré dans la table des symboles s’il
n’a pas été déjà inséré et l’AL retourne id et un pointeur
vers une entrée de la table des symboles.

Leila Ben Ayed Théorie des Langages et Compilation 272


I.3. Phases de compilation
Exemple
On veut illustrer les phases de compilation sur l’exemple suivant :
Position := Initiale + Vitesse * 60;
La grammaire est la suivante :
P  id := Exp;
Exp  id | nb | (Exp) | Exp + Exp | Exp * Exp
Une Contrainte sémantique doit être vérifiée :
L’opérateur de multiplication doit être appliqué à deux
opérandes de même type (entier, entier) ou (réel, réel)
Pour notre exemple, Vitesse est un réel et 60 est un nombre
entier, il faut alors convertir 60 d’entier vers réel (60.0)

Leila Ben Ayed Théorie des Langages et Compilation 273


I.3. Phases de compilation
• Analyse lexicale
id1 := id2 + id3 * nb;
• Analyse syntaxique
P

id := Exp ;

Exp + Exp

id Exp * Exp

id nb
Leila Ben Ayed Théorie des Langages et Compilation 274
I.3. Phases de compilation
• Analyse sémantique
Comme vitesse est un réel, un compilateur peut convertir le nombre
entier nb en réel pour pouvoir utiliser l’opérateur de multiplication
Var position, Initiale,
P : réel;
Vitesse

Analyseur
id := Exp
Sémantique

Table des id de variables


Exp + Exp
N° Lexème Type
1 Position Réel
2 Initiale Réel id Exp * Exp
entier vers réel
3 Vitesse Réel
60 60.0
id
Leila Ben Ayed Théorie des Langages et Compilation 275
I.3. Phases de compilation
• Génération de code intermédiaire
Temp1 := Entier vers réel(60);
Temp2 := Temp1*id3;
Temp3 := id2 + Temp2;
id1 := Temp3;
• Optimisation de code Analyse syntaxique
Temp1 := id3*60.0;
id1 := id2 + Temp1;
• Génération de code intermédiaire (Machine VON NEUMAN)
Machin à registres
MOVF id3, R2
MULF #60.0, R2
MOVF id2, R1
ADDF R2, R1
MOVF R1, id1
Leila Ben Ayed Théorie des Langages et Compilation 276
I.4. Qualité d’un compilateur

–Fournir le maximum d’erreurs en


une seule compilation
–Rapidité

Leila Ben Ayed Théorie des Langages et Compilation 277


I.5. Outils pour la construction de
compilateurs
– Assembleur
– Ecriture en langage évolué
– Constructeurs automatiques de compilateurs : LEX et YACC
Générateur automatique
d’analyseur syntaxique
Grammaire non
Analyseur Syntaxique
contextuelle du Yacc Écrit en C ou en LPascal
langage
Générateur automatique
d’analyseur lexical
Description
des unités Lex Analyseur lexical
lexicales du Écrit en C ou en LPascal
langage

Leila Ben Ayed Théorie des Langages et Compilation 278


II. Analyse lexicale
Plan

II.1. Présentation générale


II.2. Automates finis et expressions régulières
II.3. Spécification des unités lexicales
II.4. Reconnaissance des unités lexicales
II.5. Conception d’un générateur d’un analyseur
lexical
Leila Ben Ayed Théorie des Langages et Compilation 279
II.1. Présentation générale
• L’analyseur lexical constitue la première phase d’un compilateur. Sa tâche
principale est de lire les caractères d’entrée et de produire comme
résultat une suite d’unités lexicales que l’analyseur syntaxique va utiliser.

Passer unité
lexicale et ses
attributs
Lire caractère
Programme Analyseur Analyseur
Source
lexical Obtenir syntaxique
Rendre prochaine
caractère unité lexicale

Table des
symboles
Leila Ben Ayed Théorie des Langages et Compilation 280
II.1. Présentation générale
• Rq. L’AL est un sous programme de l’AS. A la réception de
« prochaine unité », l’AL lit les caractères d’entrée jusqu’à ce qu’il puisse identifier la
prochaine unité lexicale.
Unité lexicale : produite la même pour un ensemble de chaines de caractères
Modèle d’une unité lexicale : règle qui décrit une unité lexicale (Expression régulière)
Lexème : une suite de caractères du PS qui concorde avec le modèle d’une unité lexicale.
Unité Lexicale Lexèmes Description formelle des
modèles
const const const
if if If
oprel < <= = <> > >= (<+<=+=+<>+>+>=)
id Pi compte D2 lettre(lettre+chiffre)*
nb 3 6.780 6.0 Chiffre+ + chiffre+.chiffre+

Leila Ben Ayed Théorie des Langages et Compilation 281


II.2. Automates finis et expressions
régulières
• Un analyseur lexical est basé sur les systèmes de transition (ou bien les
automates finis)

Un diagramme de transition pour la reconnaissance de >=

Début > =
0 1 2 return(oprel, PGE)

autre

3 *
return(oprel, PGQ)

Leila Ben Ayed Théorie des Langages et Compilation 282


II.2. Automates finis et expressions
régulières

Un diagramme de transition pour la reconnaissance de >=


Début > =
0 1 2 return(oprel, PGE)

autre

3 *
return(oprel, PGQ)
Ce diagramme fonctionne comme suit:
Son état de départ est l’état 0. Dans l’état 0, on lit le prochain caractère de l’entrée. On suit l’arc
> depuis l’état 0 vers l’état 1 si le caractère d’entrée est >. Sinon, on n’a réussi à reconnaître ni >
ni >=. En atteignant l’état 1, on lit le prochain caractère d’entrée. L’arc étiqueté = entre l’état 1
et l’état 2 doit être suivi si le caractère d’entrée est = et le diagramme reconnaît >= (PGE).
Autrement, l’arc étiqueté autre conduit à l’état 3. Le diagramme reconnaît ainsi > (PGQ) et
recule d’un caractère dans l’entrée. On utilise une * pour signaler les états dans lesquels ce
recul dans l’entrée doit être fait.
Leila Ben Ayed Théorie des Langages et Compilation 283
II.2. Automates finis et expressions
régulières
Un diagramme de transition pour la reconnaissance
des opérateurs de relation
Début < = return(oprel, PPE)
0 1 2
>

autre 3 return(oprel, DIF)

= *
4 return(oprel, PPQ)
5 return(oprel, EGA)
>
return(oprel, PGE)
= 7
6
autre *
Leila Ben Ayed Théorie des Langages et Compilation 8 return(oprel, PGQ)
284
II.2. Automates finis et expressions
régulières
Un diagramme de transition pour la reconnaissance des
identificateurs et des mots clés

lettre, chiffre
*
Début lettre autre
0 1 2
return(UnilexId(), RangerId())

L’action spécifiée par le symbole * permet de reculer d’une position sur le fichier
source après la consommation d’un symbole autre qu’une lettre ou un chiffre.

Leila Ben Ayed Théorie des Langages et Compilation 285


II.2. Automates finis et expressions
régulières
Les fonctions RangerId() et UnilexId()
- La fonction RangerId() a accès au tampon où l’unité lexicale identificateur a été localisée. On
examine la table des symboles et si on trouve le lexème avec l’identificateur mot clé, RangerId()
rend 0. Si on trouve le lexème comme variable du programme, RangerId() rend un pointeur vers
une entrée dans la table des symboles. Si on ne trouve pas le lexème dans la table des symboles,
il y est placé en tant que variable et un pointeur vers cette nouvelle entrée est retourné.
- La fonction UnilexId() recherche le lexème dans la table des symboles. Si le lexème est un mot
clé, l’unité lexicale correspondante est retournée; autrement, l’unité lexicale id est retournée.

NB.
1) Le diagramme de transition ne change pas si on doit reconnaître de nouveaux mots clés; on
initiale simplement la table des symboles avec les nouvelles chaines et les nouvelles unités
lexicales.
2) En pratique, la table des symboles peut être répartie sur deux tables: table des mots clés et
table des identificateurs de variables.

Leila Ben Ayed Théorie des Langages et Compilation 286


II.3. Spécification des unités lexicales
Expressions régulières
Les expressions régulières sont une notation importante pour spécifier des
modèles d’unités lexicales.
Exemples:
Soit L l’ensemble {A, B, …, Z, a, b, …z} et C l’ensemble {0, 1, …9}
1. L+C ou(L  C) est l’ensemble des lettres et des chiffres
2. LC est l’ensemble des chaines formées d’une lettre suivie d’un chiffre
3. L4 est l’ensemble des chaines de quatre lettres
4. L* est l’ensemble de toutes les lettres, y compris , la chaine vide.
5. L(L+C)* est l’ensemble de toutes les chaines de lettres et de chiffres
commençant par une lettre.
6. C+ est l’ensemble de toutes les chaines d’au moins un chiffre
(représentations décimales des entiers naturels)
Leila Ben Ayed Théorie des Langages et Compilation 287
II.3. Spécification des unités lexicales
Définitions régulières
Soit  un alphabet de symboles de base, une définition régulière est une suite de
définitions de la forme :

d1  r1
d2  r2

d n  rn
Où chaque di est un nom distinct et chaque ri est une expression régulière sur les
symboles de  {d1, d2, …, di-1}

Exemples:
Lettre  A|B|…|Z|a|b|…|z
chiffre  0|1|…|9
id  Lettre(Lettre + Chiffre)*

Leila Ben Ayed Théorie des Langages et Compilation 288


II.4. Reconnaissance des unités lexicales
Nous utilisons les diagrammes de transition pour reconnaître des unités lexicales
Exemple:
Considérons le fragment de la grammaire suivant:
Instr  si expr alors instr
| si expr alors instr sinon instr
| id opaff id pv
| id opaff nb pv
expr  terme oprel terme
| terme
terme  id
| nb
Où si, alors, sinon, oprel, id et nb engendrent les ensembles de chaines données par les définitions
régulières suivantes:
si  si nb  chiffre+
alors  alors opaff  :=
sinon  sinon pv  ;
oprel  < | <= | = | <> | > | >=
id  lettre(lettre|chiffre)*

Leila Ben Ayed Théorie des Langages et Compilation 289


II.4. Reconnaissance des unités lexicales

Le mot en entrée dans le fichier source est le suivant :


N° lexème type
si a1 >= b alors a1 Mots clés
1 a1 …
si
:= 10; 2 b …
alors
3 … …

L’analyseur lexical retourne la séquence suivante d’unités


lexicales avec leurs attributs:
si id oprel id alors id opaff nb pv
0 1 PGE 2 0 1 := 10 ;

Leila Ben Ayed Théorie des Langages et Compilation 290


II.4. Reconnaissance des unités lexicales

Rq. On suppose que les lexèmes sont séparés par un espace


consistant d’une suite non vide de blancs, tabulations et fins
de lignes. Notre analyseur lexical doit éliminer ces espaces
en comparant une chaine avec la définition régulière
suivante :
Délim  blanc | tabulation | fin de ligne
bl  délim+
Si l’analyseur lexical trouve une correspondance avec bl, il ne
retourne pas l’unité lexicale à l’analyseur syntaxique. Il
continue pour rechercher l’unité lexicale qui suit le blanc et
le retourne à l’analyseur syntaxique.

Leila Ben Ayed Théorie des Langages et Compilation 291


II.4. Reconnaissance des unités lexicales
Système de transition associé à un analyseur lexical
l, c

autre *
bl, tab, \n 1 2
l return(UnilexId(), RangerId())
c
Début
c autre 4 *
0 3 return(nb, val)
6
< return(oprel, PPE)
=
Echec()
5 > 7
return(oprel, DIF)
= autre
autre EOF *return(oprel, PPQ)
8
9
> return(oprel, EGA)
return(oprel, PGE)
14 = 11
13
10
return(EOF, 0) autre *
12 return(oprel, PGQ)
Leila Ben Ayed Théorie des Langages et Compilation 292
II.4. Reconnaissance des unités lexicales
Système de transition associé à un analyseur lexical
l, c
Init(Val)
autre *
bl, tab, \n 1 2
l return(UnilexId(), RangerId())
cAdd(Val, c)
Début Add(Val, c)
c autre 4 *
0 3 return(nb, conv(val))
6
< return(oprel, PPE)
=
Erreur()
5 > 7
return(oprel, DIF)
= autre
autre EOF *return(oprel, PPQ)
8
9
> return(oprel, EGA)
return(oprel, PGE)
14 = 11
13
10
return(EOF, 0) autre *
12 return(oprel, PGQ)
Leila Ben Ayed Théorie des Langages et Compilation 293
II.4. Reconnaissance des unités lexicales
Code C d’un analyseur lexical
Unilex AnalLex() /* Unilex est une chaine si Alalex retourne uniquement l’unité lexicale*/
{ /* Unilex est un entier si Analex retourne l’unité lexicale et chaque unité est définie comme une
constante*/ case 1: car = carsuiv();
While(1) if(isletter(car) || isdigit(car))
/* Unilex est un enregistrement si Analex ajouter(car, chaine);;
else etat = 2;
retourne l’unité lexicale et un attribut*/
break;
{ case 2: Reculer(1); RangerId(); return(UniLexId()); /*
Switch(etat) cas où l’analyseur lexical retourne uniquement
{ */l’unité lexicale sinon, il faut utiliser un
case 0: Init(Chaine); car = carsuivant(); enregistrement (symbole)*/
if(car == ‘ ‘ || car == ‘\t’ || car = ‘\n’) ………….
{ etat = 0; debutlex ++; }
else if( car == ‘<‘) etat = 5; case 3: car = carsuiv();
else if (car == ‘=‘) etat = 9; if(isdigit(car)) ajouter(car, chaine);
else if (car == ‘>’) etat = 10;
else if (isletter(car)) Ajouter(car, chaine); else etat = 4;
etat = 1; break;
case 4 : Reculer(1); Return(NB); case 6: Return(Oprel);
else if(isdigit(car)) Ajouter(car, chaine);
……………
etat = 3; case 13: Return(EOF);
Leila Ben Ayed
else if(car == EOF) etat = 13;Théorie des Langages }et Compilation 294
else Erreur();
II.4. Reconnaissance des unités lexicales
Code C d’un analyseur lexical (cas du retour d’un enregistrement dans une
variable globale symbole à deux champs (UL, Att))

Unilex AnalLex() /* Unilex est une chaine si Alalex retourne uniquement l’unité lexicale*/
{ /* Unilex est un entier si Analex retourne l’unité lexicale et chaque unité est définie comme une
constante*/ case 1: car = carsuiv();
While(1) if(isletter(car) || isdigit(car))
/* Unilex est un enregistrement si Analex ajouter(car, chaine);;
retourne l’unité lexicale et un attribut*/ else etat = 2;
{ break;
case 2: Reculer(1); symbole.att = RangerId();
Switch(etat)
symbole.UL = UniLexId(); Return(Symbole);
{ ………….
case 0: Init(Chaine)car = carsuivant();
if(car == ‘ ‘ || car == ‘\t’ || car = ‘\n’) case 3: car = carsuiv();
{ etat = 0; debutlex ++; } if(isdigit(car)) ajouter(car, chaine);
else if( car == ‘<‘) etat = 5;
else etat = 4;
else if (car == ‘=‘) etat = 9;
break;
else if (car == ‘>’) etat = 10; case 4 : Reculer(1); symbole.UL=NB; symbole.Att =
else if (isletter(car)) etat = 1; toupper(chaine)); Return(symbole);
else if(isdigit(car)) etat = 3; case 6: symbole.UL = Oprel; symbole.att = PPE;
else if(car == EOF) etat = 13; Return(symbole); ……………
else Erreur(); case 13: symbole.UL = EOF; symbole.att = 0;
Return(symbole);}
Leila Ben Ayed Théorie des Langages On
et Compilation
peut retourner des numériques. 295
II.4. Reconnaissance des unités lexicales
Code C d’un analyseur lexical qui élimine les espaces et collecte les nombres

#include <stdio.h>
#include <ctype.h>
Int NumLigne = 1;
Int Vallex = RIEN;

Int AnalLex() While (isdigit(T))


{ {
int T;
While(1);
ValLex = ValLex*10+T-’0’;
{ T = getchar();
T = getchar(); }
if (T == ‘ ‘ || T == ‘\t’) ;
ungetc(T, stdin); return NB;
else
if (T == ‘\n’) }
NumLigne ++; Else
else ValLex = RIEN;
if(isdigit(T))
{
Return T;
Vallex = T-’0’;; }
T = getchar(); }

Leila Ben Ayed Théorie des Langages et Compilation 296


II. Compilateur en une seule passe
Plan

II.1. Présentation générale


II.2. Définition de la syntaxe
II.3. Traduction dirigée par la syntaxe
II.4. Un traducteur pour les expressions
II.5. Analyse lexicale

Leila Ben Ayed Théorie des Langages et Compilation 297


II.1. Présentation générale
Un compilateur en une seule passe est un compilateur qui fait le parcours
du fichier source une seule fois.
L’analyseur lexical fournit un résultat aussi bien à l’analyseur syntaxique,
sémantique qu’au traducteur en code intermédiaire.
Il fournit ainsi:
- Les unités lexicales à l’analyseur syntaxique
- Les types des identificateurs à l’analyseur sémantique et
- Les attributs des unités au traducteur en langage intermédiaire
- Si l’unité est un nombre alors l’attribut est la valeur de ce nombre
- Si l’unité est un opérateur arithmétique alors l’attribut est l’opérateur en
question (+, -, /, *)
- Si l’unité est oprel alors l’attribut est l’opérateur en question
(PPQ, PPE, PGQ, PGE, EGA, DIF)

Leila Ben Ayed Théorie des Langages et Compilation 298


II.2. Définition de la syntaxe

• Consiste en une grammaire non contextuelle


– C’est une grammaire (V, T, S, R) où
• V est l’ensemble des symboles non terminaux
• T est l’ensemble des terminaux
• S est le symbole de départ où l’axiome de la grammaire
• R est l’ensemble des règles de production de la forme A  u où u  (V + T)*

• Un programme est syntaxiquement correct s’il peut être généré par la


grammaire associée au langage de programmation

• Si le langage est l’ensemble des instructions d’affectation, alors un élément


de l’ensemble est une instruction d’affectation
Une grammaire possible est la suivante:

Leila Ben Ayed Théorie des Langages et Compilation 299


II.2. Définition de la syntaxe

Soit la grammaire non contextuelle G = (V, T, INST, R) où


V = {INST, EXP}
T = {id, :=, +, -, *, /, (, ), ;}
R = { INST  id := EXP;
EXP  id | nb | EXP + EXP | EXP * EXP | EXP – EXP | EXP / EXP
| (EXP) }

INST est l’axiome de la grammaire. Un mot est généré par la grammaire si en partant
de l’axiome (le symbole de départ) et en appliquant successivement des règles de
production, nous obtenons le mot (formé par une séquence de terminaux)

Par exemple le mot suivant est généré par la grammaire:


Id := id + (id*nb);

Leila Ben Ayed Théorie des Langages et Compilation 300


II.2. Définition de la syntaxe

Parce que on a:
INST  id := EXP;
 id := EXP + EXP ;
 id := id + EXP ;
 id := id + (EXP) ;
 id := id + (EXP * EXP) ;
 id := id + (id * EXP) ;
 id := id + (id * nb) ;

Leila Ben Ayed Théorie des Langages et Compilation 301


II.2. Définition de la syntaxe
Si le langage est formé par l’ensemble des séquences non vides d’instructions où
chaque instruction est une instruction d’affectation
alors une grammaire possible est la suivante :

LISTE_INST  INST | INST LISTE_INST


INST  id := EXP;
EXP  id | nb | EXP + EXP | EXP * EXP | EXP – EXP | EXP / EXP | (EXP)

LISTE_INST est l’axiome de la grammaire. Un mot est généré par la grammaire si en


partant de l’axiome (le symbole de départ) et en appliquant successivement des
règles de production, nous obtenons le mot (formé par une séquence de terminaux)

Par exemple le mot suivant est généré par la grammaire:


Id := id + (id*nb); id := nb;

Leila Ben Ayed Théorie des Langages et Compilation 302


II.2. Définition de la syntaxe

Parce que on a:
LISTE_INST  INST LISTE_INST
 id := EXP; LISTE_INST
 id := EXP + EXP ; LISTE_INST
 id := id + EXP ; LISTE_INST
 id := id + (EXP) ; LISTE_INST
 id := id + (EXP * EXP) ; LISTE_INST
 id := id + (id * EXP) ; LISTE_INST
 id := id + (id * nb) ; LISTE_INST
 id := id + (id * nb) ; INST
 id := id + (id * nb) ; id := EXP;
 id := id + (id * nb) ; id := nb;

Leila Ben Ayed Théorie des Langages et Compilation 303


II.3. Traduction dirigée par la syntaxe

• La traduction dirigée par la syntaxe est la combinaison d’un


analyseur syntaxique et d’un générateur de code intermédiaire

UL Traducteur Programme
Programme Analyseur dirigé par la
source lexical syntaxe
en LI
Données

Producteur Consommateur
• L’analyseur lexical (AL) joue le rôle de producteur et le traducteur dirigé par la syntaxe (TDS) joue le rôle de
consommateur
• L’AL produit une unité lexicale avec ses attributs et le TDS consomme cette unité et demande l’unité suivante (fait appel à
symbole_suivant())

Leila Ben Ayed Théorie des Langages et Compilation 304


II.3. Traduction dirigée par la syntaxe

• 2 méthodes différentes existent pour la


traduction dirigée par la syntaxe:
– Définition dirigée par la syntaxe
• Formalisme basé sur une grammaire + des règles
sémantiques
– Schéma de traduction
• Des production + des fragments de programmes

Leila Ben Ayed Théorie des Langages et Compilation 305


II.3. Traduction dirigée par la syntaxe
II.3.1. Définition dirigée par la syntaxe (DDS)

• Elle utilise une grammaire non contextuelle pour spécifier la


structure syntaxique du texte d’entrée.
• A chaque symbole non terminal de la grammaire, on associe un
ensemble d’attributs et à chaque production, on associe un
ensemble de règles sémantiques pour calculer la valeur des
attributs associés aux symboles apparaissant dans cette
production
• Une DDS est formée par les règles de la grammaire + des règles
sémantiques pour calculer les attributs.

Leila Ben Ayed Théorie des Langages et Compilation 306


II.3. Traduction dirigée par la syntaxe
II.3.2. Schéma de traduction
• C’est une grammaire non contextuelle étendue par des
fragments de programmes qui sont des actions de
traduction.
• Elles sont introduites à l’intérieure de la partie droite
des règles de production entre {}
• Au moment de la construction de l’arbre d’analyse, des
feuilles additionnelles sont associées à ces actions.
• En les parcourant de gauche à droite, nous obtenons le
résultat de la traduction.
Leila Ben Ayed Théorie des Langages et Compilation 307
II.4. Un traducteur pour les expressions
II.4.1. Traduction des expressions infixées en notation
post-fixée
• La notation postfixée pour une expression arithmétique E est définie récursivement
comme suit :
– Si E est une variable ou une constante alors la forme post fixée de E est E elle-
même
– Si E est de la forme E1 op E2 alors la forme postfixée de E est E1’E2’op où E1’ et E2’
sont respectivement les formes postfixée de E1 et E2.
– Si E est de la forme (E1) alors la forme post fixée de E est la forme postfixée de E1.
• Pour cet exemple, dans une DDS, on associe un attribut t à chaque non terminal
dont la valeur est une chaine qui représente la notation postfixée de l’expression
engendrée par ce non terminal dans un arbre syntaxique.

Leila Ben Ayed Théorie des Langages et Compilation 308


II.4. Un traducteur pour les expressions
II.4.2. DDS pour la traduction des expressions infixées
en notation post-fixées
Règles de production Règles sémantiques
Exp  Exp1 + Exp2 {Exp.t := Exp1.t ||Exp2.t||
+}
Exp  Exp1 * Exp2 {Exp.t := Exp1.t ||Exp2.t||
*}
Exp  (Exp1) {Exp.t := Exp1.t}
Exp  0 {Exp.t := 0}
Exp  1 {Exp.t := 1}
Exp  2 {Exp.t := 2}
…. .…
Exp  9 {Exp.t := 9}
Leila Ben Ayed Théorie des Langages et Compilation 309
II.4. Un traducteur pour les expressions
L’AS
Expdu mot (5+9)*2
Donne :
Exp * Exp

( Exp ) 2
Lorsque la règle de
production Exp  5
Exp + Exp est appliquée,
l’attribut t est calculé
par l’application de
la règle sémantique
et Exp.t prend la
5 9 valeur 5
Leila Ben Ayed Théorie des Langages et Compilation 310
II.4. Un traducteur pour les expressions
(5+9)*2
Exp.t:=59+2*
Est traduite par
5 9 + 2 * Exp.t:= 59+ * Exp.t:=2

( Exp.t:=5 9 + ) 2
Lorsque la règle de
production Exp  5
Exp.t := 5 + Exp.t :=9 est appliquée,
l’attribut t est calculé
par l’application de
la règle sémantique
et Exp.t prend la
5 9 valeur 5
Leila Ben Ayed Théorie des Langages et Compilation 311
II.4. Un traducteur pour les expressions
II.4.3. Schéma de traduction des expression
Exp  Exp1 + Exp2{Imprimer(+)}

Exp  Exp1 * Exp2{Imprimer(*)}

Exp  (Exp1)
Exp  0 {Imprimer(0)}
Exp  1 {Imprimer(1)}
Exp  2 {Imprimer(2)}
Exp  3 {Imprimer(3)}
Exp  4 {Imprimer(4)}
Exp  5 {Imprimer(5)}
Exp  6 {Imprimer(6)}
Exp  7 {Imprimer(7)}
Leila Ben Ayed Exp  8 Théorie
{Imprimer(8)}
des Langages et Compilation 312
II.4. Un traducteur pour les expressions
(5+9)*2
Exp
Est traduite par
5 Exp
9 + 2 ** Exp I(*)

( Exp ) 2 I(2)

En exécutant les
Exp + Exp I(+) Instructions
d’impression de
gauche à droite :
I(5)I(9)I(+)I(2)I(*)
5 Nous obtenons
I(5) 9 I(9) La forme post fixée :
59+2*
Leila Ben Ayed Théorie des Langages et Compilation 313
II.5. Analyse lexicale
• L’analyse lexicale consiste en la conversion du flot de caractères d’entrée en un flot
d’unités lexicales qui devient l’entrée pour les phases suivantes d’analyse (syntaxique,
sémantique et traduction en code intermédiaire) ou bien pour le traducteur dirigé par
la syntaxe dans le cas d’un compilateur en une seule passe. Un analyseur lexical est
basé sur les systèmes de transition (ou bien les automates finis)

Un diagramme de transition pour la reconnaissance de >=

Début > =
0 1 2 return(oprel, PGE)

autre

3 *
return(oprel, PGQ)

Leila Ben Ayed Théorie des Langages et Compilation 314


III. Analyse Syntaxique
Plan

III.1. Présentation Générale


III.2. Analyse syntaxique par descente récursive
III.3. Analyse syntaxique prédictive récursive
III.4. Analyse syntaxique prédictive non récursive
III.5. Récupération sur erreur
III.6. Analyse syntaxique par décalage réduction
III.1. Présentation générale
L’analyse syntaxique consiste à vérifier que la séquence d’unités
lexicales retournées par l’analyseur lexical est générée par la grammaire
du langage.
Ceci revient à construire un arbre syntaxique dont les feuilles
concordent avec la séquence d’unités lexicales en les parcourant de
gauche à droite.

Nous distinguons:

• Analyse syntaxique descendante


• Analyse syntaxique ascendante
III.1. Présentation générale
Analyse syntaxique descendante :
• Elle s’effectue par la construction descendante d’un arbre syntaxique en
partant de la racine étiquetée par l’axiome de la grammaire et en
réalisant de manière répétitive les étapes suivantes:

• Étape 1: au nœud n étiqueté par le non terminal A, choisir une


production ayant A à gauche et construire les fils de n avec les
symboles en partie droite de la production.

• Étape 2: déterminer le prochain nœud où un sous arbre doit être


construit.
III.2. Analyse syntaxique descendante
récursive
Exemple: Le langage est formé par un ensemble de Types générés par la
grammaire non contextuelle suivante:
Type  array[Type_simple] of Type
| Type_simple
| ^Type
Type_simple  integer
|char
|nb 2points nb
Les étapes de construction descendante de l’arbre syntaxique pour le
mot:
array[nb 2points nb] of integer
sont les suivantes:

Leila Ben Ayed Théorie des Langages et Compilation 318


III.2. Analyse syntaxique descendante
récursive
(a) Type

(b) Type

array [ Type_simple ] of Type

(c) Type

array [ Type_simple ] of Type

nb 2points nb

Leila Ben Ayed Théorie des Langages et Compilation 319


III.2. Analyse syntaxique descendante
récursive

(d) Type

array [ Type_simple ] of Type

nb 2points nb Type_simple

(e) Type

array [ Type_simple ] of Type

nb 2points nb Type_simple

integer

Leila Ben Ayed Théorie des Langages et Compilation 320


III.2. Analyse syntaxique descendante
récursive

• C’est une méthode d’analyse dans laquelle on


exécute des procédures récursives.
• Une procédure est associée à chaque non
terminal.

Leila Ben Ayed Théorie des Langages et Compilation 321


III.2. Analyse syntaxique descendante
récursive
Exemple: Le langage est formé par un ensemble de
Types générés par la grammaire non contextuelle
suivante:
Type  array[Type_simple] of Type
| Type_simple
| ^Type
Type_simple  integer
|char
|nb 2points nb
Leila Ben Ayed Théorie des Langages et Compilation 322
III.2. Analyse syntaxique descendante
récursive
Procedure accepter(T) Procedure Type_simple()
Si Symbole = T alors Si symbole = integer alors
symbole := symbole_suivant();
AnalLex(); accepter(integer);
Sinon erreur(); Sinon Si symbole = char alors
Fin Si accepter(char);
Procedure Type() Sinon Si symbole = nb alors
Si symbole = array alors accepter(nb);
accepter(array); accepter([); Type_simple(); accepter(2points);
accepter(]); accepter(nb);
accepter(of); Type(); Sinon erreur();
Sinon si symbole  {integer, char, nb} alors Fin Si Fin Si Fin Si
type_simple(); Fin
Symbole_suivant est une fonction
Sinon si symbole = ^ alors accepter(^); qui retourne le nouveau symbole
Type();
trouvé par l’analyseur lexical et
sinon erreur (); l’enregistre dans une variable
Fin Si FinSi FinSi globale symbole
Fin

Leila Ben Ayed Théorie des Langages et Compilation 323


III.3. Analyse syntaxique Prédictive
descendante récursive
• C’est une méthode d’analyse syntaxique par descente récursive
où un symbole de prévision permet de décider d’une manière
unique quelle règle peut être appliquée.
• La grammaire doit être non récursive à gauche et non ambiguë.
• Pour se faire, il faut éliminer la récursivité à gauche puis
enlever l’ambigüité.
• Ensuite, on associe une procédure à chaque non terminal.

Rq. Le pseudo-code précédent est associé à un analyseur


syntaxique prédictif récursif car la grammaire qui génère les
types est non ambiguë et non récursive à gauche

Leila Ben Ayed Théorie des Langages et Compilation 324


III.3.1. Elimination de la récursivité à gauche

• Une grammaire est dite récursive à gauche si


elle admet une règle de la forme : A  A 
• Une grammaire récursive à gauche avec les
règles de production
– A  A1|A2|…An |1|2 |… |m
Est transformée en une grammaire non récursive à
gauche ayant les règles de production :
– A  1 A’| 2A’|… mA’
– A’  1 A’|2A’|…nA’ |
Leila Ben Ayed Théorie des Langages et Compilation 325
III.3.1. Elimination de la récursivité à gauche

Exemple
• La grammaire suivante est récursive à gauche
Exp  Exp op Exp | (Exp) | id | nb
Elle est transformée en une grammaire non
récursive à gauche avec les règles suivantes:
Exp  (Exp) E’ | id E’ | nb E’
E’  op Exp E’ | 

Leila Ben Ayed Théorie des Langages et Compilation 326


III.3.2. Elimination de l’ambiguité
Une grammaire est dite ambiguë si elle admet des règles de la forme :
A   1 | 2
• Une grammaire ambiguë avec les règles de production
– A   1|2|…n |1|2 |… |m
Est transformée en une grammaire non ambiguë ayant les règles de production :
– A   A’|1 | 2 |…| n
A’  1|2|…n
• La grammaire suivante est ambigue
I  If (Expb) Then I | If (Expb) Then I else I
Elle est transformée en une grammaire non ambiguë avec les règles
suivantes:
I  If (Expb) Then I S
S   | else I

Leila Ben Ayed Théorie des Langages et Compilation 327


III.3.3. Exemple
Exemple: le langage est formé par une séquence non vide d’instructions d’affectation

L_I  I | I L_I
I  id := Exp;
Exp  id |nb| (Exp) | Exp op Exp
1) En éliminant la récursivité à gauche, on obtient:
L_I  I | I L_I
I  id := Exp;
Exp  id E’|nb E’| (Exp) E’
E’  op Exp E’ | 
2) En éliminant l’ambiguité, on obtient :
L_I  I S
S   | L_I
I  id := Exp;
Exp  id E’|nb E’| (Exp) E’
E’  op Exp E’ | 

Leila Ben Ayed Théorie des Langages et Compilation 328


III.3.3. Exemple
Un pseudo-code d’un analyseur syntaxique prédictif et récursif associé:

L_I  I S Procédure S()


Si symbole = id alors L_I();
S   | L_I Fin
I  id := Exp; Procédure I();
Exp  id E’|nb E’| (Exp) E’ Si symbole = id alors
accepter(id); accepter(:=);
E’  op Exp E’ |  Exp(); accepter(;);
Sinon erreur();
Fin Si
Fin
Procédure accepter(T) Procédure Exp();
Si symbole = T alors Symbole := symbole_ Si symbole = id alors accepter(id); E’();
suivant(); Sinon Si symbole = nb alors accepter(nb); E’();
Sinon erreur(); Sinon si symbole = ( alors accepter((); Exp(); accepter()); E’();
Sinon erreur();
FinSi
Fin Si Fin Si Fin Si
Fin Fin
Procédure L_I() Procédure E’()
I(); S(); Si symbole = op alors accepter(op); Exp(); E’();
Fin
Fin

Leila Ben Ayed Théorie des Langages et Compilation 329