Cours de Compilation F

Université Sidi Mohammed Ecole Nationale des
Ben Abdelah – Fès Sciences Appliquées
Compilation et optimisation du code
Réalisé par: Nabil El akkad
2023/2024
Plan
Introduction
Expression régulière et automates finis
Grammaires hors-contexte et automates à pile
Analyse lexicale
Analyse syntaxique
Analyse sémantique
Génération du code
Optimisation de code 2
Introduction
Objectif de la
matière
Théorie de langage Phases d’un compilateur

Etudier les caractéristiques des langages de Construire un compilateur qui permet de
programmation: traduire un programme source en un
1- Connaître les propriétés des langages programme objet:
(Alphabet, Mot, Type). 1-Phases d’analyse: Dégage les
2- Dénoter les langages par des expressions constituants d’un programme source
3- Construire et étudier le système (Lexical, syntaxique, sémantique)
générateur d’un langage (Grammaire) 2-Phases de synthèse: Construit le
4- Construire et étudier le système programme cible (Génération et
reconnaisseur d’un langage (Automate). optimisation du code intermédiaire,
génération du code final)
3
Introduction (suite)
 Théorie de langage
Définition
La théorie de langage est une matière qui permet de comprendre le
fonctionnement des langages par un modèle mathématique qui doit être
capable de:
1- Décrire un langage;
2- Reconnaître les mots qui appartiennent à un langage donné.
Applications pratiques
- Définition formelle (lexical, syntaxique et sémantique) de langages de
programmation,
- Construction de compilateurs,
- …..
4
Introduction
 Théorie de langage (suite)
Symbole
Un symbole est une entité abstraite.
Exemples: Lettres, Chiffres, Symboles graphiques.
Alphabet
Un alphabet (ou vocabulaire) noté Ω est un ensemble de symboles.
Exemples: Ω = {0 ,1} , Ω = {0; 1; 2; 3; 4; 5; 6; 7; 8; 9; .} , Ω = {a,b,…..z}.
Mot
Un mot (ou bien une chaîne ou lexème) défini sur un alphabet Ω est
une suite finie de symboles juxtaposés (ou concaténés) de Ω.
Exemples: Le mot 1011 est défini sur l’alphabet {0, 1} ; le mot 1.23 est
défini sur l’alphabet {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, .}.
5
Remarque: Le mot vide est une suite vide de symboles et noté ε.
Introduction
Longueur d’un mot
La longueur d’un mot m est le nombre de symboles qui le composent.
Elle est notée par |m|.
Exemples: |ababb|=5 , | ε|=0
Nombre d’occurrence
La cardinalité d’un mot m par rapport à un symbole a Ω est Le
nombre d’occurrence de la lettre a dans m. Elle est notée par |m|a
Exemples: |ababb|a=2 , |abbaaba|b=3
Propriété: m   m x
xΩ
6
Introduction
Concaténation
Soient m, m’ et m’’ trois mots sur l’alphabet Ω.
- La concatenation de m et m’ est obtenue en écrivant m suivi de m’,
elle est notée par mm’ ou m.m’.
- εm = mε = m, avec ε est le mot vide
- Soit x une lettre (x Ω), xn (n ΙN) est la concaténation de n lettres
identiques, avec x0 = ε et x1= x
- mn (n ΙN) est la concaténation de n mots identiques.
- La concaténation est associativité: m(m’m’’) = (mm’)m’’
- |mm’|= |m|+ |m’| , |mn|=n |m| , avec n ΙN
- La concaténation n'est pas commutative: mm’ ≠ m’m
Exemples: (aabac).(dab) vaut aabacdab , b2 = bb , (ab)3 = ababab 7
Introduction
Préfixe, suffixe et miroir
Soient m, m’ et m’’ trois mots tels que: m=m’m’’. On dit que:
- m’ est un mot préfixe de m.
- m’’ est un mot suffixe de m.
- Le miroir du mot m (notée par miroir(m) ou mR) est le mot formé par la
suite des symboles composant m mais pris dans l'ordre inverse.
Propriétés: (mR )R = m , (mm’)R = m’R mR
Exemples: aabbba=(aab)(bba). Donc aab et bba sont, respectivement,
le préfixe et le suffixe de aabbba. (1010)R=0101. miroir(ε)= ε
Mots conjugués
Deux mots m et m’ sont dits conjugués s’il existe deux mots u et v tels
que : m = uv et m’ = vu. 8
Introduction
Langage formel
L'ensemble de mots sur un alphabet Ω est noté Ω* (fermeture transitive). Un
langage L sur Ω est une partie de Ω* tel que:
L   * où L  Ρ (  *)
Exemple:
Soit Ω = {a , b} un alphabet.
- Φ est un langage
- {ε} est un langage
- {a , ba , aab} est un langage
9
Introduction
Langage formel
Un langage formel, noté L, est un ensemble (fini ou infini) de mots définis sur un
alphabet Ω donné. En général, un langage peut être défini par:
Extension: Tous les éléments du L sont donnés (L fini).
Compréhension: Tous les éléments du L sont définis à partir d’une propriété (L fini ou
infini). L= {n ΙN | n est paire}
Induction: Le langage L est défini par certains éléments triviaux (c’est-à-dire des
éléments dont on sait, sans démonstration, qu’ils appartiennent à L) et des règles
d’induction (m L f(m) L) permettant de retrouver d’autres éléments de L en
fonction de ceux connus (L fini ou infini).
Exemples:
 L’ensemble des lexèmes définis dans le langage JAVA.
 L’ensemble des programmes en langage JAVA.
 Soit L   * (avec Ω ={0,1}).
L peut être défini par induction comme suit:
ε L, si x L alors 0x1 L, si x L alors 1x0 L et si x, y L alors xy L 10
Introduction
Opération sur les langages
Soient L et L’ deux langages définis sur un alphabet Ω.
- L L’ (ou L+ L’ ou L | L’) est un langage sur Ω obtenu par la réunion de L et L’,
tel que: L L’= {m / m L ou m L’}.
- L∩L’ est un langage sur Ω obtenu par l’intersection de L et L’, tel que
L∩L’= {m / m L et m L’}.
- Le complément du langage L , noté par L ,est obtenu par: L = {m / m  L}
- LL’ est un langage sur Ω obtenu par la concaténation de L et L’, tel que:
L.L’ = {m / u L, v L’ : m = uv}.
- Le langage exposant d’un langage L, noté Ln, est obtenu par:
Ln=L.L...L= {m / u1, u2, ...un L : m = u1u2 ...un }.
n
11
Introduction
Opération sur les langages (suite)
- La fermeture itérative de Kleene de L est notée par:
* i
L   i 0 L
- La fermeture positive de Kleene de L est notée par:

L    i  0 Li
- Le langage miroir de L est donnée par:

LR = {m / u L : m = uR}.
Remarque:
L*=L+ + {ε} 12
Introduction
Grammaire: Définition
Une grammaire est une notation utilisée pour la description de la syntaxe
d’un langage, c.à.d. de la façon avec laquelle les mots de langage seront
organisées et utilisées.
Exemple: Pour analyser une classe de phrases simples en français, on
peut supposer qu’une phrase est construite de la manière suivante :
PHRASE → ARTICLE SUJET VERBE COMPLEMENT
SUJET → "garçon" ou "fille"
VERBE → "voit" ou "mange" ou "porte"
COMPLEMENT → ARTICLE NOM ADJECTIF
ARTICLE → "un" ou "le" ou "une" ou "la"
NOM → "livre" ou "plat"
ADJECTIF → "bleu" ou "rouge" ou "vert" 13
Introduction
Grammaire: Définition formelle
On appelle grammaire le quadruplet G (VT, VN, R, S) telle que:
VT: Ensemble fini de symboles (ou des mots) dits terminaux, on l’appelle
également vocabulaire terminal. Exemple: VT ={garçon, fille, voit, mange,
porte, un, le, une, la, livre, plat, bleu, rouge, vert}.
VN: Ensemble fini de symboles (ou des mots) non terminaux qui représente les
noms attribués aux productions constituant la grammaire du langage.
Exemple: VN = {PHRASE, ARTICLE, SUJET, VERBE, NOM,
COMPLEMENT}
R: Ensemble de règles de productions de la forme g → d tel que g (VTỤVN)+ et
d (VTỤ VN)* . (Voir l’exemple précédent)
S: Symbole (ou Mot) non-terminal particulier appelé axiome (mot de départ de la
grammaire). Dans l’exemple précédent, l’axiome est: PHRASE.
Par convention, on utilisera les lettres majuscules pour les non-terminaux,

14
et les lettres minuscules pour représenter les terminaux.
Introduction
Grammaire: Propriétés sur les règles de production
Soit G=(VT,VN,R,S) une grammaire
- Les règles X → Y1 , X → Y2 , ….. X → Yk ayant même partie gauche sont
souvent notées X → Y1 | Y2 |….. |Yk .
- Les règles de la forme ε→d (avec ε est le mot vide, d (VTỤ VN)* ) sont
interdites.
- On appelle dérivation sur G, toute suite finie X1 , X2 , ….. Xk telle que k≥1 et
X1→ X2 → …..→ Xk . On dit que Xk est dérivé à partir de X1 ou X1 se dérive en
Xk .
-X Y : si X se dérive en Y par l’application de 0, une ou plusieurs règles de
production.
-X Y : si X se dérive en Y par application au moins d’une règle.
n
- X Y : si X se dérive en Y par application de n règles.
- X Y : si X se dérive en Y par application d’une seule règle.
- Si X1 Y1 , X2 Y2 , ….. Xk Yk alors X1X2….. Xk Y1Y2….. Yk 15
Introduction
Grammaire: Arbre syntaxique
Soit une grammaire G=(VT,VN,R,S), les arbres de syntaxe de G sont des arbres
où les nœuds internes sont étiquetés par des symboles de VN, et les feuilles
étiquetés par des symboles de VT .
Exemple:
Soit la grammaire G = ({a, b}, {S, T}, {S → aS|aT, T → bT|b}, S). Elle génère le
mot aab selon la chaîne de dérivation S → aS → aaT → aab. Ce qui donne donc
l’arbre syntaxique suivant :
Remarque: Si l’arbre syntaxique a comme racine S, alors il est dit arbre de

dérivation du mot u tel que u est le mot obtenu en prenant les feuilles de l’arbre
dans le sens gauche→droite et bas→haut. 16
Introduction
Grammaire: Classification de Chomsky
Soit G=(VT,VN,R,S) une grammaire, les classes de grammaires de
Chomsky sont :
- Grammaire régulière à droite ou à gauche (Type 3): Toutes les
règles de production sont de la forme X→Y où X VN et Y=cZ (à droite)
ou Y=Zc (à gauche) tel que c VT* et Z VN {ε}.
- Grammaire hors-contexte (Type 2): Toutes les règles de production
sont de la forme X→Y où X VN et Y (VT VN)∗
- Grammaire contextuelle (Type 1): Toutes les règles sont de la forme
X→Y où X (VT VN)+ , Y (VT VN)∗ et |X|≤|Y|.
- Grammaire générale (Type 0): Toutes les règles sont de la forme :
X→Y où X (VT VN)+ et Y (VT VN)∗ . (aucune restriction)
17
Introduction
Grammaire: Langage engendrée
Soit G=(VT,VN,R,S) une grammaire . Le langage défini par la grammaire
G appelé L(G) est l'ensemble des mots dérivés du symbole de départ :
L(G) = { m VT* / S * m}
Un langage de type i est un langage engendré par une grammaire de
type i tel que:
- Langage de type 3 est un langage régulier ou rationnel.
- Langage de type 2 est un langage algébrique.
- Langage de type 1 est un langage contextuel.
- Langage de type 0 est un langage récursivement énumérable.
Remarque importante :
Une grammaire définit un seul langage. Par contre, un même langage
peut être engendré par plusieurs grammaires différentes. 18
Introduction
Automate: Définition
Un automate est un modèle mathématique (ou une machine abstraite) qui
permet de lire un mot et de répondre à la question : "un mot m
appartient-il à un langage L ?" par oui ou non.
En général, un automate est composé de :
- Une bande en entrée sur laquelle sera inscrit le mot à lire;
- Une tête de lecture qui permet de lire le mot en entrée.
- Un organe de commande qui permet de gérer un ensemble fini de pas
d’exécution ;
- Une mémoire auxiliaire de stockage.
19
Introduction
Automate: Définition (suite)
 Une bande de lecture
 Elle est constitue d’une succession de cases;
 Chaque case contient un seul symbole d’un alphabet d’entrée;
 Le mot à reconnaître est écrit dans les cases de cette bande de lecture.
 Une tête te de lecture
 Elle peut lire une case à un moment donné;
 Dans la case où se trouve la tête de lecture à un instant donné est
appelée la case courante;
 La tête peut être déplacée par le reconnaisseur pour se positionner sur
la case immédiatement à gauche ou à droite de la case courante.
 Une mémoire
 Elle peut avoir des formes différentes.
 La mémoire stocke des éléments d’un alphabet de mémoire. 20
Introduction
 Une unité de contrôle
 Elle constitue le cœur d’un reconnaisseur;
 Elle est vue comme un pg qui dicte au reconnaisseur son comportement.
 Elle est définie par un ensemble fini d’états et une fonction de transition
définissant le passage d’un état à un autre en fonction du contenu de la
case courante de la bande de lecture et du contenu de la mémoire.
 L’unité de contrôle détermine le sens de déplacement de la tête de
lecture et choisit les symboles qui seront sauvegarder dans la mémoire.
 Parmi les états d’un reconnaisseur, on trouve:
o Des états initiaux: les états dans lesquels doit se trouver le
reconnaisseur avant de commencer la reconnaissance d’un mot;
o Des états d’acceptation: les états dans lesquels doit se trouver le
reconnaisseur après la reconnaissance d’un mot. 21
Introduction
Formellement, un automate contient au minimum :
– Un alphabet pour les mots en entrée;
– Un ensemble non vide d’états;
– Un état initial;
– Un ensemble non vide d’états finaux;
– Une fonction de transition (permettant de changer d’état).
Exemple: L’automate des mots contenant le facteur ab est le suivant:
Remarque: On dit qu’un mot est reconnu par un automate si, à partir d’un état
initiale, on arrive à un état final à travers une succession d’état intermédiaires . On
dit aussi qu’un langage est reconnu par un automate lorsque tous les mots de ce
langage sont reconnus par l’automate. 22
Introduction
Automate: Classification de Chomsky
- Automate à états fini: Utilisé pour reconnaitre les langages de type 3.
- Automate à pile: Pour reconnaitre les langages de type 2.
- Automate à bornes linéaires: Pour reconnaitre les langages de type 1.
- Machine de Turing: Pour reconnaitre les langages de type 0.
23
Correction de l’exercice 1
Série N°1
 Exercice 1
1-Trouvez les langages correspondants aux définitions suivantes:
- Tous les mots sur {a, b, c} qui commencent par un a et finissent par un b.
- Tous les mots sur {a, b} qui contiennent plus de a que de b.
2- On note par Pref(L) l’ensemble suivant : {u| m L : u est préfixe de m} et par Suf(L) l’ensemble
suivant : {v| m L : v est suffixe de m}. Calculez Pref(L) et Suf(L) dans chacun des cas suivants
: L = {ab, ac,ε}, L= {anbm|n,m ≥ 0}
3- On note par Conj(m) l’ensemble des conjugués de m. Trouvez Conj(m) pour m =ε et m = anbn.
4- Définissez la fermeture de Kleene (L∗) pour chacun des langages suivants: L = {ε}, L = {a, aa}.
5- Précisez le type de chacune des grammaires suivantes ainsi que les types des langages qui en
dérivent :
- G = ({a, b}, {S, T}, {S → aabS|aT, T → bS|ε} , S);
- G = ({a, b, c}, {S, T,U}, {S → bSTa|aTb, T → abS|cU,U → S|ε}, S) ;
- G = ({0, 1, 2}, {S,C, Z, T}, {S → TZ, T → 0T1C|ε,C1 → 1C,CZ → Z2, 1Z → 1}, S).
6- Donnez, sans démonstration, les langages générés par les grammaires suivantes. Dites, à
chaque fois, de quel type s’agit-il ? :
- G = ({a,b}, {S}, {S → abS|b}, S).
- G = ({a, b}, {S}, {S → aSa|bSb|ε}, S) 24
Introduction
 Définition d’un compilateur
Un compilateur est un outil qui lit un programme source écrit dans un
langage donné et le traduit en un programme correspondant écrit dans
un autre langage tout en signalant les erreurs du programme source.
Programme Programme
Source Compilateur Cible
Phases Phases
Analyse Synthèse
Messages d’erreurs
Un compilateur est décomposé en deux phases principales:

Phases d’analyse: Permettent de dégager les constituants d’un
programme source dans une représentation intermédiaire.
Phases de synthèse: Permettent de construire le programme cible à
25
partir de cette représentation intermédiaire.
 Phases d’un compilateur
Un compilateur typique se décompose en 6 phases élémentaires: 3 phases
d’analyse et 3 phases de synthèse. Deux autres tâches interagissent avec les six
phases : la gestion d’une table des symboles et la détection des erreurs.
Programme
Analyseur lexical
source
Analyseur syntaxique
Table des Analyseur sémantique Gestion

symboles des erreurs
Générateur de code intermédiaire
Optimiseur de code
Programme
Générateur de code final
Cible 26
Introduction
 Phases d’un compilateur (suite)
Phase Description Exemple
Permet de reconnaître les unités identificateurs
lexicales ou lexèmes (Identificateurs, y := a * b + 30

Analyseur lexical
mots clés du langage; affectations et
opérateurs (+,*,...)). Affectation opérateurs nombre
Permet de vérifier les entités en entrée :=

apparaissent conformément ou non y +
Analyseur syntaxique aux règles définissent la grammaire du
langage. * 30
a b
Permet de contrôler la cohérence y:=a*b+30 :=
sémantique du programme source: erreur si y et a
-Vérifie la cohérence des types des sont des entiers y +
alors que b est
Analyseur sémantique variables et des expressions de type * conversion
-Procède parfois à des conversions caractère

entier réel
a b
(entier vers réel).
-…….. 30
27
Introduction
Permet de construire une Pour y:=a*b+30 on trouve:
représentation intermédiaire, des t1←ER(30) //ER: Entier vers réel
Générateur de code programmes sources, indépendante t2←id2*id3
intermédiaire de tous les langages de t3←t2+t1
programmation. id1←t3
Permet d’améliorer le code t1←id2*id3

Optimiseur de code intermédiaire par la réduction du id1←t1+30.0
nombre de variables et d’instructions
Permet de choisir des emplacements Mov R2, id2

mémoire pour les variables et de les Mul id3; (R2= AL, Ax ou Eax)
Générateur de code assigner aux registres. Mov R1, 30
final Add R1, R2
Mov id1, R1
28
Introduction
Permet de stocker toutes les informations Table des
nécessaires sur les lexèmes (mots) du symboles
programmes source id1 y
Gestion de table
des symboles id2 a
id3 b
Après avoir détecté une erreur, une phase -Erreurs lexicaux,

doit la signaler et la traiter de telle façon que -Erreurs syntaxiques,
Gestion des erreurs le compilateur puisse continuer son -Erreurs sémantiques,
traitement et que d’autres erreurs puissent
-……
être détectées.
29
Introduction
Analyseur lexical Analyseur syntaxique Analyseur sémantique
y:=a*b+30 id1:=id2*id3+nombre
Tables des
symboles
id1 y Mov R2, id2
Mul id3; (R2= Al, Ax ou Eax)
id2 a
Mov R1, 30
id3 b Add R1, R2
Mov id1, R1
Générateur de code
Générateur de code Optimiseur de code intermédiaire
t1←id2*id3 t1←ER(30)
id1←t1+30.0 t2←id2*id3
t3←t2+t1
id1←t3 30
 Environnement d’un compilateur
La création d’un programme cible exécutable requiert en fait plusieurs
programmes, en plus du strict compilateur.
Programme source Eventuellement dispersé dans différents fichiers
Contient des définition de symboles, macros…….
En C++ , macros: #define MIN(a,b) ((a) < (b)) ? (a) : (b)
- Remplace les macros par leur définition

Préprocesseur - Crée un fichier unique
Compilateur Produit un programme cible en langage

d’assemblage
Assembleur Produit un code machine translatable
-Un pg cible peut être constitué de plrs fichiers

Relieur-chargeur objet translatables, et nécessite parfois des biblio..
-Les assembler pour créer le pg cible exécutable.
-Cette opération: édition de liens
Code machine absolu 31
Introduction
 Compilateur et interpréteur
Algorithme
Editeur de texte
Programme source Programme source
Erreurs de Résultat
Compilateur Données Interpréteur
compilation Erreurs
Editeur de lien Erreurs

d’édition de lien Exemples: Lisp, Perl, Prolog, …
Programme cible
Résultats
Données Processeur Erreurs
d’exécution
Exemples: Pascal, C, C++,… 32

Langage compilé: étapes qui ont lieu avant l'exécution
pour un langage de ce type comme C++.
Fichier
de Librairies
code
Code objet Edition de liens Programme

Compilation
exécutable
Autres code objet

Fichier
d'entête
Langage interprété : cas de Java
Introduction
 Outils pour la construction d’un compilateur

Constructeur d’analyseur lexical: Expression régulière, Automate fini
Constructeur d’analyseur syntaxique: Grammaire, automate à pile
Constructeur d’analyseur sémantique: Traduction dirigée par la syntaxe.
Génération de code: Traduction dirigée par la syntaxe, assembleur.
35
Plan
Introduction
Analyse lexicale
Analyse syntaxique
Analyse sémantique
Génération de code
36
 Expression régulière
Définition
Soit Ω un alphabet quelconque ne contenant pas les symboles { ,+,|,.,(,)}.
Une expression régulière (ou rationnelles) est un mot défini sur l’alphabet
Ω { ,+, |, ., (, )} permettant de représenter un langage régulier de la
façon suivante :
– L’expression régulière ε dénote le langage vide (L = {ε}) ;

– L’expression régulière a (a Ω) dénote le langage L = {a} ;
– Si r est une expression régulière qui dénote L alors (r) (resp. (r)+) est
l’expression régulière qui dénote L (resp. L+) ;
– Si r est une expression régulière dénotant L et s une expression
régulière dénotant L′ alors (r)|(s) est une expression régulière dénotant
L L′. L’expression régulière (r).(s) (ou simplement (r)(s)) dénote le
langage L.L′.
37
 Expression régulière (suite)
Exemples
considérons l’alphabet Ω={0,1}
1- L’expression 0* décrit tous les mots composés uniquement du symbole
0 ainsi que le mot vide ε. (0000, 000,…..).
2- L’expression 110*1 décrit tous les mots contenant deux fois le symbole
1 suivis d’un nombre quelconque de symboles 0 ou vide et du symbole 1.
(1100001, 110000001,……).
3- L’expression 0*110*1 est la concaténation des deux expressions 1 et 2

(précédente). (00001100001, 00011001,……).
4- L’expression 0*|110*1 décrit l’expression des mots générées soit par

l’expression 1 ou par 2 (00000, 1100001, ……).
38
Remarques:
1- Opérateur unaire + : au moins une fois : E+= EE* .
2- Opérateur unaire ? : 0 ou 1 fois: E? = E|ε.
3- Priorité des opérateurs: * , +, concaténation , |
Exemples:
aa*|b+ est interprétée comme (a(a)*)|(b)+
a|b*c est interprétée comme (a)|((b)*c)
39
Ambiguïté
Une expression régulière est dite ambiguë s’il existe au moins un mot
pouvant être mis en correspondance avec l’expression régulière de
plusieurs façons.
Exemple:
Considérons l’expression (a|b) a(a|b) décrivant tous les mots sur {a, b}
contenant le facteur a. Soit à faire correspondre le mot abaab, on a :
Il existe donc au moins deux façons pour faire correspondre abaab à

l’expression précédente, elle est donc ambiguë.
40
Comment lever l’ambiguïté?
Il n’existe pas une méthode précise pour lever l’ambiguïté d’une E.R.
Cependant, cette opération dépend de l’hypothèse de reconnaissance.
Exemple:
On peut décider que le facteur fixe soit le premier « a » du mot à

reconnaître ce qui donne l’expression régulière : b a(a|b) .
41
 Langages réguliers
Définition
Les langages réguliers (ou rationnels) sont les langages générés par des
grammaires de type 3 (ou encore grammaires régulières). Ils sont
reconnus grâce aux automates à états finis (voir la partie suivante).
Exemples:
a∗ : dénote le langage régulier an (n ≥ 0) ;
(a|b)∗ : dénote les mots dans lesquels le symbole a ou b se répètent un
nombre quelconque de fois. Elle dénote donc le langage de tous les mots
sur {a, b} ;
(a|b)∗ab(a|b)∗ : dénote tous les mots sur {a, b} contenant le facteur ab.
42
 Langages réguliers (suite)
Propriétés
Soient L et L’ deux langages réguliers désignés respectivement par les
expressions régulières r et s, on a:
1- L+L’ , L∩L’, L , LR, L.L’, L∗ (resp. L+) sont des langages réguliers.
2- L’union finie de langages réguliers représente un langage régulier.

Ainsi, on peut dire que tout langage fini représente un langage régulier.
3- L’union infinie de langages réguliers peut ou non être un langage

régulier.
43
Série N°1
Exercice 2
Démontrez, à l’aide de la définition inductive des langages réguliers, que les deux
langages suivants sont réguliers (l’alphabet considéré est Ω= {0; 1}):
1. L’ensemble des mots composés d’un nombre arbitraire de 1, suivis de 01,
suivis d’un nombre arbitraire de 0.
2. L’ensemble des nombres binaires impairs.
44
Série N°1
Exercice 3
1. Démontrez que tout langage fini est régulier.
2. Donnez une expression régulière qui accepte chacun des langages suivants
(définis sur l’alphabet Ω={0; 1}):
- Toutes les chaînes qui se terminent par 00.
- Toutes les chaînes dont le 10ème symbole, compté à partir de la fin de la

chaîne, est un 1.
45
 Langages réguliers (suite)
Lemme de pompe (ou de l’étoile, d’itération ou de gonflement): a
été formulé en 1961 par Bar-Hillel, Micha Perles, Eli Shamir
Soit L un langage régulier défini sur l’alphabet Ω. Il existe alors un entier n

tel que pour tout mot m L de longueur |m| ≥ n, il existe x, z Ω∗ et y Ω+
tels que :
– m = xyz ;
– |xy| ≤ n ;
– xyiz L pour tout i ≥ 0.
46
Série N°1
Exercice 4 (à faire)
1- Montrer que le langage régulier akbl vérifie les critères de pompe.
2- Montrer que le langage anbn n’est pas régulier.
47
Expression régulière et automates finis (suite)
 Automates finis
Définition
Un automate fini (AF) est un diagramme de transition qui peut reconnaitre avec
précision ce que les expressions régulières peuvent dénoter.
Modélisation de l’AF
Un AF est une machine modélisée par:
- Un ruban d’entrée (Input Tape): Sur lequel on place le mot à traiter (Input Word).
Le ruban est divisé en case (caractères).
- Une tête de lecture (Read Head): Indiquant la position du caractère suivant à lire.
- Un ensemble d’états (Set of states), parmi lesquels:
- L’état initial: Etat de l’automate au départ de l’exécution.
- Des états accepteurs: états dans lesquels doit se trouver le reconnaisseur
après avoir reconnu un mot.
- Une relation de transition: Indiquant pour chaque état et symbole lu qu’il est
l’état suivant de l’automate.
48
 Automates finis (suite)
Formalisation d’un AF
Un automate fini est un modèle mathématique qui est défini par un
quintuplet A=(Q, V, δ, q0, F) où:
- Q est un ensemble d‘états.

- V est un ensemble de symboles d'entrée (alphabet).
- δ est une fonction de transition qui prend comme argument un état et un
symbole d'entrée et qui retourne un état: δ: Q×V→Q
- q0 est l’état initial de l’automate tel que q0 Q .
- F est un ensemble d‘états finaux ou états d'acceptation tel que F  Q .
49
Représentation d’un AF par un graphe de transition
Un AF est représenté par un graphe (ou diagramme) orienté étiqueté, appelé
graphe de transition tel que :
- L’état initial est désigné par une flèche entrante au sommet correspondant
- Pour chaque état q, q Q, il existe un nœud étiqueté q.
- Pour chaque état q et chaque symbole a de V tel que δ(q; a) = p, il existe un arc
du nœud q vers le nœud p étiqueté a.
- Les nœuds correspondant aux états de satisfaction (états appartenant à F) sont
représentés par un cercle double.
Exemple: Soit le langage L = {akbr/ k≥0 et r >0}
q0 q1
50
 Automates finis
Représentation d’un AF par une table de transition (suite)
La table de transition est un tableau qui permet de représenter la fonction
de transition δ(q; a) = p entre les deux états q et p par le symbole a.
Soit l’AF de l’exemple précédent, la table de transition correspondante
est:
a b Exemple: δ(q0; a) = q0
→ q0 q0 q1 → : désigne l’état initial
* q1 - q1 * : désigne l’état final
51
Automate Fini non déterministe (AFN)
Un AFN est un AF caractérisé par:
- Plusieurs transitions correspondantes au même symbole sortant d’un même
état. a q2
q
q1
a
- Des transitions sur le symbole ε (mot vide): Changer d’état sans avancé dans le
mot d’entrée. ε
q > q1
Exemple d’un AFN
q0 q1 q2
52
Automate Fini déterministe (AFD)
Un AFD est un cas particulier des AFN tel que:
- Aucun état n’a de ε transition.
- Pour chaque état q et chaque symbole a, il existe au plus un arc
d’étiquette a partant de q.
Exemple d’un AFD
q0 q1
53
Automate Fini déterministe complet (AFDC)
Un automate fini déterministe complet (AFDC) est un automate déterministe pour
lequel chaque état q et chaque symbole a, il existe un et un seul arc d’étiquette a
partant de q.
Exemple d’un AFDC
54
Transformation de l’AFD en AFDC
Tout AFD peut être transformé en un AFDC reconnaissant le même langage par
l’algorithme suivant:
- Rajouter à l’AFD un nouvel état P non final (« P est appelé état poubelle ou état
erreur »);
- Rajouter les transitions d’étiquettes manquantes en les dirigeant toutes vers cet
état poubelle P ; ne pas oublier les transitions de P vers lui-même .
Exemple
a,b,c
AFD non complet AFD complet 55


Théorème de Rabin et Scott
Tout langage accepté par un AFN est également accepté par un AFD.
Proposition
Tout AFN (avec ou sans ε-transition) peut être transformé en un AFD.
56
Transformation d’un AFN sans ε-transition en AFD
1- Etat initial de l’AFD E(0)={q0} est l’état initial du l’AFN;
2- Construire E(1) l’ensemble des états obtenus à partir de E(0) par la transition x:
E(1)=Uq’E(0)δ(q’, x)
3-Recommencer l’étape 2 pour toutes les transitions possibles et pour chaque nouvel
ensemble E(k);
E(k)= Uq’E(k-1)δ(q’,x)
4- Tous les ensembles contenant au moins un état final du premier automate
deviennent finaux;
5- Renuméroter les états en tant qu’états simples.
Série N°1
Exercice 5
Transformer en AFD l’automates suivant :
58
Transformation d’un AFN avec ε-transition en AFD
Soit A=(Q, V, δ, q0, F) un AFN et s  V, q  Q et T  Q. On note par:
- ε-fermeture(q): L’ensemble des états de l’AFN accessible depuis q par
des ε-transition (q appartient aussi à cet ensemble).
- ε-transition: la transition sur le symbole ε.
- ε-fermeture(T)=  ε-fermeture(q)
q T
- Transition(T,s)=  Transition(q,s)=  δ(q,s)

q T q T
Exemple ε
a b c
q0 q1 q2 q3
ε 59
ε-fermeture(q0)={q2, q1, q0}
 Automates finis
Transformation d’un AFN avec ε-transition en AFD (suite)
1- A partir de l’ε-fermeture de l’état initial (on représente le nouvel état initial)
2- Rajouter dans la table de transition toutes les ε-fermetures des nouveaux états produits avec
leurs transitions;
3- Recommencer l’étape 2 jusqu’à ce qu’il n’y ait plus de nouvel état;
4- Tous les ε-fermetures contenant au moins un état final du premier automate deviennent
finaux;
5- Renuméroter les états en tant qu’états simples.
2
3
 Automates finis
Transformation d’un AFN avec ε-transition en AFD (suite)
Exemple:
Algorithme
AFN
État a b c
A={0, 1, 3} B={1,2} ---- C={4}
B={1,2} D={2} E={1,3} ----
C={4} ---- ---- ----
D={2} ---- E={1,3} ----
E={1,3} D={2} ---- C={4}
AFD
61
Minimisation d’un AFD
Par - Eliminer les états qui n’ont pas un

Minimiser un Réduire le chemin à partir de l’état initial
AFD nombre d’états - Fusionner les états reconnaissant
le même langage.
Pour
- Réduire le temps de reconnaissance

- Réduire l’espace mémoire utilisé pour sauvegarder l’AFD
Deux Méthodes - Moore (pour les AFD)

- Brzozowski (pour les automates quelconques)
62
 Automates finis
Minimisation d’un AFD (suite)
Définition 1: Un état est dit inaccessible s’il n’existe aucun chemin permettant
de l’atteindre à partir de l’état initial.
Définition 2: Deux états qi et qj sont dits β-équivalents s’ils permettent

d’atteindre les états finaux en utilisant les mêmes mots (pour tout mot x V*,
δ(qi, x) F si et seulement si δ(qj, x) F). On écrit alors : qiβqj.
Remarques:
1-La relation R (R= β-équivalence) est une relation d’équivalence, car elle est:
-Réflexive (pRp), p Q
-Symétrique (pRq qRp), p,q Q
-Transitive (pRq et qRq’ pRq’). p,q,q’ Q
2- Le nombre de classes d’équivalence de la relation β-équivalence est égal au
nombre des états de l’automate minimal, car les états de chaque classe
d’équivalence reconnaissent le même langage (ils seront fusionnés). 63
 Automates finis
Pour minimiser un AFD, il faut suivre la méthode suivante:
1- Nettoyer l’automate en éliminant les états inaccessibles ;
2- Regrouper les états appartenant à la même classe d’équivalence.
Remarque: L’automate de départ et l’automate minimisé doivent reconnaitre les
mêmes mots.
Exemple: Etat a b
Minimiser l’AFD suivant: *1 2 5
*2 2 4
3 3 2
4 5 3
5 4 6
6 6 1
7 5 7 64
 Automates finis
1- Nettoyer l’automate en éliminant les états inaccessibles :
Etat a b Etat a b
*1 2 5 L’état 7 est inaccessibles *1 2 5
*2 2 4 *2 2 4
3 3 2 3 3 2
4 5 3 4 5 3
5 4 6 5 4 6
6 6 1 6 6 1
7 5 7
65
 Automates finis
2- Regrouper les états appartenant à la même classe d’équivalence:
1- Créer deux classes: A contenant les états finaux et B contenant les états non finaux;
2- S’il existe un symbole x et deux états qi et qj d’une même classe tel que δ(qi, x) et
δ(qj, x) n’appartiennent pas à la même classe, alors créer une nouvelle classe et
séparer qi et qj. On laisse dans la même classe tous les états qui donnent un état
d’arrivée dans la même classe;
3- Recommencer l’étape 2 jusqu’à ce qu’il n’y ait plus de classes à séparer;
Etat a b 1- A={1,2} , B={3,4,5,6}

*1 2 5 2- δ(3,b)=2 A , δ(4,b)=3 B, donc il faut séparer 4 (ou 3) du reste de
Etat a b
la classe B. Alors , on crée une classe C contenant l’état 4 (ou 3).
*2 2 4 *A A C
3- δ(3,b)=2 A, δ(5,b)=6 B, donc il faut séparer 5 de la classe B. On
3 3 2 peut mettre 5 dans la classe C (si C={4}) car δ(5,a)=4 C et B B A
4 5 3 δ(4,a)=5 C et δ(5,b)=6 B et δ(4,b)=3 B. Donc B={3,6} et C={4,5}. C C B
5 4 6 4- Aucun autre changement n’est possible, alors on arrête
l’algorithme. L’automate minimal est donc contient les trois états A
6 6 1 66
(état initial et final), B et C.
Série N°1
Exercice 6
Minimiser l’AFD suivant:
67
Opérations sur les automates
Complément d’un automate:
Soit A=(Q,V,δ,q0,F) un AFDC reconnaissant le langage L. L’automate
reconnaissant le langage inverse (c’est-à-dire L ou V∗−L) est défini par le
quintuplet AC=(Q,V,δ,q0,Q-F) (en d’autres termes, les états finaux
deviennent non finaux et vice-versa).
Exemple:
68
 Automates finis
Opérations sur les automates (suite)
Miroir d’un automate:
Soit A=(Q, V, δ, q0, F) un automate reconnaissant le langage L(A). L’automate qui
reconnaît le langage (L(A))R est définit comme suit: AR=(Q, V, δR, F, {q0}) tel que :
δR(q’,a)=q si δ (q, a)=q’
Remarques
1- Pour définir l’automate AR, il suffit d’inverser les sens des arcs de l’automate
et le statut initial/final des états initiaux et finaux.
2- L’automate AR peut contenir plusieurs états initiaux (ce qui signifie qu’il est le
plus souvent non déterministe). Pour éliminer le problème des multiples états
initiaux, il suffit de rajouter un nouvel état initial et de le raccorder aux anciens
états finaux par des ε-transitions.
69
 Automates finis
Miroir d’un automate: Exemple
Automate non déterministe A Miroir de l’automate A

Rajouter un nouvel état initial et le raccorder aux états 0 et 3 par des ε-transitions
70
 Automates finis
Produit de deux automates:
Soit A=(Q,V,δ,q0,F) et A’=(Q’,V’,δ’,q’0,F’) deux automates à états finis. On appelle
produit des deux automates A et A′ l’automate A"=(Q",V",δ",q"0,F"), défini comme
suit :
Q′′ = Q × Q′; V′′ = V V′; q′′0 = (q0, q′0); F′′ = F × F′; δ"((q, q’),a)=(δ(q, a),δ’(q’, a))
Remarques:
1- Si m est un mot reconnu par A′′ alors il l’est par A et A’.
2- Si L(A) est le langage reconnu par A et L(A′) est le langage reconnu par A′
alors l’automate A′′ reconnaît l’intersection des deux langages : L(A)∩L(A′).
71
 Automates finis
Produit de deux automates: Exemple
Automate (1): reconnaît les mots

sur {a, b, c} contenant deux a Produit de1 et 2
Automate (3): représente le

Automate (2): reconnaît les mots
produit des deux automates
sur {a, b, c} contenant deux b
(1) et (2) 72
Théorème de Kleene
Soient:
EGR l’ensemble des langages réguliers générés par des GR,
EER l’ensemble des langages décrits par toutes les ER,
EAF l’ensemble de tous les langages reconnus par les AF.
Nous avons, alors, l’égalité suivante : EGR = EER = EAF
Le théorème annonce que l’on peut passer d’une représentation à une

autre du fait de l’équivalence entre les trois représentations.
73
Passage de l’AF (D ou N) vers l’ER
Soit A=(Q,V,δ,q0,F) un automate à états fini quelconque.
On note par Li le langage reconnu par l’automate si son état initial était qi.
Par conséquent, trouver le langage reconnu par l’automate revient à
trouver L0 , étant donné que la reconnaissance commence à partir de q0.
L’automate permet d’établir un système d’équations aux langages de la

manière suivante:
- Si δ(qi,a)=qj alors on écrit: Li=aLj
- Si qi F, alors on écrit: Li=ε.
- Si Li=α et Li=β alors on écrit Li= α| β
Il suffit ensuite de résoudre le système en procédant à des substitutions

et en utilisant la règle suivante: La solution de l’équation L= αL|β est le
langage L=α*β. 74
Série N°1
Exercice 7
1- Construisez l’expression régulière qui correspond à l’automate suivant :
75

q1
ε q2
q1
a
q2
AFN(E1) AFN(E2) AFN((E1)+)

AFN(E1)
AFN((E2)*)
AFN(E2)
AFN(E1.E2) 76
AFN(E1|E2)

Passage de l’ER vers l’AFD
La stratégie la plus utilisée consiste à construire tout d’abord

l’automate fini non déterministe (AFN) correspondant à cette
expression régulière, et ensuite convertir l’AFN en automate fini
déterministe (AFD).
77
Série N°1
Exercice 7
2- Convertissez les expressions régulières suivantes en AFN puis en AFD
- 01*
- 00(0|1)*
78
Passage de l’AF (D ou N) vers la GR
Soit A=(Q,V,δ,q0,F) un AF, la grammaire qui génère le langage reconnu
par A est G=(VT,VN,R,S), telle que:
– VT = V ;
– Associer à chaque état de Q un non terminal;
– L’axiome S est le non-terminal associé à l’état initial;
– Soit B le non terminal associé à qi et C le non-terminal associé à qj, si
δ(qi,a)=qj alors la grammaire possède la règle de production: B → aC ;
– Si qi est final et B est le non-terminal associé à qi alors la grammaire
possède la règle de production : B → ε.
79
Série N°1
Exercice 8
1- Trouvez la grammaire régulière générant le langage reconnu par l’automate
suivant:
80
Passage de la GR vers l’AF (D ou N)
GR Normalisée:
soit G=(VT,VN,R,S) une grammaire régulière à droite, elle est dite normalisée si toutes les règles de
production sont de l’une des formes suivantes :
- A → a, A∈ VN, a∈ VT ;
- A → aB, A, B∈ VN, a∈ VT ;
- A → ε, A ∈ VN
Normalisation d’une GR à droite:

1- Pour chaque règle de la forme A → wB (A, B ∈ VN et w ∈ VT* tel que |w|>1, créer un nouveau non-
terminal B′ et éclater la règle en deux : A → aB′ et B′ → uB tel que w = au et a∈VT ;
2- Pour chaque règle de la forme A → w (A ∈ VN et w ∈ VT*) tel que |w| > 1, créer un nouveau non-
terminal B′ et éclater la règle en deux : A→ aB′ et B′→u tel que w=au et a∈VT;
3- Recommencer 1 et 2 jusqu’à ce qu’il n’y ait plus de nouveaux non terminaux ;
4- Pour chaque règle A → B (A, B ∈ VN ) tel que B → β1| β2|...| βn
- Rajouter une règle A → β1| β2|...| βn
- Supprimer la règle A → B
5- Refaire l’étape 4 jusqu’à ce qu’il n’y ait plus de règles de la forme A → B
81
 Automates finis
Passage de la GR vers l’AF (D ou N), (suite)
Soit G=(VT,VN,R,S) une grammaire régulière à droite normalisée, le passage de
G vers l’AF A=(Q,V,δ,q0,F) est trouvé par l’algorithme suivant:
1- V =VT
2- Associer un état à chaque non terminal de VN;
3- L’état initial est associé à l’axiome ;
4- Pour chaque règle de production de la forme A →ε, l’état qA est final ;
5- Pour chaque règle de production de la forme A→x (x VT), alors créer un
nouvel état final qf et une transition partant de qA vers qf avec l’entrée x
6- Pour chaque règle A→xB alors créer une transition partant de qA vers l’état qB
en utilisant l’entrée x ;
Remarques:
1- Si les règles de production A→B ne sont pas supprimées dans l’algorithme de
normalisation, il faut ajouter l’étape suivante:
Pour chaque règle A→B alors créer une ε-transition partant de qA vers l’état qB ;
2- Chercher comment peut-on trouver l’AF si la grammaire est régulière à gauche? 82
Série N°1
Exercice 8
2- Soit la grammaire régulière : G = ({a, b}, {S, T}, {S→aaS|bbS|bT|aT|ε,
T→bT|aT|aaS|bbS}, S). Trouvez l’automate reconnaissant le langage
généré par cette grammaire puis en déduire son expression régulière.
83
Plan
Introduction
Analyse lexicale
Analyse syntaxique
Analyse sémantique
84
 Grammaires hors-contexte
Rappel
Soit G=(VT,VN,R,S) une grammaire quelconque. G est dite hors-contexte

ou de type 2 si toutes les règles de production sont de la forme: x→y tel
que x VN et y (VT VN)∗.
Remarques
- Le langage généré par une GHC est appelé un langage hors-contexte

(ou algébrique).
- La plupart des langages de programmation sont des langages hors-

contextes.
85
Série N°2
Exercice 1
1- Trouver la GHC générant le langage anbn (n≥0).
2- Trouver la GHC générant le langage mmR tel que m (a|b)∗.
3- Trouver la GHC générant le langage 0i1n2n et 0n1n2i, avec n,i > 0.
86
 Grammaires hors-contexte (suite)

Ambiguïté
Une grammaire HC est dite ambiguë si elle peut générer au moins un mot
par plusieurs manières.
En d’autres termes, si l’on peut trouver un mot généré par la grammaire et
possédant au moins deux arbres de dérivation, alors on dit que la
grammaire est ambiguë.
Exemple:
Soit la grammaire G = ({0, 1,+, ,( ,)}, E, {E → E+E|E E|(E)|0|1}, {E}).
Cette grammaire est ambiguë, car le mot 1+1*0 possède deux arbres de
dérivation.
87
 Grammaires hors-contexte (suite)

Lever l’ambiguïté
- Il n’existe pas une méthode générale pour lever l’ambiguïté qui
fonctionne avec toutes les grammaires HC ambiguës;
- Introduire une hypothèse supplémentaire (ce qui va changer la
grammaire) en espérant que le langage généré soit le même.
Exemple
La grammaire G′ = ({0, 1,+, ,( ,)}, {E, T, F}, {E→T+E|T,T→F T|F,
F→(E)|0|1}, {E}) génère le même langage que G (de l’exemple précédent)
mais a l’avantage de ne pas être ambiguë.
88
 Grammaires hors-contextes propres (GHCP)

Définition
Une grammaire hors-contexte G=(VT,VN,R,S) est dite propre si elle vérifie:
– A → u R : S ne figure pas dans u ;
– A → u R : u≠ε ou A=S ;
– A → u R : u  VN;
– Tous les non terminaux sont utiles, c’est-à-dire qu’ils vérifient :
*
• A VN\{S}: A est atteignable depuis S:  ,   (VT  VN \ {S}) : S A
• A VN : A est productif : w VT+: A w
Propriété
Il est toujours possible de trouver une grammaire propre pour toute
grammaire hors-contexte.
89
 Grammaires hors-contextes propres (GHCP), suite

Transformation d’une GHC vers une GHCP
1. Rajouter une nouvelle règle S′ → S tel que S′ est le nouvel axiome ;
2. Éliminer les règles A → ε:
– Calculer l’ensemble E = {A VN {S′}|A→ε} ;
– Pour tout A E, pour toute règle B → αAβ de R
– Rajouter la règle B → αβ
– Enlever les règles A → ε
3. Eliminer les règles A→B:
– Calculer toutes les paires (A, B) telle que A→B
– Pour chaque paire (A, B) trouvée
– Pour chaque règle B → u1|...|un ,rajouter la règle A → u1|...|un
– Enlever toutes les règles A → B
4. Supprimer tous les non-terminaux non-atteignables.
5. Supprimer tous les non-terminaux non-productifs
90
Série N°2
Exercice 2
Soit G une grammaire HC dont les règles de production sont :
S → aSbS|bSaS|ε.
1- Transformer G en GHCP.
91
 Formes Normales de Chomsky (FNC) d’une GHC

Définition
Soit G=(VT,VN,R,S) une grammaire hors-contexte. On dit que G est sous
forme normale de Chomsky si les règles de G sont toutes de l’une des
formes suivantes :
A → BC, A VN, B,C VN \ {S}
A → a, A VN, a VT
S→ε
Propriété
Il est toujours possible de transformer n’importe quelle grammaire hors-
contexte pour qu’elle soit sous la forme normale de Chomsky.
Remarque
Si la grammaire est propre, alors la procédure de transformation sera très
facile. 92
 Formes Normales de Chomsky (FNC) d’une GHC (suite)

Transformation d’une GHC vers sa FNC
On suppose que la grammaire HC a été rendue propre. Donc toutes les
règles sont sous l’une des formes suivantes :
S → ε , A → w avec w VT+ , A → w avec w ((VN\{S})UVT)+
1- La deuxième forme peut être facilement transformée en A → BC. En effet,
si w = au, u VT+ , alors il suffit de remplacer la règle par les trois règles
A → A1A2, A1 → a et A2 → u. Ensuite, il faudra transformer la dernière
règle de manière récursive tant que |u| > 1.
2- Il reste alors à transformer la troisième forme.
Supposons que : w = w1A1w2A2...wnAnwn+1 avec wi VT* et Ai (VN\{S})
- Si w1≠ ε, alors il suffit de transformer cette règle en : A → B1B2 , B1→w1,
B2 → A1w2A2...wnAnwn+1
- Sinon, elle sera transformée en : A → A1B , B → w2A2...wnAnwn+1
- Cette transformation est appliquée de manière récursive jusqu’à ce que
93
toutes les règles soient des règles normalisées.
Série N°2
Exercice 2 (suite)
2- Transformer G, définie dans la question 1, à sa forme normale de
Chomsky.
94
 Formes Normales de Greibach (FNG) d’une GHC

Définition
Soit G=(VT,VN,R,S) une grammaire hors-contexte. On dit que G est sous
forme normale de Greibach si les règles de G sont toutes de l’une des
formes suivantes :
A → aA1A2...An , a VT, Ai VN\{S}
A → a , A VN , a VT
S→ε
Propriété
Il est toujours possible de transformer n’importe quelle grammaire hors-
contexte pour qu’elle soit sous la forme normale de Greibach.
95
 Formes Normales de Greibach (FNG) d’une GHC
Transformation d’une GHC vers sa FNG
Lemme1:
Soient Y→β1|…|βr les règles de Y . Le langage (engendré par la
grammaire) n’est pas changé si la règle X→ αYα’ est remplacée par les
règles X→αβ1α’|…|αβrα’.
Lemme2: (Pour supprimer la récursivité)

Si les règles de X sont:
X→Xα1|…|Xαr
X→β1|…|βs
Le langage (engendré par la grammaire) n’est pas changé si les règles de
X sont remplacées par les règles suivantes :
X→β1|…|βs Y→α1|…|αr X→β1Y|…|βsY

Ou
X→β1Y|…|βsY Y→α1Y|…|αrY Y→α1Y|…|αrY|ε
96
Série N°2
Exercice 3
Soit G une grammaire HC dont les règles de production sont:
S→SSa|b.
Transformer G à sa forme normale de Greibach.
97
 Automate à pile (AP)

Définition
- Le langage L= {anbn/n IN} est non régulier donc n’est pas reconnu par un automate fini
(Voir l’exercice 4 série 1).
- Il existe une grammaire HC qui permet de générer L, donc L est reconnu par un automate de
type 2 ou automate à pile (Voir l’exercice 1 série 2).
- Alors dans ce cas, on peut dire que la pile est une mémoire qui est ajoutée à l’automate
pour compter le nombre de a du début du mot puis de décompter exactement le même
nombre de b.
Un automate à pile possède les différents

éléments d’un reconnaisseur (bande et tête
de lecture, unité de contrôle), sa
particularité est son mode de stockage:
une pile dans laquelle sont stockés des
symboles d’un alphabet particulier appelé
alphabet de pile.
98
 Automate à pile
Définition
Un automate à pile est défini par A=(Q, π, V, δ, Z0, q0, F) où:
- (Q,V,q0,F) sont, respectivement, l’ensemble d’états, l’alphabet, l’état
initiale et l’ensemble d’états finaux.
- π est l’ensemble des symboles utilisés pour écrire dans la pile
(l’alphabet de la pile), c.-à-d. qui peuvent être empilés. Cet alphabet doit
forcément inclure le symbole signifiant que la pile est vide.
- Z0 est le contenu initial de la pile.
- δ est la fonction de transition définie par: δ : Q×(V {ε})×π →Q×(π−{ })
avec δ(qi, a, B) = (qj, C) où B est le sommet de la pile et C indique le
nouveau contenu de la pile.
Remarque
Si la pile est vide au départ, l’AP est défini par A=(Q,π,V,δ,q0,F)
99
Interprétation des transitions
Transition Graphe de transition Signification
q0 a, →B q1 Si l’état est q0, si le symbole lu est a et si la

δ(q0, a, ) = (q1, B )
pile est vide alors passer à l’état q1 et empiler B.
Si l’état est q0, si le symbole lu est a et si le
q0
a, A → BA q1
δ(q0, a, A) = (q1, BA) sommet de la pile est A alors passer à l’état q1 et
empiler B.
ε, A → BA Si l’état est q0, s’il ne reste plus rien à lire et que

δ(q0, ε, A) = (q1, BA) q0 q1 le sommet de la pile est A alors passer à l’état q1
et empiler le symbole B.
δ(q0, a, A) = (q1, A) q0
a, A → A q1 sommet de la pile est A alors passer à l’état q1 et
ne rien faire avec la pile
q0
a, A → ε q1
δ(q0, a, A) = (q1, ε) sommet de la pile est A alors passer à l’état q1 et
dépiler un symbole de la pile.
100
Mode de reconnaissance
Il existe 2 modes de reconnaissance pour les automates à pile:
1- Reconnaissance par état final: Un mot m est accepté par un AP si après
avoir lu tout le mot m, l’automate se trouve dans un état final quelque soit le
contenu de la pile.
2- Reconnaissance sur pile vide: Un mot m est accepté par un AP si après
avoir lu tout le mot m, la pile est vide quelque soit l’état de l’automate.
Remarques:
 Ces deux modes sont équivalents, donc, dans ce qui suit, on accepte un mot si le
ruban vide (après avoir lu tout le mot), on est sur l‘état final et la pile vide
 Un mot m est rejeté par un AP si:
- Aucune transition n’est possible (l’automate n’a pas pu lire tout le mot)
- L’automate se trouve dans un état non final.
- La pile est non vide.
- Une opération incorrecte est menée sur la pile : Dépiler alors que la pile est vide.
101
Exemple
L’automate reconnaissant les mots anbn (avec n ≥ 0) est le suivant : A=({q0,q1,q2,q3}, {A, },
{a,b},δ,q0,{q3}) telle que δ est définie par:
– δ(q0, a, ) = (q1, A )
a, A → AA b, A →ε
– δ(q1, a, A) = (q1, AA)
– δ(q1, b, A) = (q2, ε) q
a, → A q b, A → ε q2 ε, → q
0 1 3
– δ(q2, b, A) = (q2, ε)
ε, →
– δ(q2, ε, ) = (q3, )
– δ(q0, ε, ) = (q3, )
Traitement des mots: aabb, aab, abb et ε

1- Le mot aabb: (q0, a, )→(q1, a, A )→(q1, b, AA )→(q2, b, A )→(q2, ε, ) →(q3, ε, ). Le
mot est reconnu.
2- Le mot aab: (q0, a, ) →(q1, a,A ) →(q1, b,AA ) →(q2, ε,A ). Le mot n’est pas reconnu
car il n’y a plus de transitions possibles alors que l’état de l’automate n’est pas final
3- Le mot abb: (q0, a, ) →(q1, b,A ) →(q2, b, ). Le mot n’est pas reconnu car on n’arrive
pas à lire tout le mot ;
102
4- Le mot ε: (q0, ε, ) →(q3, ε, ). Le mot est reconnu.
 Automate à pile déterministe
Soit l’automate à pile défini par A=(Q,π,V,δ,q0,F) . A est dit déterministe si
qi Q, a (V {ε}), A π, il existe au plus une paire (qj, B) (Q×π∗)

telle que δ(qi, a,A) = (qj, B).
Remarque:
Malheureusement, nous ne pouvons pas transformer tout automate à pile

non déterministe en un automate déterministe
103
 Grammaire hors-contexte vers un automate à pile
Pour tout langage généré par une grammaire hors-contexte, il existe un

automate à pile (déterministe ou non) qui le reconnaît.
Réciproquement, pour tout langage reconnu par un automate à pile, il

existe une grammaire hors-contexte qui le génère.
104
Série N°2
Exercice 4
1- Construire l’automate à pile du langage suivant: mcmR tel que m (a|b)*
2- Construire l’automate à pile du langage suivant: mmR tel que m (a|b)*
105
Plan
Introduction
Analyse lexicale
Analyse syntaxique
Analyse sémantique
106
Analyse lexical
 Définition
À partir du programme source, qui se présente comme un flot de caractères,
l'analyse lexicale permet de reconnaitre des unités lexicales, qui sont les mots
que l'analyseur syntaxique va ensuite les utiliser.
Unité lexicale
Programme Analyseur Analyseur
source lexical syntaxique
Prochaine unité
lexicale?
Table des symboles
Remarques:
1-Les unités lexicales seront stockées au fur et à mesure dans la table de symboles.
2-L’opération du lecture du texte source doit s’accompagner avec des tâches
supplémentaires: Eliminer les blancs, les commentaires, fin de lignes, gérer les
numéros des lignes pour les utiliser dans le cas d’une erreur rencontrée, …..
3-L’analyseur lexical doit signaler chaque présence d’erreur dans le texte d’entrée. 107
Analyse lexical
 Lexème, unité lexicale
Lexème (ou Token): est une chaîne de caractères qui constitue une seule entité
tirée à partir du texte source. Par exemple dans l’instruction suivante:
aire:=base * hauteur / 2, l’analyseur lexical reconnaît les lexèmes suivants
Unité lexicale: est un type de lexème qui est un symbole terminal qui rentre dans
la construction du langage source. Pour l’exemple précédent, on trouve:
Lexèmes Unité lexicale

aire , base , hauteur identificateur
:= op-affectation
*,/ op-arithmétique
108
Analyse lexical
 Modèle
Modèle: Est une règle décrivant les lexèmes qui correspondent à une unité
lexicale particulière. Nous utilisons les expressions régulières ou les automates
finis pour représenter les modèles des unités lexicales.
Exemple:
- Modèle identificateur:
lettre | _ | chiffre
0 1
lettre
109
Série N°3
Exercice 1
1- Ecrire une grammaire pour générer les identificateurs d’un langage comme
Pascal ou C. On considérera qu’un identificateur est valide s’il commence par une
lettre (majuscule ou minuscule) suivi d'un nombre quelconque (éventuellement
aucun) de symboles. Ces symboles sont constitués par des lettres, des chiffres,
et du caractère '_'.
2- Une constante de type chaîne de caractères est délimitée par des apostrophes
et constituée d'un nombre quelconque de caractères. Pour permettre à une
apostrophe de faire partie d'une chaîne de caractères, on double celle-ci.
2-1- Ecrire la grammaire qui permet de générer cette unité lexicale.
2-2- Construire l’automate qui permet de reconnaitre cette unité lexicale.
2-3- Donner quelques lexèmes qui sont définis par cette unité lexicale.
2-4- Trouver des constantes qui ne sont pas reconnues par cette unité
lexicale.
110
Analyse lexical
 Construction de l’analyseur lexical
I- Implémenter tous les modèles (automates) représentants les unités lexicales
du langage traité.
Exemples:
Identificateurs, Mots clés, Nombres, Opérations relationnelles, Opérations
logiques, opérations arithmétiques, …….
II- Traiter le programme source caractère par caractère pour:

- Extraire les lexèmes reconnus par leurs automates et les enregistrer dans
une table des symboles avec d’autres attributs.
- Gérer les erreurs pour les lexèmes non reconnus.
Exemples: Lexèmes Unités lexicales Attributs
x,y identificateur Adresse de x et y: Pour le GC
x:=y+30 Type de x et y: Pour l’AS
:= op-affectation
+ op-arithmétique
111
30 nombre Type: Pour l’AS
Analyse lexical
I-Implémentation des automates
Pour chaque automate représentant une unité lexicale du langage source,
implémenter en java (ou un autre langage) une fonction booléenne portant le
même nom que l’unité lexicale traitée.
Exemple: Automate d’un identificateur
int identificateur()
{
Remplir sa table de transition Tran[ ][ ] à partir de l’automate correspondant.
Remplir sa table F[ ] des états finaux.
if (AFD (Tran, F)) // Fonction d’automate fini déterministe
{
nom:= lexeme;
unlex:= "iden";
return 1
}
else return 0;
} 112
Analyse lexical
I- Implémentation des automates : Fonction AFD
Variables Algorithme
tampon: Un tableau qui contient les Typedef int fonction[100][256];
caractères en provenance du fichier Typedef int ens[100];
source. int AFD (fonction Tran, ens F)
ltampon: C’est la longueur du tampon. {
lexème: Un tableau qui contient les int e=e0; //e0 est l’état initial de l’automate
alphabets d’un lexème à reconnaître. int i= ptrdeb;
ptrdeb et ptrfin: Pointeur de début et de s=tampon[i];
fin d’un lexème (ptrfin ne doit pas while (Tran[e][s]!=-1 && i<ltampon)
dépasser ltampon). {
e=Tran[e][s]; //e est un état de l’automate
lexeme[i-ptrdeb]=s;
i++;
s=tampon[i];
}
If (e F) // si e est un état final
{ ptrfin=ptrdeb=i; return 1};
else return 0; 113
}
Analyse lexical
II- Traitement du programme source
Pour Traiter un programme source, il faut suivre les étapes suivantes:
1- Utiliser le tampon mémoire pour lire le programme source et les deux pointeurs
ptrdeb et ptrfin pour repérer respectivement le début et la fin d’un lexème sur le
tampon.
2- Lire le tampon par une fonction getlex() pour extraire et enregistrer les lexèmes du
langage dans la table des symboles et afficher les erreurs à la fin du traitement de
tous le programme source.
Tampon
Programme getlex()
source
Unité
ptrdeb ptrfin Analyseur lexical Analyseur
lexical Syntaxique
Table des
Afficher les erreurs à symboles 114
la fin du traitement
Analyse lexical
II- Traitement du programme source : Algorithme
Répéter
Copier une partie du programme source dans le tampon.
Répéter
Positionner les pointeurs ptrdeb et ptrfin sur le 1er caractère du prochain lexème.
getlex
Déplacer ptrfin sur le tampon jusqu’à trouver un modèle ou une erreur.

Enregistrer chaque lexème reconnu dans la table des symboles
Enregistrer les erreurs rencontrées.
Jusqu’à la fin du tampon
Jusqu’à la fin du programme source.
Afficher toutes les erreurs enregistrées.
Remarque:
Toutes les instructions du bloc (Répéter….jusqu’à la fin du tampon) peuvent être
implémentées dans une seule fonction getlex().
115
Analyse lexical
II- Traitement du programme source : Fonction getlex()
# define maxtmp 256
char unilex[20] // Un tableau qui va contenir l’identité de l’unité lexicale
// correspondante au prochain lexème lu.
int getlex()
{
if (ptrfin > maxtmp/2)
{ if (liretamp()==0) return -1;} //Pour tester la fin du tampon
if (identificateur())
{ if (motcle(lexeme)) strcpy (unilex, "mot clé");
else strcpy (unilex, "ident"); return 1}
if (oprel())
{strcpy (unilex, "op-rel"); return 1}
……….
printf ("Erreur: symbole incorrect, % c\n", tampon[ptrfin]);
ptrfin++; ptrdeb++ ; return 0;
} 116
Analyse lexical
 Gestionnaire de la table des symboles (GTS)
C’est une structure de données contenant des informations sur chaque lexème
utilisé dans le code source en cours d’analyse. La table de symboles est
considérée comme un intermédiaire entre toutes les phases d’un compilateur
pour échanger les informations sur les lexèmes enregistrés.
Structure de la TS:
typedef struct ptrTS { char nom[20]; // Attribut: Lexème
char unilex[20]; // Attribut: Unité lexicale
int * adr //Attribut: Adresse mémoire sur la valeur du lexème
int taille //Attribut: Taille de la valeur du lexème
……………
type attribut // TS peut contenir d’autres attributs (par exemple: type de lexème, ..)
ptrTS *suc //pointeur sur un autre symbole
} STTS
Remarque:
A chaque fois que l’analyseur lexical rencontre une unité lexicale pour la première
fois, le GTS doit enregistrer les informations (attributs) actuellement disponibles
(nom , unilex). Les autres informations seront enregistrées lors du traitement des
117
autres phases d’analyse.
Analyse lexical
 Erreurs lexicales
Un analyseur lexical doit détecter la présence d’une erreur et la signaler, un bon
analyseur lexical ne doit pas s’arrêter devant la 1ère occurrence d’une erreur
rencontrée.
Exemples:
- Un caractère n’appartient pas à l’alphabet.
- Un commentaire non fermé.
- Un mot clé non terminé
118
Plan
Introduction
Analyse lexicale
Analyse syntaxique
Analyse sémantique
119
Analyse Syntaxique
 Définition
L'analyse syntaxique (ASy) est un processus qui permet de vérifier si les
éléments proviennent de l’analyseur lexical (par getlex()) forment une chaine
d’unité lexicale acceptée par la grammaire du langage .
Oui + Arbre Syntaxique

Analyseur
Suite d’unité
lexicale Syntaxique
Non + Message d’erreur pour aider
à corriger le fichier source
Donc l’objectif de l’ASy est de:

1- Vérifier que le texte d’entrée est conforme à la grammaire.
2- Construire une représentation intermédiaire (arbre syntaxique) pour les autres
modules du compilateur.
3- Indiquer les erreurs de syntaxe et éventuellement de poursuivre l’analyse
après une erreur (reprise sur erreur). 120
Analyse Syntaxique
 Méthode de construction de l’ASy
Il existe fondamentalement deux méthodes pour construire l’ASy:
1- Analyse descendante (top-down):
Construction d’un arbre d’analyse à partir de l’axiome vers les feuilles (chaine
d’entrée) par des dérivation à gauche: On part de l’axiome, puis on essaye les
dérivations (à gauche) successives de chaque non-terminal jusqu’à arriver aux
symboles terminaux de la phrase à analyser (retrouver la chaine d’entrée ou
échec).
Exemple
Grammaire Chaine Reconnaissance

S →ABC ch= abcd S →abBC→abbcC→abbcd Echec
A → ab|a S →abBC→abacC→abacd Echec
B → bc|ac S →aBC→abcC→abcd Succés
C→d
121
Analyse Syntaxique
 Méthode de construction de l’ASy
2- Analyse ascendante (bottom-up):
Construction d’un arbre d’analyse à partir des feuilles (chaine d’entrée) vers
l’axiome par des dérivation à droite: On prend la phrase à analyser (constituée
au départ uniquement de symboles terminaux) et on identifie des parties droites
de règles pour transformer la phrase en chaines de plus en plus constituées par
de non-terminaux jusqu’à arriver à l’axiome.
Exemple
Grammaire Chaine Reconnaissance

S →S+T | T ch= id+id*(id+id) ch→F+F*(F+F)→T+T*(T+T)→S+T*(S+T)
T → T*F | F →S+T*(S) →S+T*F→S+T →S Succé
F → id | (S)
122
Analyse Syntaxique
 Construction d’analyseur syntaxique descendant
Il existe deux algorithmes pour construire l’ASyD:
1- Analyse par descente récursive:

2- Analyse prédictive:
123
Analyse Syntaxique
 Analyse par descente récursive
Pour construire cet analyseur, on peut suivre les étapes suivantes:
1- Associer à chaque non terminal N de la grammaire une fonction

booléenne N() portant le même nom que N.
2- Dans chaque fonction définie précédemment, l’analyseur syntaxique

fait un appel à la fonction getlex() à chaque fois qu’il rencontre un
symbole terminal, ce dernier sera comparé avec le lexème retourné par
la fonction getlex.
124
Analyse Syntaxique
Exemple:
S →ABC int A( ) if(!strcmp (unilex, ‘c’);
A → ab|a { getlex( ); return 1;
B → bc|ac if(!strcmp (unilex, ‘a’) else return 0;
C→d { getlex( ); }
//Construction de l’ASyD if(!strcmp (unilex, ‘b’); if(!strcmp (unilex, ‘a’)
int S( ) { getlex( ); { getlex( );
{ if A( ) if(!strcmp (unilex, ‘c’); if(!strcmp (unilex, ‘c’);
{ if B( ) {ingetlex(); ingetlex();} return 1;
{ if C( ) return 1; else ingetlex(); else return 0;
else return 0; } }
} else ingetlex( ); return 0;
else return 0; return 1; }
} } return 0; int C( )
else return 0; } { getlex( );
} int B( ) if(!strcmp (unilex, ‘d’)
{ getlex( ); return 1;
if(!strcmp (unilex, ‘b’) return 0; 125
{ getlex( ); }
Analyse Syntaxique
Problèmes:
1- L’analyse par descente récursive nécessite un rebroussement (retour
en arrière. Comme par exemple: A→ab|a) ce qui n’est pas toujours facile
à implanter.
2- Le mot abc nécessite aussi plusieurs rebroussements
Solution:
Analyseur prédictif sans rebroussement.
126
Analyse Syntaxique
 Analyse prédictive
L’analyseur prédictif est un analyseur par descente récursive ou non sans
rebroussement (déterministe) qui permet de déterminer laquelle des
alternatives à prendre à partir des productions de la forme:
A → β1|β2| ……|βn .
Principe: Pour chaque symbole d’entrée t donné, l’alternative βi (1≤i≤n) à prendre
est celle qui dérive une chaine commençant par t (appelé symbole de prévision).
L’analyseur prédictif s’appui donc sur la connaissance des premiers symboles qui
peuvent être engendrés par les parties droites des productions.
Pour pouvoir construire un analyseur prédictif sans rebroussement, la

grammaire doit être déterministe ou LL(1) (LL: lecture du texte de
gauche à droite selon des dérivations gauches)
127
Analyse Syntaxique
 Analyse prédictive: First et Follow
Définition
Soit G=(VT,VN,R,S) une grammaire hors-contexte
Soit A→β une production de R. On définit les deux ensembles First(β) (ou
Premier(β)) et Follow(A) (ou Suivant(A)) par:
First(β)={a VT / β aY avec Y (VT VN)* }
Follow(A)={b VT / S XAY et b First(Y) avec X,Y (VT VN)* }.
Remarque:
Les deux ensembles First et Follow peuvent être calculés pour tous les symboles
X avec X (VT VN)+
Exemple
S →ABC ; A → ab|a ; B → bc|ac ; C → d.
First(S)={a} ; First(A)={a} ; First(B)={a,b} ; First(C)= {d}.
Follow(A)={a,b} ; Follow(B)={d} .
Comment calculer Follow(S) et Follow(C)? (Voir l’algorithme qui calcule le Follow) 128
Analyse Syntaxique
 Analyse prédictive: Calcul de First
Soit un symbole X (VT VN)* , pour calculer les firsts de X on applique la fonction
First(X) suivante:
Debut
EnFirst={Ø} // EnFirst est un ensemble qui va contenir les firsts de X
Si X VT alors EnFirst={X}.
Sinon Si X VN alors
{ Si X→ε est une production alors
EnFirst= EnFirst+{ε}
Finsi
Pour toute production X →α tel que α ≠ ε faire
EnFirst= EnFirst+First(α)
Fin pour
}
Sinon Si X=Y1Y2…..Yn alors
{ i=1;
Tant que (ε First(Yi) et i<n) faire
{ EnFirst=EnFirst+(First(Yi)\ {ε}); i++;}
EnFirst=EnFirst+FirstYi;
}
129
Fin
Analyse Syntaxique
 Analyse prédictive: Calcul de Follow
Soit un symbole X (VT VN)* , pour calculer les follows de X on applique la fonction
Follow(X) suivante:
Debut
EnFollow={Ø} // EnFollow est un ensemble qui va contenir les follows de X
Si X=S (avec S est l’axiome) alors
EnFollow=EnFollow+{$}
{ Si A→αXβ est une production alors
EnFollow= EnFollow+ (First(β )\{ε})

Si ε First(β) alors
EnFollow= EnFollow+ Follow(A)
}
Si A→αX est une production alors
EnFollow= EnFollow+ Follow(A)
Fin
130
Série N°3
 Exercice 2
Soit la grammaire G=(VT, VN, R,E) telle que:
VT=(+,*,(,),nbr), VN=(E,T,F,E’,T’) et R=(E→TE’, E’→+TE’, E’→ε, T→FT’,
T’→*FT’, T’→ε, F→(E), F→nbr).
1-Décrire le langage généré par cette grammaire.
2- Calculer les deux ensembles First et Follow pour les éléments de VN .
131
Analyse Syntaxique
 Analyse prédictive: Grammaire LL(1)
Définition
Soit G=(VT,VN,R,S) une grammaire hors-contexte
La grammaire G est de type LL(1) si et seulement si pour toutes les productions
de la forme A → β1|β2| ……|βn :
- i≠j First(βi) ∩ First(βj)=Φ
- Si i tel que βi ε alors Follow(A)∩First(βj)=Φ j (ce cas se produit lorsque A

est dans la partie droite d’une production X →α1Aα2 )
- Si i tel que βi ε alors j≠i , βj ε
Remarque
Le mot LL(k) est l’abréviation de:
L: Left to Right Scaning
L: Left Most Derivation
k: Le nombre des symboles de prévision
132
Analyse Syntaxique
 Analyse prédictive: Grammaire LL(1)
Exemples des grammaires LL(1)
Grammaire Type Raisons

S→a|Ac LL(1) -First(a) ∩ First(Ac)=Φ
A→bAa|c -First(bAa) ∩ First(c)=Φ
S→a|Ac|bS Non LL(1) -First(Ac) ∩ First(bS) ≠Φ

A→bAa|c
S→a|Ac LL(1) -First(a) ∩ First(Ac)=Φ
A→bAa|ε -Follow(A) ∩ First(bAa) =Φ
133
Analyse Syntaxique
 Analyse prédictive: Suppression de la récursivité à gauche
Grammaire récursive à gauche (GRG):
Une grammaire est récursive à gauche si elle contient un non-terminal A telle qu‘il
existe une dérivation A Aα, ou α est une chaîne quelconque.
Une grammaire récursive qui contient les deux règles suivantes: A→Aα|β est non
LL(1) (Démontrer cette propriété)
Transformation d’une GRG en une grammaire LL(1)

- Une grammaire récursive comportant les productions suivantes A→Aα|β peut
être transformée en LL(1) par la technique suivante: A→βA’ , A’ →αA’|ε.
- On peut généraliser cette technique:
Les productions suivantes: A → Aα1|Aα2|…|Aαn|β1|β2| ……|βm peuvent être
remplacées par:
A→β1A’ |β2A’ | ……|βmA’ , A’ →α1A’|α2A’|…|αnA’|ε.
134
Analyse Syntaxique
 Analyse prédictive: Factorisation
Grammaire nécessite une factorisation
On dit qu’une grammaire G nécessite une factorisation à gauche si G
comporte les productions suivantes : A→ αβ1|αβ2 . G est non LL(1)
(Démontrer cette propriété).
Factorisatin de G
- La grammaire G qui comporte les productions A→ αβ1|αβ2 peut être transformée
en LL(1) par factorisation à gauche: A→ α A’ , A’ → β1|β2.
135
Analyse Syntaxique
 Analyse prédictive: Factorisation
Grammaire nécessite une Substitution
On dit qu’une grammaire G nécessite une substitution à gauche si G
comporte les productions suivantes : A→B|C, B→wX|α1, C→wY|α2 . G est
non LL(1) (Démontrer cette propriété).
Substitution de G
- La grammaire G comportant les productions A→B|C, B→wX|α1, C→wY|α2 peut
être transformée en LL(1) par la substitution à gauche: A→wA’|α1|α2 ,A’ →X|Y .
136
Série N°3
 Exercice 3
Soit la grammaire G0 définie par les productions suivantes:
S →aE|bF ; E→bE|ε ; F→aF|aG ; G→Gc|d
1. Montrer que G0 est non LL(1).
2. Ecrire une grammaire G1 non récursive a gauche telle que L(G1) = L(G0).
3. Ecrire une grammaire G2 factorisée a gauche telle que L(G2) = L(G1).
4. Calculer les ensembles First(A) et Follow(A) pour les symboles A non terminaux
de G2, et First() pour les parties droites de règles de G2.
5. Montrer que G2 est de type LL(1).
137

Cours de Compilation F

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours de Compilation F

Transféré par

Droits d'auteur :

Formats disponibles

Université Sidi Mohammed Ecole Nationale des

Ben Abdelah – Fès Sciences Appliquées

Compilation et optimisation du code

Réalisé par: Nabil El akkad

Expression régulière et automates finis

Grammaires hors-contexte et automates à pile

Théorie de langage Phases d’un compilateur

- La fermeture positive de Kleene de L est notée par:

- Le langage miroir de L est donnée par:

Par convention, on utilisera les lettres majuscules pour les non-terminaux,

Remarque: Si l’arbre syntaxique a comme racine S, alors il est dit arbre de

 Théorie de langage (suite)

Automate: Classification de Chomsky

- Automate à états fini: Utilisé pour reconnaitre les langages de type 3.

- Automate à pile: Pour reconnaitre les langages de type 2.

- Automate à bornes linéaires: Pour reconnaitre les langages de type 1.

- Machine de Turing: Pour reconnaitre les langages de type 0.

Un compilateur est décomposé en deux phases principales:

Table des Analyseur sémantique Gestion

lexicales ou lexèmes (Identificateurs, y := a * b + 30

Permet de vérifier les entités en entrée :=

-Procède parfois à des conversions caractère

Permet d’améliorer le code t1←id2*id3

Permet de choisir des emplacements Mov R2, id2

Après avoir détecté une erreur, une phase -Erreurs lexicaux,

- Remplace les macros par leur définition

Compilateur Produit un programme cible en langage

Assembleur Produit un code machine translatable

-Un pg cible peut être constitué de plrs fichiers

Programme source Programme source

Editeur de lien Erreurs

Exemples: Pascal, C, C++,… 32

Code objet Edition de liens Programme

Autres code objet

 Outils pour la construction d’un compilateur

Constructeur d’analyseur syntaxique: Grammaire, automate à pile

Constructeur d’analyseur sémantique: Traduction dirigée par la syntaxe.

Génération de code: Traduction dirigée par la syntaxe, assembleur.

Expression régulière et automates finis

Grammaires hors-contexte et automates à pile

– L’expression régulière ε dénote le langage vide (L = {ε}) ;

3- L’expression 0*110*1 est la concaténation des deux expressions 1 et 2

4- L’expression 0*|110*1 décrit l’expression des mots générées soit par

1- Opérateur unaire + : au moins une fois : E+= EE* .

2- Opérateur unaire ? : 0 ou 1 fois: E? = E|ε.

3- Priorité des opérateurs: * , +, concaténation , |

Il existe donc au moins deux façons pour faire correspondre abaab à

On peut décider que le facteur fixe soit le premier « a » du mot à

2- L’union finie de langages réguliers représente un langage régulier.

3- L’union infinie de langages réguliers peut ou non être un langage

1. L’ensemble des mots composés d’un nombre arbitraire de 1, suivis de 01,

suivis d’un nombre arbitraire de 0.

2. L’ensemble des nombres binaires impairs.

- Toutes les chaînes qui se terminent par 00.

- Toutes les chaînes dont le 10ème symbole, compté à partir de la fin de la

Soit L un langage régulier défini sur l’alphabet Ω. Il existe alors un entier n

– xyiz L pour tout i ≥ 0.

1- Montrer que le langage régulier akbl vérifie les critères de pompe.

2- Montrer que le langage anbn n’est pas régulier.

- Q est un ensemble d‘états.

Exemple: Soit le langage L = {akbr/ k≥0 et r >0}

→ q0 q0 q1 → : désigne l’état initial

* q1 - q1 * : désigne l’état final

3- L’expression 01101 est la concaténation des deux expressions 1 et 2

4- L’expression 0|1101 décrit l’expression des mots générées soit par