Compilation 2

COMPILATION
Samir MBARKI
Département d’Informatique, Faculté des Sciences, KENITRA
Année Universitaire : 2014-2015
S. MBARKI Compilation 2014-2015 1 / 184

Sommaire
1 Introduction à la compilation
2 Analyse lexicale
3 Analyse syntaxique
4 Analyse sémantique
5 Séries d’exercies

Sommaire
Pourquoi étudier la compilation ?
Définition de Compilateur/Interpréteur
Traitement effectué par un compilateur
Phases d’un compilateur
2 Analyse lexicale

Introduction à la compilation
Pourquoi étudier la compilation ?
Pour mieux comprendre les erreurs de compilation.

Pour mieux comprendre le fonctionnement d’un compilateur.
Les algorithmes et les outils de compilations sont repris dans d’autres
domaines informatiques :
I Traitement automatique des langages naturels (TALN).
I Parser des documents (.XML).
I GED (Gestion éléctronique de documents).
Analyse lexicale : Scanner Analyse syntaxique : Parser

Rôle du compilateur
Comment l’utilisateur communique avec l’ordinateur ?

Compilateur/Interpréteur

Définition de compilateur
Définition
Le compilateur est un programme (fonction) qui prend en entrée un
programme écrit dans un langage L1 et produit en sortie un programme
équivalent écrit dans un langage L2.
Exemple : C, C++, Java, ...

Définition d’interpréteur
Définition
L’ interpéteur est un programme (fonction) qui prend en entrée un programme
écrit dans un langage source L1 et produit en sortie le résultat d’exécution de
ce programme.
Exemple : Shell Unix, VB, PL/SQL, ...

Traitement effectué par un compilateur
Exemple

Phases d’un compilateur
Exercice
Ecrire un programme qui affiche les statistiques d’un fichier texte en comptant
le nombre de mots, d’entiers, de réels et le nombre de caractères de
ponctuation.
Analyse lexicale
Le flot de caractères est lu de gauche à droite.

Les caractères formant un sens sont groupés en unités lexicales (Tokens).
Les séparateurs (espace, tabulation, retour à la ligne) sont supprimés.
Les commentaires sont ignorés.
L’analyseur lexical doit déterminer si chaque lexème (mot) est connu.
Une unité lexicale est une suite de caractères ayant une signification
collective.

Analyse lexicale
Exemple
Soit l’instruction : Surf := base * hauteur / 2
Les unités lexicales sont :

<Identificateur> Surf
<Affectation>
<Identificateur> base
<Mult>
<Identificateur> hauteur
<Divis>
<Nombre> 2
Analyse syntaxique
L’unité syntaxique constitue l’arbre syntaxique.

Appliquer la grammaire du langage source pour vérifier la syntaxe du
programme source.
La grammaire du langage source est formé par un ensemble de règle de
production.

Analyse syntaxique
Exemple
<Identificateur> <Affectation> <Identificateur> <Mult> <Identificateur>
<Divis><Nombre>

Analyse sémantique
Vérifie si le programme source contient des erreurs sémantiques.

Collecte des informations de type pour la génération de code cible.
Parmi les tâches de l’analyseur sémantique :
I Vérification de type.
I Vérification des incompatibilités de types.
I Conversion implicite de type.
Exemple
conversion implicite de type :
2 → 2.0

Sommaire
2 Analyse lexicale
Introduction et spécification
Concepts et outils
L’outil Flex

Analyse lexicale
I- Introduction et spécification
L’analyseur lexical (Scanner) fusionne les caractères lus dans le code source
en groupes de mots qui forment logiquement des unités lexicales (tokens) du
langage.

Analyse lexicale
Interaction avec les autres modules

Analyse lexicale
Terminologie
Trois termes majeurs sont utilisés en analyse lexicale :

I Unité lexicale : un couple constitué d’un nom d’unité lexicale et d’une
valeur d’attribut optionnelle (facultatif).
I Motif : est une description de la forme que les lexèmes d’une unité lexicale
peuvent prendre. Il peut être simple ou complexe.
I Lexème : est une séquence de caractères dans le programme source qui
est reconnue par le motif d’une unité lexicale.
Exemple

Analyse lexicale
Terminologie
Exemple
Symboles (Unités lexicales) :
I Identificateur, Chaine, Constante numérique.
I Mot-clé (IF, WHILE, DO, ...)
I Opérateur (symbole spéciale) : <, >=,<=, ==, =, ...
Analyser les phrases suivantes :
I A+15+B => A, +, 15, B
I test+3148 => test, +, 3148

Analyse lexicale
Terminologie
Input de l’analyseur lexical : WHILE A>3*B DO A<A-1 END

Output de l’analyseur lexical :
Une variable C de tye couleur qui peut prendre les valeurs :

VERT, BLEU, ROUGE, JAUNE. Affecter à la variable la valeur rouge.
typedef enum {VERT, BLEU, ROUGE, JAUNE} couleur;

couleur C;
C = ROUGE; //C=2
Analyse lexicale
Terminologie
Question
Comment définir formellement les symboles d’un langage ?
Réponse
Les meilleurs modèles définissant les unités lexicales auxquelles
appartiennent les lexèmes sont les langages réguliers.
Il existe deux façons de décrire les langages réguliers :
I Les expressions régulières
I Les automates finis

Analyse lexicale
Concepts et outils
Alphabet :
On appelle alphabet Σ un ensemble fini non vide.
Les elements de l’alphabet s’appellent symboles.
Exemple
Σ = {a, b, ..., z}
Σ = {α, β, ..., ϕ, +, ∗, −, /}
Mot :
Un mot est une suite de symboles appartenant à un alphabet Σ.
Exemple
Sur l’alphabet Σ = {0, 1}, on peut construire les mots : 101001, 11, 100.
ε est le mot vide.
La concaténation de deux mots est un mot.
Analyse lexicale
Langage formel
Exemple (suite)
Soit Σ = {0, 1}, si α = 100 et β = 1010 alors αβ = 1001010.
α2 = αα = 100100
α3 = ααα = 100100100
Langage formel :
Un langage sur un alphabet Σ est un ensemble de mots construits sur Σ.
Exemple
Σ∗ est l’ensemble de tous les mots construits sur Σ.
Remarque
Un langage construit sur un alphabet Σ est une partie de Σ∗ .
On distingue deux langages particuliers : ∅, Σ.

Analyse lexicale
Exemple de langages
Exemple de langages
soit Σ={a, .., z}
L0 = {a}.
L1 = {aa, ab}.
L2 = {αaα/α ∈ Σ∗ } = {a, bab, cdacd, ...}.
L3 = {α ∈ Σ∗ /|α|a <= 10} : l’ensemble de tous les mots dont le nombre
d’occurences de a <= 10.
|.|x ∈Σ : Σ∗ →IN , |.|x calcule le nombre d’occurences de x dans un mot.

Analyse lexicale
Opérations sur les langages formels
L’union.
L2 = {x / x ∈ L1 ou x ∈ L2}
S
I L1
L’intersection.
L2 = {x / x ∈ L1 et x ∈ L2}
T
I L1
La différence.
I L1 - L2 = {x / x ∈ L1 et x ∈
/ L2}
I ¯ =Σ∗ − L1
L1
La concaténation.
I L1L2 = {xy / x ∈ L1 et y ∈ L2}
I Ln = LL.....L
| {z }
n fois
I L1={a, b, c} ; L2={1, 2}
I L1L2={a1, a2, b1, b2, c1, c2}
I L2L1={1a, 1b, 1c, 2a, 2b, 2c}
Analyse lexicale
Fermeture de Kleene
Soit L un langage :
L∗ = K >=0 Lk
S
Exemple
L1={a, b}
L∗1 =L01 L11 L12 L13 ...
S S S S
={ε, a, b, aa, ab, ba, bb, ...}
L+ est appelé fermeture de Kleene positive de L : L+ =L∗ -{ε}

Proposition.
Les identités suivantes sont vraies pour tous les langages (X, Y, Z) :
X(YZ)=(XY)Z
Xε=εX=X
S S
X(Y Z)=XY XZ
S S
(X Y)Z=XZ YZ
(X ∗ )∗ = X ∗
Analyse lexicale
Langages réguliers
Définition
Un langage régulier L sur un alphabet Σ est défini récursivement comme suit :
{ε} est un langage régulier sur Σ.
Soit a ∈ Σ alors {a} est un langage régulier sur Σ .
Si R est un langage régulier, alors R k et R ∗ sont des langages réguliers
sur Σ .
S
Si R1 et R2 sont deux langages réguliers alors R1 R2 et R1 R2 sont des
langages réguliers.

Analyse lexicale
Les expressions régulières (ER)
Soit Σ un alphabet, les expressions régulières et les langages qu’ils décrivent

sont défini comme suit :
Soit a ∈ Σ, alors a est une ER qui décrit le langage {a} .
ε est une ER qui décrit le langage {ε} .
Si α et β sont deux ER décrivant les langages A et B alors : α + β ( α | β)
S
est une ER qui décrit le langage A B .
- αβ est une ER qui décrit le langage AB.
- α∗ est une ER qui décrit le langage A∗ .

Analyse lexicale
Les expressions régulières (ER)
Exemple d’ER
Numérique : (0|1|2|...9)
Alphabétique : (a|b|c|...|z|A|...Z)
Opérateur : (<|>|<>|=|<=|>=)
Naturel : Numérique+ ou NumériqueNumérique∗
Entier : (+|-|ε)Naturel
Identificateur : Alphabétique ( Alphabétique|Numérique)∗

Analyse lexicale
Exercices
Exercice 1
Donner les expressions régulières qui décrivent :
1 Le langage de mots sur Σ={a, b} qui commencent par a est se terminent
par b.
2 Le langage de tous les mots sur {a, b} concaténés avec les mots sur {c, d}.
ab, aab, abb, aaab, abab, abababbab, ε, a, b, c,d,ac,abc, abcd,
ababcdcdc.
Réponse :
a(a|b)∗ b
(a|b)∗ (c |d )∗

Analyse lexicale
Exercices
Exercice 2
1 Est ce que le mot w appartient au langage décrit par l’ER r dans les cas
suivants :
- w= 10100010 r =(0 + 10)∗
- w= 01110110 r =(0 + (11)∗ )∗
- w= 000111100 r =((011 + 11)∗ (00)∗ )∗
2 Simplifier les ER suivantes :
- ε + ab + ab + abab(ab)∗
- aa(b∗ + a) + a(ab∗ + aa)
-a(a + b)∗ + aa(a + b)∗ + aaa(a + b)∗

Analyse lexicale
Exercices
Réponses
ε + ab + abab(ab)∗
= ε + ab + ab(ab)∗
= ε + ab(ε + (ab)∗ )
= ε + ab(ab)∗
= ε + (ab)∗
= (ab)∗
aa(b∗ + a)+ a(ab∗ + aa)
= aa(b∗ + a)+ aa(b∗ + a)
= aa(b∗ + a)
a(a + b)∗ + aa(a + b)∗ + aaa(a + b)∗
= (a + aa + aaa)(a + b)∗

Analyse lexicale
Exercices
Exercice 3
1 Montrer les égalités suivantes :
- b + ab∗ + aa∗ b+ aa∗ ab∗ = a∗ (b + ab∗ )
- a∗ (b + ab∗ ) = b + aa∗ b∗
2 Donner une expression r du langage formé sur {a,b} ayant au plus 3a.

Analyse lexicale
Exercices
Réponses
1 Vérification
- b + ab∗ + aa∗ b+ aa∗ ab∗ = a∗ (b + ab∗ )
=> (b + ab∗ ) + a+ (b + ab∗ )
=(ε + a+ )(b + ab∗ )= a∗ (b + ab∗ )
- a∗ (b + ab∗ )
= a∗ b + a∗ ab∗
= (ε + a + ) + a + b ∗
= b + a+ b + a+ b ∗
= b + a+ (b+b∗ )
= b + a+ b ∗
= b + aa∗ b
2 b∗ (a + ε)b∗ (a + ε)b∗ (a + ε)b∗

Analyse lexicale
Introduction aux automates
Exemple : Introduction aux automates

Un distributeur de café délivre une tasse de café moyennant la somme de 3
DH. Ce distributeur accepte les pièces de 1 DH et 2 DH mais ne rend pas la
monnaie. Un bouton C permet d’obtenir un café. Au début, le bouton C est
bloqué. Si on met assez de pièces, le bouton C se libère et on ne peut pas
insérer de pièces.
Modéliser le fonctionnement du distributeur.
Automate :
Etat initiale e0 : bouton bloqué
Etat e1 : quand on insère 1DH
Etat e2 : quand on insère 2DH
Etat e3 : bouton C se libère

Analyse lexicale
Introduction aux automates
→ : état initial
: état final

Analyse lexicale
Automate fini déterministe
Un automate lit un mot écrit sur son ruban d’entrée. Il part d’un état initial et à
chaque lettre lue, il change d’état. Si à la fin du mot, il est dans un état final, on
dit qu’il accepte le mot.
Mot appartient au langage → dernier état est un état final.

Mot n’appartient pas au langage → sinon.
Automate fini déterministe (AFD)
Définition
Un AFD A est définit comme un 5-uplet A=<Q, Σ, δ, q0 , F> : Q est l’ensemble
des états, Σ est un alphabet, δ : Q×Σ →Q est la fonction de transition, q0 est
l’état initial (q0 ∈ Q), F est l’ensemble des états finaux (F ⊆ Q) .
Les automates peuvent être représentés par des graphes où les états sont les
noeuds et les arcs représentent la fonction de transition.
Analyse lexicale
Automate fini déterministe
: état initial : état final
Si δ (q0 , a)=q1 ⇒
Exercice
Représenter graphiquement l’automate suivant :
A=<Q, Σ, δ, q0 , F> avec Σ={0, 1} et Q={q0 , q1 } q0 est l’état initial et F={q1 }

Analyse lexicale
Langage accepté par AFD
On dit qu’un automate A=<Q, Σ, δ, q0 , F> accepte un mot x=x1 x2 ...xn , si

et seulement si δ(...δ(δ(δ(q0 , x1 ), x2 ), x3 )...), xn ) ∈ F .
Exemple de vérification
I 11111 (Oui)
δ(δ(δ(δ(δ(q0 , 1), 1), 1), 1), 1) ∈ F
I 10010 (Non)
δ(δ(δ(δ(δ(q0 , 1), 0), 0), 1), 0) ∈
/F

Analyse lexicale
Automate fini non déterministe (AFN)
Il est difficile de passer directement d’une ER à un AFD.

Il est facile de passer directement d’une ER à un AFN.
Définition
Un AFN A=<Q, Σ, δ, q0 , F>, se caractérise par :
δ : QX (Σ {ε})− > P (Q )
S
P({a, b, c})={∅ , {a}, {b}, {c}, {a,b}, {a,c}, {b,c}, {a,b,c}}

Plusieur arcs, reconnaissent le même symbole, peuvent sortir du même
état.
Il peut y avoir des ε-transition.

Analyse lexicale
Automate fini non déterministe (AFN)
Exemple
Représenter graphiquement l’AFN suivant :
A=<Q, Σ, δ, q0 , F> avec Σ={0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, +, -, .} et
Q={q0 , q1 , q2 , q3 , q4 , q5 } q0 est l’état initial et F={q5 }

Analyse lexicale
Transformation d’un AFN en AFD
Deux cas sont possibles :

AFN sans ε- transitions
AFN avec ε- transitions
Cas d’un AFN sans ε- transitions :
Soit AN = <QN , ΣN , δN ,qN0 , FN > est un AFN sans ε- transitions, il existe un
AFD, AD = < QD , ΣD ,δD , qD0 , FD > tel que :
L(AN )= L(AD ) (Les 2 automates acceptent le même langage).
QD ⊆ P (QN ) (Un état de QD est un sous ensemble de QN ).
ΣD = ΣN (Les deux automates ont le même alphabet).
qD0 = {qN0 } (L’AFD est formé de l’état initial de l’automate non
déterministe)
FD = {q ∈ QD /q FN 6= ∅} (Un état final de AFD doit contenir au moins
T
un état final de l’AFN).

δD (q ∈ QD , a ∈ ΣD ) = qN ∈q δN (qN , a)
S
D

Analyse lexicale
Exemple
Transformer en AFD l’automate suivant :
ΣD = { 0,1} ; qD0 = {q0 }
S
δD ({q0 ,q2 }, 1) =δN (q0 , 1) δN (q2 , 1)
S
={q0 } ∅

Analyse lexicale
Cas d’un AFN avec ε- transitions :

Définition de ε-fermeture :
ε-fermeture : Q −→ P(Q) tel que :
1 q ∈ ε-fermeture(q)
2 Si q1 ∈ δ(q , ε) alors q1 ∈ ε-fermeture(q)
3 Si q1 ∈ ε-fermeture(q) et q2 ∈ ε-fermeture(q1 ) alors q2 ∈ ε-fermeture(q)
Remarque
Si Q’ ⊂ Q : ε-fermeture(Q’) =
S
q ∈Q 0 ε-fermeture(q)
ε-fermeture d’un état q est l’ensemble de tous les états accessibles à
partir de q par des ε- transitions.

Analyse lexicale
Exemple de ε-fermeture
ε-fermeture(q0 ) ={q0 ,q1 } ; ε-fermeture(q1 ) = {q1 }

ε-fermeture(q2 ) = {q2 } ; ε-fermeture(q3 )= {q3 ,q5 }
ε-fermeture(q4 ) = {q4 } ; ε-fermeture(q5 )= {q5 }
ε-fermeture({q0 ,q3 })= ε-fermeture(q0 ) ε-fermeture(q3 )={q0 ,q1 } ∪ {q3 ,q5 }
S
= {q0 ,q1 ,q3 ,q5 }

Analyse lexicale
Algorithme de transformation
Soit AE = <QE , ΣE , δE ,qE0 , FE > un ε-AFN, il existe un AFD AD = <QD , ΣD ,
δD ,qD0 , FD > tel que L(AE )= L(AD ) avec :
QD ⊆ ε-fermeture(P(QE ))
Σ D =Σ E
qD0 = ε-fermeture( qE0 )
FD = {qD ∈ QD tq : qD FE 6= ∅}
T
Soit qD ∈ QD et a∈ ΣD alors :
S
δD (qD , a)= ε-fermeture( qE ∈qD δE (qE , a))

Analyse lexicale
Exemple de transformation

Analyse lexicale
Exemple (Représentation graphique de l’AFD obtenu)

Analyse lexicale
Exercice :Transformer l’automate suivant en AFD.

Analyse lexicale
Minimiser un AFD
But : Obtenir un automate ayant le minimum d’états possibles.

Démarche : regrouper les états équivalents de l’automate.
Deux états p,q de A sont dits équivalents si et seulement si :
∀w ∈ Σ∗ tq δ(p,w) est un état final ⇔ δ(q,w) est un état final
1 w = ε, si p ∈ F et q ∈
/ F alors p et q sont distinguables (non équivalents)
2 w 6= ε, (δ(p,w)=r et δ(q,w)=s) et (r et s sont distinguables) alors p et q sont
distinguables

Analyse lexicale
Algorithme de minimisation
Donnée :
un automate déterministe
Résultat :
L’automate minimal reconnaissant le même langage que l’automate initial
Principe général :
l’algorithme calcule les classes d’équivalences.
Après examen de tous les symboles, un bilan est fait : il consiste à
attribuer un numéro (en chiffre romain) à chaque classe d’équivalence.

Analyse lexicale
Algorithme
Construire un tableau dont les colonnes sont les différents états de
l’automate de départ.
La première ligne de bilan s’obtient en séparant (par ε) les états finaux et
les autres en deux classes.
I Numéroter I l’état de la première colonne ;
I Numéroter I ou II les états des autres colonnes de manière à séparer les
états finaux des autres états.
Les lignes suivantes du tableau sont construites une par une en
regardant, pour chaque état, dans quel état mène la transition par un
symbole de l’alphabet et en notant la classe à laquelle appartient cet état
dans la ligne bilan précédente.

Analyse lexicale
Un nouveau bilan est effectué qui prend en compte le bilan précédent et

toutes les lignes que l’on vient de calculer. Les classes sont numérotées
en chiffres romains à partir de la gauche.
On répète les deux opérations qui précèdent jusqu’à obtenir deux lignes
de bilan successives identiques.
Les états de l’automate minimal sont les classes de la dernière ligne de
bilan.
Les transitions se trouvent dans le tableau entre l’avant-dernière et la
dernière ligne de bilan.
L’état de départ est la classe contenant l’état de départ de l’automate
déterministe.
Les états finaux sont les classes contenant des états finaux de l’automate
initial.

Analyse lexicale
Exemple
On s’arrête car on a deux fois le même bilan.

Analyse lexicale
Exemple

Analyse lexicale
Exercice : Minimiser un AFD

Analyse lexicale
Equivalence des automates finis aux expressions régulières
Théorème
Un langage est régulier si et seulement s’il est généré par un automate fini.

Analyse lexicale
Construction d’un AFN à partir d’une ER
Il s’agit de la construction de Thompson basée sur la récursivité des ER.

On suppose que A et B sont les AFN des ER R1 et R2.

Analyse lexicale
D’après ce qui précède, toute expression régulière est reconnue par un

automate.
Exemple
Soit l’expression régulière (a + b)∗ ab, l’automate associé est :

Analyse lexicale
L’automate ainsi obtenu est non déterministe et il possède beaucoup de

ε-transitions.
En déteminisant, et en minimisant on obtient :

Analyse lexicale
Détermination du langage accepté par un automate fini
Méthode de Kleene :
Soit A= <Σ, Q , q0 , F , δ> un automate fini non déterministe ne contenant pas
d’ε-transitions.
Pour tout état q , notons Xq l’ensemble des mots menant de l’état q à un
état final.
Chaque langage Xq satisfait l’équation linéaire
Xq = Σoù q 0 =δ(q ,a) aXq 0 [+ε si q ∈ F ]
Pour obtenir une expression régulière du langage, il suffit de résoudre le
système des équations linéaires ci-dessus par élimination de variables
Toutes les équations qu’on manipule peuvent être mises sous la forme
Xq = KXq + L où K et L sont des expressions linéaires des variables Xq 0 ,
q’ 6= q ;

Analyse lexicale
Lemme d’Arden
Soient X, K et L des langages sur un alphabet Σ. On suppose que ε∈
/ K. Alors
S
X=KX L si et seulement si X=K L ∗
K peut être le langage vide (si le membre droit de l’équation ne contient

pas la variable Xq ), mais il ne contient pas le mot vide (car l’automate ne
possède pas d’ε- transitions)
D’après le lemme d’Arden, l’équation est équivaut à Xq =K*L.
En remplaçant Xq par K*L dans les autres équations, on obtient encore
un système d’équations linéaires, équivalent au système d’origine.

Analyse lexicale
Exemple
Soit L le langage reconnu par l’automate suivant :
Le
 système d’équations linéaires associé à cet automate est :
 X1 = bX1 + (a + b)X2 (1)
X2 = aX3 + ε (2)
X3 = (a + b)X2 + ε (3)


Analyse lexicale
On peut éliminer X3 dans l’équation (2), en remplaçant X3 par (a+b)X2 +ε :

on obtient
X2 = a((a + b)X2 + ε) + ε = a(a + b)X2 + (a + ε)
Ce qui est équivaut (d’après le lemme d’Arden) à :
X2 = (a(a + b)) ∗ (a + ε)
On peut maintenant éliminer X2 dans l’équation (3) :
X3 = (a + b)(a(a + b)) ∗ (a + ε) + ε
Ainsi que dans l’équation (1) :
X1 = bX1 + (a + b)(a(a + b)) ∗ (a + ε)
D’o d’aprés le lemme d’Arden X1 = b ∗ (a + b)(a(a + b)) ∗ (a + ε)
Le langage reconnu par l’automate est alors :
X1 = b ∗ (a + b)(a(a + b)) ∗ (a + ε)

Analyse lexicale
L’outil Flex
A quoi sert Flex ?

I Flex (Fast Lex) est un générateur automatique d’analyseurs lexicaux.
I Le résultat fournit par Flex est un fichier C qui contient le code de
l’analyseur lexical.
Forme générale d’une application Flex :

I On crée un fichier avec l’extension .l.
I Le fichier source Flex contient les diverses spécifications en terme
d’expressions régulières et les actions correspondantes en code C.
On compile le fichier source par la commande "flex".

I Cela génère un fichier qui contient le code C de l’analyseur lexical.
I Ce fichier porte le nom "lex.yy.c".

Analyse lexicale
L’outil Flex

Analyse lexicale
Format d’un fichier Flex
La structure générale d’un fichier Flex est la suivante :
Seul le premier "%%" est obligatoire

Analyse lexicale
Section des définitions
La section définition se compose de :

I Un bloc littéral :
• Définitions et déclarations globales.
• Commence par "%{" et se termine par "%}".
• Les symboles "%{" et "%}" doivent être placés en début de ligne.
• Le bloc littéral contient des déclarations et des définitions en C qui seront
globales au programme produit par Flex.
• Le contenu du bloc littéral est copié tel quel dans le fichier lex.yy.c.
I Des définitions :
• On peut nommer des expressions régulières en utilisant des définitions.
I Des conditions de départ :
• Permettent de définir plusieurs états de Flex.

Analyse lexicale
Section règles et sous-programmes utilisateurs
Section des règles :

I Une règle se compose d’une partie gauche et une partie droite.
I La partie gauche d’une règle est soit :
• Une spécification des expressions régulières reconnues.
• Une chaîne de lettres ou de chiffres (avec ou sans guillemets).
• Un identificateur d’expressions mis entre accolades.
I La partie droite d’une règle contient des actions exécutées lorsque des
unités lexicales sont reconnues.
Section des sous-programmes utilisateurs :

I Permet de définir des fonctions et des procédures C dans les actions des
règles.
I Permet également de définir le programme principal (si nécessaire).

Analyse lexicale
Définition des expressions régulières dans Flex
Les méta-symboles :
I Les symboles suivants ont une signification précise pour Flex :
• " \ [ ] ∧ -? . * + | ( ) $ / { } % < >
I Pour introduire un de ces symboles dans un motif comme caractère du
texte, il faut soit le précéder par un caractère \, soit l’encadrer de ".
I On utilise la notation du C : "\n" pour le retour à la ligne et "\t" pour le
caractère tabulation.
Définitions des méta-symboles :
I [xyz] : correspond à un seul caractère parmi ceux indiqués.
• Exemple : [aeiouy] spécifier une voyelle.

I ? : indique que le caractère précédent est optionnel.
• Exemple : a ?[bc] spécifier ab, ac, b ou c.
I * : indique une répétition 0, 1, ..., n fois du caractère précédent.
I + : indique une répétition 1, 2 ..., n fois du caractère précédent.
I | : indique une alternative
• Exemple : ac|b signifie ac ou bien b.
Analyse lexicale
Définition des expressions régulières dans Flex
Définitions des méta-symboles :

I ( ) : indiquent la portée d’opérateurs comme +, * et ?.
• Exemple : (ac|b)+.
I x/y : correspond à x s’il est suivi de y (y ne fait pas partie du motif).
• Exemple : [a/b] signifie que a est considéré s’il est suivi immédiatement par
un b.
I {macro} : correspond à l’expansion de la macro désignée entre les
accolades { }.
I x{m,n} : Correspond à m jusqu’à n occurrences de x.
• Exemple : (a|b){3,7} spécifie tous les mots sur {a, b} de longueur comprise
entre 3 et 7.
I . : N’importe quel caractère.
• Exemple : .{3} n’importe quel mot de longueur 3.
I - : correspond à un intervalle de caractères.
• Exemple : [a-z] spécifie les lettres minuscules.
Analyse lexicale
Méta-symboles de Flex
Les opérateurs :
I ∧ : placé en début du motif, indique que le motif doit se trouver en début de
ligne.
• Exemple : [∧a] signifie que la ligne doit commencer par a.
I $ : placé en fin du motif, indique que le motif doit se trouver en fin de ligne.
• Exemple : [a$] signifie que la ligne doit se terminer par a.

Analyse lexicale
Les actions
L’action par défaut de tout programme Flex est de recopier tous les
caractères qui ne correspondent à aucun motif dans le fichier de
description.
D’autres actions prédéfinies peuvent être utilisés dans les actions :
I ; : sert à ne pas recopier les caractères non reconnus.
I ECHO ; : sert à recopier les caractères reconnus.
I | : sert à reporter l’action sur la règle suivante. Elle signifie la même chose
que l’action pour la règle suivante.
exemple
Un programme Flex qui élimine tous les caractères blancs (sauf \n) et
imprime les chiffres et les lettres majuscules.
%%
[0-9] | [A-Z] |
\n ECHO ; . ;
Analyse lexicale
Variables globales et sous-programmes
Pour le traitement des actions un peu complexes, Flex fournit plusieurs

variables globales.
I Parmi ces variables, on trouve :
• char * yytext : conserve le texte de l’unité lexicale courante.
• int yyleng : conserve la longueur de l’unité lexicale courante.
• FILE * yyin : est le fichier à partir duquel Flex lit par défaut.
• FILE * yyout : est le fichier dans lequel les actions ECHO sont effectuées par
défaut.
Flex fournit plusieurs fonctions (sous-programmes) :

I yymore() : indique au scanner que la prochaine fois qu’il reconnaît une
règle, l’unité lexicale correspondante devra être concaténée à la valeur
actuelle de yytext au lieu de le remplacer.
I yylex() : cette fonction est utilisée par l’analyseur syntaxique pour appeler
le module de l’analyse lexicale.

Analyse lexicale
Ambiguités des actions
Deux règles sont ambiguës si elles peuvent être déclenchées avec une
même entrée.
Flex utilise une résolution d’ambiguïté qui est la suivante :
I La règle qui correspond à la plus longue entrée est appliquée en priorité.
I Si deux règles ambiguës correspondent à la même entrée, la première
définie est appliquée en priorité.
exemple
%%
algo printf("mot clé") ;
[a-z]+ printf("identificateur") ;
La chaîne algorithme est reconnue comme identificateur.

Analyse lexicale
Exercices
1 Ecrire un programme qui analyse un texte et réaffiche les lignes qui

commencent par S ou que se terminent par S.
2 Ecrire un programme qui réaffiche les lignes d’un texte précédés de leurs
numéros de lignes
3 Ecrire un programme qui analyse un texte et réaffiche les lignes qui
commencent par S et se terminent par S contenant d’autre caractères
autre que S
4 Ecrire un programme qui analyse un texte et remplace les minuscules par
les majuscules sauf dans les commentaires C

Sommaire
2 Analyse lexicale
Introduction
Définition de grammaire formelle
Vocabulaire et notation
Analyse descendante
Analyse ascendante
L’outil Bison

Analyse syntaxique
Exemple de langage non régulier
Exemple
Définir une ER qui décrit le langage suivant :
L={an bn /n > 0}
Propositions :
(ab)∗ => contient ε
aa∗ bb∗ <=> a+ b+ => le nombre de a n’est pas nécesserement égale au
nombre de b.
(ab)+ => contient abab
a∗ b∗ => contient ε
=> Le langage L n’est pas régulier. Il n’y a pas d’ER qui décrit le langage L.
ST : a,b SN : S Axiome : S
Règle de production : S -> ab ; S->aSb
Vérification pour aaaabbbb appartient au langage.
Analyse syntaxique
Phase d’analyse d’un compilateur
Phase d’analyse d’un compilateur

Analyse syntaxique
Exemple de grammaire
Exemple
Soit la grammaire suivante :
ST : a,b,c,d,+,-,*,/,(,),ˆ
SN : E,T,F
Axiome : E
Règles de production :
E → T |T + E |T − E expression
T → F |F ∗ T |F /T terme
F → a|b|c |d |(E )|F ˆF facteur
Vérifier si le mot a+d*cˆa appartient au langage ?

Analyse syntaxique
=> R1 : E → T R2 : E → T + E R3 : E → T − E
R4 : T → F R5 : T → F ∗ T R6 : T → F /T
R7 : F → a R8 : F → b R9 : F → c
R10 : F → d R11 : F → (E ) R12 : F → F ˆF

Analyse syntaxique
Définition de grammaire formelle
Définition
Une grammaire G est définie par : G=(Vt , Vn , P , S) avec :
Vt : Ensemble des symboles terminaux (Unités lexicales)
Vn : Ensemble des symboles non terminaux
P : Ensemble des règles de production
S : Axiome
Remarque :
T
Vn Vt = ∅
S ∈ Vn

Analyse syntaxique
ε est la chaine vide.

Les élements de Vt sont représentés par a,b,c,...
Les élements de Vn sont représentés par A,B,C,...
Les chaines sont des élements appartenant à (Vt Vn )∗ et sont α, β, λ, ...
S
αβ est la concaténation des deux chaines α et β

α0 = ε
α2 = αα
Une chaine composée uniquement de symboles ∈ Vt est dite terminale.
Une chaine qui contient des élements appartenant à Vn est dite non
terminale.
Une chaine est appelée également une expression gramaticale.

Analyse syntaxique
Soit la grammaire G=(Vt , Vn , P , S) avec :
Vt ={a,b}
Vn ={A,B}
P={A→a , A→aB , B→b , B→bB}
Exemple d’expression gramaticale terminale

β = bbba
Exemple d’expression gramaticale non terminale

α = aBBb
αβ = aBBbbbba
βα = bbbaaBBb
α2 = aBBbaBBb
Analyse syntaxique
Règle gramaticale
Règle gramaticale <=> Règle de production.

Notation : α ⇒ β où α ∈ (Vt Vn )∗ : est la partie gauche de la règle ; β
S
∈ (Vt Vn )∗ : est la partie droite de la règle.

S
Lecture : α est dérivable en β
Exemple
Définir la règle gramaticale dont la partie gauche est aAb.
α = aAb
Trouver β ∈ (Vt Vn )∗ tel que :
S
α⇒β
aAb ⇒ aaBbAb
Donc : β = aaBbAb

Analyse syntaxique
Dérivation-Réduction
Dérivation-Réduction :
Soit λ ∈ (Vt Vn )∗ contenant plusieurs occurences de α.
S
λ = ..α...α...α...α...
Dérivation immédiate :
Consiste à fabriquer la chaine λ’ à partir de λ , en utilisant α ⇒ β , en
remplaçant une occurence de α par β dans λ
Réduction immédiate :
0
Est l’opération réciproque. Elle consiste à fabriquer la chaine λ à partir de λ en
0
utilisant la règle α ⇒ β , en remplaçant une occurence de β par α dans λ .
Dérivation multiple :
0
Consiste à fabriquer la chaine λ à partir de λ en utilisant α ⇒ β , en
remplaçant successivement plusieurs occurences de α par β dans λ .
Analyse syntaxique
Dérivation-Réduction
Réduction multiple :
0
Est l’opération réciproque. Elle consiste à fabriquer la chaine λ à partir λ , en
utilisant α ⇒ β , en remplaçant successivement plusieurs occurences de β par
α
Exemple
Soit la règle A → bAb , et λ = aAa
1 abAba est une dérivation immédiate de aAa.
2 abbbbAbbbba est une dérivation multiple de aAa
aAa ⇒ abAba ⇒ abbAbba ⇒ abbbAbbba ⇒ abbbbAbbbba

Analyse syntaxique
Langage engendré par une expression
Langage engendré par une expression :

Soit G=(Vt , Vn , P , S) une grammaire, et soit α ∈ (Vn Vt )∗ une expression. On
S
note L(α) le langage engendré par α . L(α) est l’ensemble de toutes les
chaines terminales β qui sont des dérivations de α.
L(α) = {β ∈ Vt∗ /∃α ⇒∗ β}
L(G) = est le langage engendré par la grammaire G.
L(G) est l’ensemble de toutes les chaînes terminales β qui sont des
dérivations de S.
L(G) = L(S) = {β ∈ Vt∗ /∃S ⇒∗ β}

Analyse syntaxique
Arbre de dérivation
Arbre de dérivation :
Soit G=(Vt , Vn , P , S).
Soit α ∈ Vt∗ (chaine terminale). On appelle l’arbre dérivation de α une
representation graphique de S ⇒∗ α tel que :
S est le sommet de l’arbre.
Vn ) ∗ .
S
Chaque noeud de l’arbre est un element de (Vt
Les feuilles de l’arbre forment α en les parcourant de la gauche vers la
doite et du haut vers le bas.
Le passage d’un noeud de niveau i vers un noeud de niveau j se fait par
application d’une règle grammaticale.

Analyse syntaxique
Grammaire ambigüe
Grammaire ambigüe :
Définition
Une grammaire est ambigüe si et seulement s’il existe une chaîne qui admet
plusieurs arbres de dérivation.
Exemple
Expressions
 arithmétique
 Exp → (Exp)

Exp → Exp + Exp




Exp → Exp − Exp


 Exp → Exp ∗ Exp
Exp → num




Exp → idf


Analyse syntaxique
Grammaire ambigüe
Chaîne idf + num * idf
Arbres de dérivation

Analyse syntaxique
Grammaire ambigüe
Élimination d’ambigüité
1 Choix
 des proirotés : L’opérateur * est prioritaire sur + et - .
 Exp → Terme
Terme → Terme ∗ Terme|Facteur
Facteur → idf |num|(Exp)

2 Choix d’associativités : On décide que les opérateurs sont associatifs à
gauche.

 Exp → Exp + Terme|Exp − Terme|Terme
Terme → Terme ∗ Facteur |Facteur
Facteur → idf |num|(Exp)


Analyse syntaxique
Méthodes d’analyse
L’analyseur syntaxique reçoit une suite d’unités lexicales et vérifie que

cette suite est engendrée par la grammaire du langage.
Il existe deux approches pour construire cet arbre de dérivation :

I Analyse descendante
I Analyse ascendante

Analyse syntaxique
Analyse descendante
Principe
Construire un arbre de dérivation de la racine (l’axiome de départ) vers les

feuilles (les unités lexicales).
Exemple

S → aSbT | cT | d
T → aT | bS | c
On prend le mot w=accbbadbc
On commence par un arbre contenant juste le sommet S
On traite la première lettre a du mot w.
Avec S → aSbT

Analyse syntaxique
Analyse descendante
Exemple (suite)
Ensuite S → cT
On finit par l’arbre ci-dessous
=> le mot w appartient au langage.

Analyse syntaxique
Analyse descendante
Si un non terminal a plusieurs règles commençant par le même terminal

???
Exemple

S → aAb
A → cd | c
on prend le mot W=acb
Avec S → aAb
Pour la lettre c, on choisit A → cd ou A → c

Il faut :
I Soit lire aussi la lettre suivante (b).
I Soit vérifier le résultat pour chaque règle.

Analyse syntaxique
Table d’analyse LL(1)
Solution
I Avoir une table d’analyse qui indique pour chaque symbole non-terminal
A et terminal a la règle de production à appliquer.
Pour construire une table d’analyse, on a besoin des ensembles
PREMIER et SUIVANT.

Analyse syntaxique
Ensemble Premier
On définit l’ensemble Premier(α) comme étant l’ensemble de tous les

terminaux qui peuvent commencer une chaîne qui se dérive de α
α est une chaine composée de symboles terminaux et non terminaux
Formellement : Premier(α) ={ a | α⇒*aβ }

Avec
a représente tous les symboles terminaux
β est une chaîne quelconque composée de symboles terminaux et non
terminaux

Analyse syntaxique
Ensemble Premier
Exemple

S→Ba
B→cP|bP|P|ε
P→dS

S⇒*a donc a∈PREMIER(S)
S⇒*cPa donc c∈PREMIER(S)
S⇒*bPa donc b∈PREMIER(S)
S⇒*dSa donc d∈PREMIER(S)
Pas de dérivation S⇒*ε
Donc PREMIER(S)={a,b,c,d}

Analyse syntaxique
Calcul de Premier
Algorithme
1 Si X est un non-terminal et X→Y1 Y2 ...Yn est une production de la
grammaire (avec Yi symbole terminal ou non-terminal) alors
I ajouter les éléments de PREMIER(Y ) sauf ε dans PREMIER(X)
1
I s’il existe j (j∈ {2, ..., n}) tel que pour tout i=1, ..., j-1 on a ε ∈ ( Premier(Y ),
i
alors ajouter les éléments de PREMIER(Yj ) sauf ε dans PREMIER(X).
I si pour tout i=1, ..., n ; ε ∈ PREMIER(Y ), alors ajouter ε dans PREMIER(X)
i
2 Si X est un non terminal et X→ε est une production, ajouter ε dans
PREMIER(X)
3 Si X est un terminal, PREMIER(X) = {X}.
4 Recommencer jusqu’à ce qu’on n’ajoute rien de nouveau dans les
ensembles PREMIER.

Analyse syntaxique
Calcul de Premier
Exemple 1

→ TE’
E


 →
E’ +TE’|ε
T → FT’
T’ → *FT’|ε




 →
F (E)|nb
PREMIER(E) = PREMIER(T) = {(,nb}
PREMIER(E’) = {+,ε}
PREMIER(T) = PREMIER(F) = {(,nb}
PREMIER(T’) = {*,ε}
PREMIER(F) = {(,nb}

Analyse syntaxique
Calcul de Premier
Exemple 2

S → ABC


A → aA|ε
B → bB|cB|ε

 →
C dc|da|dA
PREMIER(S) = {a,b,c,d}
PREMIER(A) = {a, ε}
PREMIER(B) = PREMIER(F) = {b,c,ε}
PREMIER(C) = {d}

Analyse syntaxique
Ensemble Suivant
Pour tout non terminal A, Suivant(A) comme étant l’ensemble des

terminaux a qui peuvent apparaître immédiatement à droite de A dans une
dérivation :
S⇒*αAaβ
Exemple

S→Sc|Ba
B→Pa|bPb|P|ε
P→dS

a, b, c ∈ SUIVANT(S) car il y a les dérivations S⇒*Sc, S⇒*dSa et
S⇒*bdSba..

Analyse syntaxique
Calcul de Suivant
Algorithme
1 Ajouter un marqueur de fin de chaîne (symbole $ par exemple) à
SUIVANT(S) (où S est le symbole de départ de la grammaire)
2 S’il y a une production A → α Bβ où B est un non terminal, alors ajouter
le contenu de PREMIER(β) à SUIVANT(B), sauf ε
3 S’il y a une production A→ α B, alors ajouter SUIVANT(A) à SUIVANT(B)
4 S’il y a une production A → α Bβ avec ε∈ PREMIER(β), alors ajouter
SUIVANT(A) à SUIVANT(B)
5 Recommencer à partir de l’étape 3 jusqu’à ce qu’on n’ajoute rien de
nouveau dans les ensembles SUIVANT.

Analyse syntaxique
Calcul de Suivant
Exemple 1


E→TE’
E’→+TE’|ε


T→FT’
T’→*FT’|ε




 →
F (E)|nb
SUIVANT(E) = {$,)}
SUIVANT(E’) = {$,)}
SUIVANT(T) = {+,),$}
SUIVANT(T’) = {+,),$}
SUIVANT(F) = {+,),*,$}

Analyse syntaxique
Calcul de Suivant
Exemple 2

S→aSb|cd|SAe
A→aAdB|ε
 →
B bb
PREMIER(S) ={a,c} SUIVANT(S) ={$,b,a,e}
PREMIER(A) ={ a,ε} SUIVANT(A) ={ e,d}
PREMIER(B) = {b} SUIVANT(B) = {e,d}

Analyse syntaxique
Construction de la table d’analyse
Une table d’analyse est un tableau M à deux dimensions qui indique pour
chaque symbole non terminal A et chaque symbole terminal a ou symbole
$ la règle de production à appliquer.
Algorithme
Pour chaque production A→α faire
1 pour tout a∈PREMIER(α) (et a6=α), rajouter la production A→α dans la case
M[A,a]
2 si ε∈PREMIER(α), alors pour chaque b∈SUIVANT(A) ajouter A→α dans M[A,b]
Chaque case M[A,a] vide est une erreur de syntaxe

Analyse syntaxique
Construction de la table d’analyse
Exemple
Avec
 la grammaire de l’exemple1 :

 E→TE’
E’→+TE’|ε


T→FT’
T’→*FT’|ε




 →
F (E)|nb
La table d’analyse produite est :
nb + * ( ) $
E E →TE’ E → TE’
E’ E’→+TE’ E’→ε E’→ε
T T →FT’ T →FT’
T’ T’→ ε T’→*FT’ T’→ ε T’→ ε
F F→nb F→(E)

Analyse syntaxique
Analyse descendante d’un mot
On utilise la table d’analyse pour déterminer si un mot m donné est tel que
S⇒*m.
On utilise une pile et l’algorithme suivant :
Algorithme
Données : mot m, table d’analyse M.
Initialisation de la pile :
[$S ]
On ajoute un pointeur ps sur la 1ère lettre de m
repeter
Soit X le symbole en sommet de pile
Soit a la lettre pointée par ps

Analyse syntaxique
Si X est un non terminal alors

Si M[X,a]=X →Y1 ... Yn alors
enlever X de la pile
mettre Yn puis Yn − 1 puis ...puis Y1 dans la pile
émettre en sortie la production X → Y1 ... Yn
sinon
ERREUR
finsi
Sinon
Si X=$ alors
Si a=$ alors ACCEPTER
Sinon ERREUR
Finsi

Analyse syntaxique
Sinon
Si X=a alors
enlever X de la pile
avancer ps
Sinon
ERREUR
finsi
finsi
finsi
jusqu’à ERREUR ou ACCEPTER

Analyse syntaxique
Exemple d’analyse
Exemple
Considérons la grammaire E,E’,T,T’,F et le mot m=3+4*5
Pile Entrée Sortie

$E 3+4*5$ E → TE 0
$E’T 3+4*5$ E → FT 0
$E’T’F 3+4*5$ F → nb
$E’T’3 3+4*5$
$E’T’ +4*5$ T0 → ε
$E’ +4*5$ E 0 → +TE 0
$E’T+ +4*5$
$E’T 4*5$ T → FT 0
$E’T’F 4*5$ F → nb
$E’T4 4*5$

Analyse syntaxique
Exemple d’analyse
Exemple (suite)
Pile Entrée Sortie
$E’T’ *5$ T 0 → ∗FT 0
$E’T’F* *5$
$E’T’F 5$ F → nb
$E’T’5 5$
$E’T’ $ T0 → ε
$E’ $ E0 → ε
$ $ Analyse réussie

Analyse syntaxique
Grammaire LL(1)
L’algorithme précédent ne peut pas être appliqué à toutes les grammaires.

Avec une table d’analyse comportant des entrées multiples (plusieurs
productions pour une même case M[A,a]) => Impossible de faire une
analyse descendante.
Définition
On appelle grammaire LL(1) une grammaire pour laquelle la table d’ana-
lyse décrite précédemment n’a aucune case définie de façon multiple.
Le terme "LL(1)" a la signification suivante :
I le premier L indique qu’on parcourt l’entrée de gauche à droite (Left to right
scanning).
I le second L indique qu’on utilise les dérivations à gauche (Leftmost
derivation).
I le 1 indique qu’un seul symbole de prévision est nécessaire à chaque étape
nécessitant la prise d’une décision d’action d’analyse.

Analyse syntaxique
Grammaire LL(1)
Exemple

S → aAb
A → cd|c
Nous avons PREMIER(S)={a}, PREMIER(A)={c }, SUIVANT(S)={$} et
SUIVANT(A)={b}
a c b d $
La table d’analyse associée : S S → aAb
A → cd
A
A→c
ce n’est pas une grammaire LL(1).

Analyse syntaxique
Récursivité à gauche
Une grammaire est immédiatement récursive à gauche si elle contient

un non terminal A avec la production A→ Aα où α est une chaîne
quelconque.
Exemple

S → ScA | B
A → Aa | ε
 →
B Bb | d|e
=> beaucoup de récursivités à gauche immédiates
Pour éliminer la récursivité à gauche immédiate il faut remplacer toute règle de

la forme A→ Aα | β par les deux règles : A→ β A’ et A’→ α A’ | ε

Analyse syntaxique
Exemple

S→BS’

→
S’ cAS’|ε



A→A’


A→aA’|ε
B→dB’|eB’




 →
B’ bB’| ε
Cette grammaire reconnaît le même langage que la première.

Analyse syntaxique
Une grammaire est récursive à gauche si elle contient un non terminal A

tel qu’il existe une dérivation A⇒*Aα où α est une chaîne quelconque.
Exemple

S → Aa | b
A → Ac | Sd | ε
S est récursif à gauche car S⇒Aa⇒Sda

Analyse syntaxique
Elimination de la récursivité à gauche

Ordonner les non terminaux A1 ,A2 ,...,An
Pour i=1 à n faire
pour j=1 à i-1 faire
remplacer chaque production de la forme Ai →Aj α où Aj →β1 |...|βp par
Ai →β1 α|...|βp α
fin pour
éliminer les récursivités à gauche immédiates des productions Ai
fin pour

Analyse syntaxique
Exemple 1
Dans l’exemple précédent :
Ordonner S,A
i=1 pas de récursivité immédiate dans S→Aa | b
i=2 et j=1 on obtient A→Ac | Aad | bd |ε
on élimine la recursivité immédiate :
A→bdA’ | A’
A’→cA’ | adA’ |ε
on
 a obtenu la grammaire
S → Aa | b
A → bdA’ | A’
 →
A’ cA’ | adA’ |ε

Analyse syntaxique
Exemple 2
Avec
la grammaire suivante :
S→Sa| TSc|d
T→TbT|ε
On
 obtient la grammaire :

 S→TScS’|dS’
 →
S’ aS’|ε

 T→T’
 →
T’ bTT’|ε
Or on a S⇒TScS’ ⇒ T’ScS’ ⇒ ScS’
=> une récursivité à gauche
l’algorithme ne marche pas toujours lorsque la grammaire possède une
règle A→ε

Analyse syntaxique
Factorisation à gauche
S’il n’est pas évident de choisir quelle production à prendre pour

développer un non terminal A.
=> réécrire les productions de A différemment jusqu’à atteindre le bon
choix.
Exemple


S→bacdAbd|bacdBcca
A→aD


B→cE
C→...




 →
E ...
S→bacdAbd ou S→bacdBcca,
=> il faut lire la 5ième lettre du mot (a ou c).
Impossible de savoir dès le départ quelle production prendre.

Analyse syntaxique
Algorithme
Factorisation à gauche :
Pour chaque non terminal A
trouver le plus long préfixe α commun à deux de ses alternatives ou plus
Si α 6= ε, remplacer A→αβ1 |..|αβn |γ1 |..|γp (où les γi ne commencent pas
par α ) par les deux règles
A→αA’|γ1 |..|γp et A’→β1 |..|βn
fin pour
Recommencer jusqu’à ne plus en trouver.

Analyse syntaxique
Exemple

S→aEbS| aEbSeB|a
E→bcB|bca
B→ba

Factorisée
 à gauche, cette grammaire devient :
 S →aEbSS’|a

S’→eB|ε


E→bcE’
E’→B|a




 →
B ba

Analyse syntaxique
Grammaire non LL(1)
Si notre grammaire est LL(1), l’analyse syntaxique peut se faire par

l’analyse descendante.
Étant donnée une grammaire
I la rendre non ambiguë.
I éliminer la récursivité à gauche si nécessaire.
I la factoriser à gauche si nécessaire.
I construire la table d’analyse
S’il ne s’agit pas d’une grammaire LL(1), il faut appliquer une autre
méthode pour l’analyse syntaxique.

Analyse syntaxique
Grammaire non LL(1)
Exemple
On considère la grammaire :
E→E+E|E*E|(E)
Elle est ambiguë.
1 Lever l’ambiguïté (on considère les priorités classiques des opérateurs) :
E→E+T|T T→T*F|T F→(E)
2 Supprimer la récursivité à gauche :
E→TE’ E’→+TE’|ε T→FT’
T’→*FT’|ε F→(E)|nb
=> Inutile de factoriser à gauche car elle est de type LL(1)

La grammaire suivante n’est pas de type LL(1)
elle n’est pas ambiguë, n’est pas récursive à gauche et elle est factorisée
à gauche :
S→aRb|ε R→cSa|d

Analyse syntaxique
Analyse ascendante
Principe
construire un arbre de dérivation du bas (unités lexicales) vers le haut

(axiome).
Deux opérations sont possibles :

I décalage (shift) : décaler d’une lettre le pointeur sur le mot en entrée
I réduction (reduce) : réduire une chaîne par un non terminal en utilisant
une des règles de production

Analyse syntaxique
Analyse ascendante
Exemple
S→aSbS|c avec le mot u=aaacbaacbcbcbcbacbc
aaacbaacbcbcbcbacbc on ne peut rien réduire, donc on décale
aaacbaacbcbcbcbacbc On peut réduire par S→c
aaaSbaacbcbcbcbacbc on ne peut rien réduire, donc on décale
aaaSbaacbcbcbcbacbc on ne peut rien réduire, donc on décale
................ ................
aaaSbaacbcbcbcbacbc On peut réduire par S→c
aaaSbaaSbcbcbcbacbc on ne peut rien réduire, donc on décale
aaaSbaaSbcbcbcbacbc on ne peut rien réduire, donc on décale
aaaSbaaSbcbcbcbacbc On peut réduire par S→c
aaaSbaaSbSbcbcbacbc On peut réduire par S→aSbS

Analyse syntaxique
Analyse ascendante
Exemple (Suite)
aaaSbaSbcbcbacbc on ne peut rien réduire, donc on décale
aaaSbaSbcbcbacbc on ne peut rien réduire, donc on décale
aaaSbaSbcbcbacbc On peut réduire par S→c
aaaSbaSbSbcbacbc On peut réduire par S→aSbS
aaaSbSbcbacbc On peut réduire par S→aSbS
aaSbcbacbc on ne peut rien réduire, donc on décale
aaSbcbacbc on ne peut rien réduire, donc on décale
aaSbcbacbc On peut réduire par S→c
aaSbSbacbc On peut réduire par S→aSbS
aSbacbc on ne peut rien réduire, donc on décale
aSbacbc On peut réduire par S→c

Analyse syntaxique
Analyse ascendante
Exemple (Suite)
aSbaSbc on ne peut rien réduire, donc on décale
aSbaSbc on ne peut rien réduire, donc on décale
aSbaSbc On peut réduire par S→c
aSbaSbS On peut réduire par S→aSbS
aSbS On peut réduire par S→aSbS
S C’est terminé ! ! !
Le mot aaacbaacbcbcbcbacbc est bien dans le langage
un décalage ou une réduction ? ?

=>Il faut construire une table d’analyse pour décider quelle opération
effectuer lorsque le pointeur est sur une lettre donnée.

Analyse syntaxique
Table d’analyse LR
Solution
Si Etat=i et Symbole courant = a alors :
I dj : décaler (empiler a et passer à l’état j)
I rp : réduire par la règle p (remplacer la chaine en sommet de pile par la
partie gauche de la règle et passer à l’état qui dépend du non terminal)
I ACC : On accepte le mot
I : Erreur de syntaxe
Pour construire la table d’analyse, on utilise :
I Ensembles SUIVANT
I Fermeture de 0-items (items)
Exemples d’items :
I E→E•+T
I F→(E•)

Analyse syntaxique
Fermeture d’un ensemble d’items
Calcul de Fermeture(I) :
1 Ajouter les items de I dans Fermeture(I)
2 Si I contient A→α•Bβ alors pour chaque B→λi ajouter : B→•λi dans
Fermeture(I)
3 Recommencer 2) tant que Fermeture(I) n’est pas stable
Exemple
On considère la grammaire suivante :
(1)E → E+T (3)T → T*F (5)F → (E)
→
(2)E T (4)T → F (6)F → nb
Fermeture({ T→T*•F , E→E•+T} ) =
{
T→T*•F, E→E•+T,
F→•(E), F→•nb
}
Analyse syntaxique
Transition d’un ensemble d’items par un symbole
Soit I un ensemble d’items

Soit X un symbole
∆(I,X) = {Fermeture(A→αX•β) / A→α•Xβ ∈ I}
Exemple
(1)E → E+T (3)T → T*F (5)F → (E)
(2)E → T (4)T → F (6)F → nb
I={T→T*•F, E→E•+T, F→•(E), F→•nb}
∆(I, F) = {T→T*F•}
∆(I, nb) = {F→nb•}
∆(I, +) = {E→E+•T, T→•T*F, T→•F, F→•(E), F→•nb}
∆(I, ( ) = {F→(•E), E→E+T, E→T, T→•T*F, T→•F, F→•(E), F→•nb}

Analyse syntaxique
Calcul de la collection des items de la grammaire
Algorithme
1 Ajouter la règle S’→S. I0 = Fermeture({S’→•S})
2 Mettre I0 dans Collection
3 Pour chaque I dans Collection :
Pour chaque X / ∆(I, X)6= ∅ :
ajouter ∆(I, X) dans Collection
Fin pour
Fin pour
4 Recommencer 3. tant que la collection n’est pas stable

Analyse syntaxique
Construction de la table d’analyse SLR
1 Construire la collection d’items

{I0 , ... , In }. 0, 1, 2, .., n sont les états.
2 Pour chaque état i :
(a) Pour chaque ∆(Ii , a) = Ij : M[i, a]=dj .
(b) Pour chaque ∆(Ii , A) = Ij : M[i, A]=j.
(c) Pour chaque (p) A→α• ∈ Ii et
chaque a ∈ SUIVANT(A) : M[i, a]=rp .
(d) Si S’→S• ∈ Ii : M[i, $]=ACC.

Analyse syntaxique
Exemple
(1)E → E+T (3)T → T*F (5)F → (E)
(2)E → T (4)T → F (6)F → nb
I0 ={E’→•E, E→ •E+T, E→ •T, T→•T*F, T→•F, F→•(E), F→•nb}
I1 =∆(I0 , E) = {E’→E•, E→ E•+T}
→ M[1,$]=ACC
I2 =∆(I0 , T) ={E→ T•, T→T•*F}
→ M[2,$]=r2 , M[2,+]=r2 , M[2,)]=r2
I3 =∆(I0 , F) = {T→F•}
→ M[3,$]=r4 , M[3,+]=r4 M[3,*]=r4 , M[3,)]=r4
I4 =∆(I0 , ( ) ={F→(•E), E→ •E+T, E→ •T, T→•T*F, T→•F, F→•(E),
F→•nb}

Analyse syntaxique
Exemple (Suite)
I5 =∆(I0 , nb) = {F→nb•}
→ M[5,$]=r6 , M[5,+]=r6 , M[5,*]=r6 , M[5,)]=r6
I6 =∆(I1 , +) ={E→ E+•T, T→•T*F, T→•F, F→•(E), F→•nb}
I7 =∆(I1 , *) ={T→T*•F, F→•(E), F→•nb}
I8 =∆(I4 , E) ={F→(E•), E→ E•+T}
I2 =∆(I4 , T) = {E→ T•, T→T•*F}
I3 =∆(I4 , F) ={T→F•}
I4 =∆(I4 , ( ) = {F→(•E), E→ •E+T, E→ •T, T→•T*F, T→•F, F→•(E),
F→•nb}
I5 =∆(I4 , nb) = {F→nb•}
I9 =∆(I6 , T) ={E→ E+T•, T→T•*F}
→ M[9,$]=r1 , M[9,+]=r1 , M[9, ) ]=r1
Analyse syntaxique
Exemple (Suite)
I3 =∆(I6 , F) ={T→F•}
I4 =∆(I6 , ( ) = {F→(•E), E→ •E+T, E→ •T, T→•T*F, T→•F, F→•(E),
F→•nb}
I5 =∆(I6 , nb) = {F→nb•}
I5 =∆(I4 , nb) = {F→nb•}
I9 =∆(I6 , T) ={E→ E+T•}
→ M[9,$]=r1 , M[9,+]=r1 , M[9,+]=r1

Analyse syntaxique
Analyseur syntaxique SLR
On part dans l’état 0,

On empile et dépile les symboles (comme lors de l’analyse LL) et les états
successifs.
Exemple 1
L’analyse du mot m=3+*48 est donnée dans la figure suivante :

Analyse syntaxique
Exemple 1 (Suite)
Pile Entrée Action
$0 3+*48 d5
$035 +*48 r5 : F→nb
$0F +*48 Je suis en 0 avec F je vais en 3
$0F3 +*48 r4 : T→F
$0T +*48 Je suis en 0 avec T je vais en 2
$0T2 +*48 r2 : E→T
$0E +*48 Je suis en 0 avec E je vais en 1
$0E1 +*48 d6
$0E1+6 *48 ERREUR ! !ce mot n’est pas dans le langage

Analyse syntaxique
Exemple 2
La figure suivante donne la table d’analyse SLR.

Analyse syntaxique
Exemple 2 (Suite)
La figure suivante donne l’analyse du mot 3+4*2.
Pile Entrée Action
$0 3+4*2$ d5
$035 +4*2$ r6 :F→nb
$0F +4*2$ Je suis en 0 avec F je vais en 3
$0F3 +4*2$ r4 :T→F
$0T +4*2$ Je suis en 0 avec T je vais en 2
$0T2 +4*2$ r2 :E→T
$0E +4*2$ Je suis en 0 avec E je vais en 1
$0E1 +4*2$ d6
$0E1+6 4*2$ d5
$0E1+645 *2$ r6 :F→nb
$0E1+6F *2$ Je suis en 6 avec F je vais en 3

Analyse syntaxique
Exemple 2 (Suite)
La figure suivante donne l’analyse du mot 3+4*2.
Pile Entrée Action
$0E1+6F3 *2$ r4 :T→F
$0E1+6T *2$ Je suis en 6 avec T je vais en 9
$0E1+6T9 *2$ d7
$0E1+6T9*7 2$ d5
$0E1+6T9*725 $ r6 :F→nb
$0E1+6T9*7F $ Je suis en 7 avec F je vais en 10
$0E1+6T9*7F10 $ r3 :T→T*F
$0E1+6T $ Je suis en 6 avec T je vais en 9
$0E1+6T9 $ r1 :E→E+T
$0E $ Je suis en 0 avec E je vais en 1
$0E1 $ ACCEPTE ! ! !

Analyse syntaxique
Remarques
La méthode ascendante analyse plus de grammaires que la méthode
descendante.
plus de grammaires SLR que LL
Aucune importance que la grammaire soit récursive à gauche.
Les grammaires ambiguës provoquent des conflits
I conflit décalage/réduction :laquelle choisir ?
I conflit réduction/réduction :
lire le terminal a
réduire S→α ou T→β

Analyse syntaxique
Introduction à Bison
Introduction à Bison :
Langage Bison :
Il permet de définir des grammaires hors contexte.
Il utilise des variables, des terminaux et des règles de production.
Il permet aussi de définir l’axiome, gérer les priorités des opérateurs, etc.
Le dossier d’installation de Gnu Bison ne doit pas contenir d’espaces. Il
est préférable que Flex et Bison soient installés dans le même dossier.
Après l’installation de Gnu Bison, Copier la bibliothèque "liby.a" dans le
dossier lib de DevCpp.
Programme Bison :
Constitué d’un ensemble de définitions écrites en utilisant le langage de
Bison.
Enregistré dans un fichier avec l’extension ".y".

Analyse syntaxique
Introduction à Bison
Compilateur Bison :
Génère un analyseur syntaxique à partir de la grammaire Bison.
Appel du compilateur : par la commande " bison d xxx.y".
Le résultat de la compilation est un fichier C nommé " xxx.tab.c" contenant
le code C de l’analyseur syntaxique.
Compilation de l’analyseur :
Par la commande " gcc" et en utilisant l’option " -ly" qui inclut la librairie
relative à bison.

Analyse syntaxique
Collaboration Flex/Bison
Collaboration Flex/Bison

Analyse syntaxique
Structure générale d’un programme Bison
Structure générale d’un programme Bison

Un programme Bison est composé de trois sections séparées par " %%" :
< Déclarations >

%%
< Règles de production >
%%
< Code auxiliaire >

Analyse syntaxique
Section de déclarations
Commence par " %{" et se termine par " %}" (en début de ligne). Elle
contient :
I Des déclarations et définitions en C.
I Des inclusions de fichiers ".h ".
Cette section est copiée tel quel au début du fichier " xxx.tab.c ".
Ces déclarations et ces définitions sont globales.
Les déclarations et les définitions peuvent être utilisées dans les sections
suivantes.
Une variable globale est fournie :
I yylval : l’analyseur lexical y stocke les attributs de l’unité lexicale reconnue,
alors que l’analyseur syntaxique y récupère ces attributs.
I yyval : l’analyseur syntaxique y stocke les attributs du symbole non
terminal courant (locale dans yyparse()).
I Sont de même type : YYSTYPE (int par défaut)

Analyse syntaxique
On peut modifier le type de ces deux variables :

I Si on manipule un seul type pour les terminaux et non terminaux.
• Pour le type réel, on définit :
%{
define YYSTYPE float
%}
I Si on veut manipuler des types différents, alors les déclarer dans la clause
"%union { }"
%union {float valr, char valc ;}
La clause "%token" permet de déclarer les noms et les types des unités
lexicales délivrées par l’analyseur lexical.
Lorsqu’un lexème n’a pas d’attribut ou a un attribut entier, il n’est pas
nécessaire de spécifier son type (le type int est pris par défaut).
La clause "%type" permet de déclarer les noms et les types des
symboles non terminaux.

Analyse syntaxique
Lorsqu’un symbole n’a pas d’attribut ou a un attribut entier, il n’est pas

nécessaire de le déclarer.
Les types spécifiés dans "%token" et "%type" doivent avoir été définis
dans une clause "%union".
Quand la grammaire est ambiguë, on obtient des conflits dans la table
d’analyse.
On résout ces conflits en définissant la précédence et l’associativité :
I La clause "%left" permet de spécifier des opérateurs associatifs à gauche.
I La clause "%right" permet de spécifier des opérateurs associatifs à droite.
I La clause "%noassoc" permet de spécifier des opérateurs non associatifs.
I La précédence est croissante.
I La clause "%prec" permet de forcer la précédence des opérateurs. Elle doit
être définie dans la règle de production :
E : UMOINS E %prec UMOINS {$$=-$2 ;}
La clause "%start" permet de spécifier le symbole de départ de la
grammaire (Axiome).
Analyse syntaxique
Exemple de déclaration
Exemple de déclarations
Soit la grammaire G définie par :
I V = {E, T, F} ;
I T = {nb, +, *} ;
I S = E ; (Axiome)
Les règles de production sont :
I E → E + T
I E → T
I T → T * F
I T → F
I F → nb
I F → (E)
Les terminaux "+", "*", "(" et ")" n’ont pas d’attributs.

Le terminal "nb" correspond à un nombre entier. Prenons comme attribut
un pointeur vers la valeur du nombre.

Analyse syntaxique
Exemple (Suite)
Considérons que l’attribut d’un non terminal est un entier, alors on doit
déclarer :
%{
#include "lex.yy.c"
extern FILE *yyin ;
int res ;
%}
%union {
int * ptr_nbr ;
int nbr ;
}

Analyse syntaxique
Exemple (Suite)
Les terminaux peuvent être déclarés par :
%token <ptr_nbr> NBENT
%token OPADD
%token OPMUL
%token PAROUV
%token PARFER
Les non terminaux peuvent être déclarés par :
%type <nbr> E
%type <nbr> T
%type <nbr> F
La précédence des opérateurs est (+ est moins prioritaire que *) :
%left OPADD
%left OPMUL
L’axiome est défini par : %start E
Analyse syntaxique
Section des règles de production

La section des règles de production peut utiliser tout ce qui est défini dans
la section de déclarations :
I Constantes, variables, fonctions.
Une règle de production de la grammaire a la forme suivante :
I Non terminal : corps_1 { actions_1 }
| corps_2 { actions_2 }
| ..............................
| corps_n { actions_n } ;
I Non terminal : partie gauche commune aux règles R_1, ..., R_n.
I corps_i : partie droite de la règle R_i
I actions_i : code C à exécuter lorsque la réduction correspondante à R_i est
effectuée.

Analyse syntaxique
La partie " action_i " permet, par exemple, de manipuler (lire, écrire, ...)
les attributs des terminaux et non terminaux, comme suit :
I Soit la règle A : U U ...U {actions} où :
1 2 n
• A : est un symbole non terminal.
• Ui : est un symbole terminal ou non terminal.
I Dans {actions}, on peut utiliser les variables suivantes :
• $$ : pour se référer à l’attribut de A.

• $i : pour se référer à l’attribut de Ui .
I Lorsqu’aucune action n’est spécifiée, Bison génère l’action $$ = $1 ;
I Lorsque la réduction correspondante à la règle ci-dessus est effectuée,
alors la variable yyval reçoit implicitement la valeur de $$

Analyse syntaxique
Exemple de règles de production
Exemple de règles de production

On considère la grammaire de la page 152 :
E : E OPADD T { $$ = $1 + $3 ; res=$$ ; }
| T { $$ = $1 ; res=$$ ;}
;
T : T OPMUL F { $$ = $1 * $3 ; }
| F { $$ = $1 ; }
;
F : NBENT { $$ = *$1 ; }
| PAROUV E PARFER { $$ = $2 ; }
;

Analyse syntaxique
Section code auxiliaire

Le code doit être écrit en C.
Elle peut contenir :
I Des fonctions appelées dans les actions.
I Un programme principal qui fait appel à yyparse().
Exemple :
main()
{
if (yyparse() == 0)
printf("Syntaxe correcte \n",) ;
else
printf("Erreur de syntaxe \n") ;
}

Analyse syntaxique
La valeur retournée par "yyparse()" est égale à 0 en cas de succès.

L’interaction entre analyseur lexical et analyseur syntaxique est assurée
en incluant le fichier "xxx.tab.h" qui contient les déclarations des
terminaux".
Exemple :
I on considère l’exemple de la page 152.
I Le contenu du fichier Flex, nommé "scan.l" , est défini comme suit :

Analyse syntaxique
Code source scan.l
Exemple
%{#include "pars.tab.h" %}
BLANC [ \t\n]
NBRE [0-9]+
%%
{BLANC} ;
"+" { return OPADD ; }
"*" { return OPMUL ; }
"(" { return PAROUV ; }
")" { return PARFER ; }
{NBRE} {yylval.ptr_nbre=(int*)
valeur(yytext) ;return NBENT ; }
%%
int* valeur(char * t)
{ // corps de la fonction }
Analyse syntaxique
Exemple de code auxiliaire
Exemple
%%
main( ) {
yyin = fopen("test.exp", "r") ;
if(yyparse() == 0)
printf("La syntaxe est correcte\n") ;
else
printf("Erreur de syntaxe\n") ;
}

Analyse syntaxique
Génération de l’analyseur syntaxique

Pour commencer la génération de l’analyseur syntaxique, lancer l’invité de
commandes

Analyse syntaxique
Taper la commande de génération du code C de l’analyseur lexical :

Analyse syntaxique
Taper la commande de génération du code C de l’analyseur syntaxique :

Analyse syntaxique
Compiler le code C de l’analyseur pars.tab.c :

Sommaire
2 Analyse lexicale
Rôle de l’analyse sémantique
Cas de la portée des identificateurs
Traduction dirigée par la syntaxe
Attributs synthétisés et hérités
Grammaire S-attribuée et grammaire L-attribuée
Graphe de dépendance

Analyse sémantique
Est une phase de compilation qui offre un niveau de vérification plus

profond que l’analyse syntaxique.
Pas de superposition entre les phases d’analyse.
Syntaxe = {Règles fixant la construction de phrases}

I Appel de P() précédé d’une définition ?
La sémantique a un double sens :
I Vérification : quelles phrases sont sémantiquement correctes.
I Traitement : quels sont les traitements effectués par le programme.
Certaines propriétés fondamentales du langage source ne peuvent être
décrites avec une grammaire hors contexte.
Analyse sémantique
Exemple de propriétés :
I Ne pas utiliser une variable non déclarée.
I Ne pas déclarer deux fois une même variable dans le même bloc.
I Dans un appel de fonction, le nombre de paramètres formels doit
correspondre au nombre de paramètres effectifs, et leurs types doivent être
compatibles.
I Ne pas multiplier un réel avec une chaîne, etc.
Le rôle de l’analyseur sémantique est de vérifier ces contraintes (analyse
contextuelle).
S’effectue en même temps que l’analyse syntaxique en définissant des
action sémantiques dans les règles de production (Traduction dirigée
par la syntaxe).
Il n’y a pas de méthode universelle pour faire une analyse
sémantique, car les propriétés ne sont pas unifiées.

Analyse sémantique
Cas de la portée des identificateurs
Portée d’un identificateur : Zone du programme où il peut être utilisé

(visibilité) et a la signification spécifiée dans sa déclaration (validité).
La notion de visibilité et de validité dépend des langages :
I Cobol : les identificateurs sont partout visibles.
I C : les identificateurs déclarés dans un bloc ne sont visibles qu’à l’intérieur
de ce bloc. Un identificateur déclaré dans un sous bloc masque un autre
identificateur de même nom déclaré dans le bloc de niveau inférieur, etc.
Afin de vérifier la portée des identificateurs, il faut stocker dans la table
des symboles tous les symboles rencontrés au fur et à mesure.
La table des symboles est la structure qui contient toutes les
informations utiles sur les symboles du programme (variables, fonctions,
etc.).
Pour le cas des variables, les informations peuvent être :
I Nom, adresse, type, valeur, portée, etc.

Analyse sémantique
La traduction dirigée par la syntaxe (TDS) est un formalisme permettant

d’associer des actions à une règle de production d’une grammaire.
Grammaire attribuée ou Définition Dirigée par la Syntaxe (DDS) :
I Chaque symbole de la grammaire (terminal ou non) possède un ensemble
d’attributs.
I Chaque règle de production possède un ensemble de règles sémantiques
qui permettent de calculer la valeur des attributs associés aux symboles
apparaissant dans la production.
I Une règle sémantique est une suite d’instructions : elle peut contenir des
affectations, des conditions, des instructions d’affichage, etc.
Définition
On appelle DDS, la donnée d’une grammaire et de son ensemble de
règles sémantiques.
On notera X.a l’attribut a du symbole X. S’il y a plusieurs symboles X dans
une production, on les notera X (1) , ...X (n) et X (0) s’il est dans la partie
gauche.
Analyse sémantique
Arbre syntaxique décoré :

I Définition :
On appelle arbre syntaxique décoré un arbre syntaxique sur les noeuds
duquel on rajoute la valeur de chaque attribut.
I Exemple
les figure suivante donnent l’arbre syntaxique décoré du mot 345 selon la
DDS définie.

Analyse sémantique
Exemple 1
Soit la grammaire :
num → num chiffre|chiffre
chiffre → 0|1|2|3|4|5|6|7|8|9
Attributs : val

Analyse sémantique
On distingue deux types d’attributs : les synthétisés et les hérités.

Attributs synthétisés :
I Un attribut est dit synthétisé lorsqu’il est calculé pour le non terminal de la
partie gauche en fonction des attributs des non terminaux de la partie
droite.
I Sur l’arbre décoré : la valeur d’un attribut en un nœud se calcule en fonction
des attributs de ses fils.
I Les attributs synthétisés peuvent être facilement évalués lors d’une analyse
ascendante. Mais pas du tout lors d’une analyse descendante.
I Dans l’exemple donné ci-dessus, val est un attribut synthétisé.

Analyse sémantique
Attributs hérités :
I Un attribut est dit hérité lorsqu’il est calculé à partir des attributs du non
terminal de la partie gauche, et éventuellement des attributs d’autres non
terminaux de la partie droite.
I Sur l’arbre décoré : la valeur d’un attribut à un nœud se calcule en fonction
des attributs des frères et du père.
I Si les attributs d’un nœud donné ne dépendent pas des attributs de ses
frères droits, alors les attributs hérités peuvent être facilement évalués lors
d’une analyse descendante, mais pas lors d’une analyse ascendante.

Analyse sémantique
Une grammaire attribuée est dite S-attribuée, si tous ses attributs sont
synthétisés (elle n’a aucun attribut hérité).
La grammaire de l’exemple 1 est S-attribuée.
Une grammaire L-attribuée est une grammaire attribuée n’ayant que des
attributs hérités qui ne dépendent pas des frères droits.
Les attributs d’une grammaire L-attribuée peuvent être évaluées lors
d’une analyse syntaxique descendante.
il existe des grammaires attribuées qui possèdent à la fois des attributs
hérités et des attributs synthétisés.

Analyse sémantique
Exemple 2
Soit la grammaire :
decl → type vlist
type → int|float
vlist → id,vlist|id
Atributs : type (ENT, REEL)
float x, y

Analyse sémantique
Graphe de dépendance
Une DDS peut utiliser à la fois des attributs synthétisés et des attributs
hérités. Dans ce cas, il faut établir un ordre d’évaluation des règles
sémantiques en construisant un graphe de dépendances.
On appelle graphe de dépendances le graphe orienté représentant les
interdépendances entre les divers attributs. Le graphe a pour sommet
chaque attribut. Il y a un arc de a à b si le calcul de b dépend de a.
On construit le graphe de dépendances pour chaque règle de production,
ou bien directement le graphe de dépendances d’un arbre syntaxique
donné. Ce dernier explicite l’ordre d’évaluation des attributs.
Le graphe de dépendances pour chaque règle de production simplifie
l’obtention du graphe de l’arbre syntaxique entier.

Analyse sémantique
Analyse sémantique avec l’outil bison
Exemple : Structure AST

Modifier l’analyseur du transparent 152, de façon à afficher l’arbre de
dérivation du mot :
I Les opérateurs sont les noeuds.
I Les nombres sont les feuilles.
La structure d’une feuille peut être représentée par
La structure d’un noeud peut être ou

L’implémentation de l’AST de l’expression 2+3*5 peut être implémentée
sous la forme suivante :

Analyse sémantique
Déclaration des types de données

Structure noeud (struct tnoeud) :
typedef struct tnoeud {
t_operateur op ;
t_pAST fd, fg ; } t_noeud ;
Union feuille-noeud (union uAST) :

typedef union uAST {
t_feuille *pf ;
t_noeud *pn ; } u_AST ;
Structure feuille-noeud (struct tpAST) :
typedef struct tpAST {
u_AST nd ;
int t_nd ; } t_pAST ;
Analyse sémantique
Création de feuille et noeud d’AST

Création de feuille :
t_pAST creer_feuille(t_feuille n)
I Alloue mémoire pour une feuille
I dépose la valeur de n dans la zone allouée
I Retourne l’adresse de la zone créée
Création de noeud :
t_pAST creer_noeud(t_operateur op, t_pAST p1, t_pAST p2)
I Alloue mémoire pour un noeud
I Dépose la valeur de op, p1, p2 dans la zone allouée
I Retourne l’adresse de la zone allouée
Analyse sémantique
Affichage d’AST
void afficher_AST(t_pAST p, int niv)
où p est un pointeur sur un noeud ou une feuille de l’AST et niv est le niveau
de l’élément correspondant

Analyse syntaxique
Règles de production et actions sémantiques

E : E AD T {$$ = creer_noeud(ADD,$1,$3) ;
*(t_pAST*)p_rac = $$ ;}
| T {$$=$1 ;
*(t_pAST*) p_rac = $$ ;}
;
T : T MU F {$$ = creer_noeud(MUL,$1,$3) ;}
| F {$$=$1 ;}
;
F : NB {$$ = creer_feuille(*$1) ;}
| PO E PF {$$=$2 ;}
;

Analyse sémantique
L’expression (23+5)*2+(67*27) s’affiche ainsi

Sommaire
2 Analyse lexicale

Compilation 2

Transféré par

Informations du document

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

Compilation 2

Transféré par

Droits d'auteur :

Formats disponibles

COMPILATION

Département d’Informatique, Faculté des Sciences, KENITRA

Année Universitaire : 2014-2015

S. MBARKI Compilation 2014-2015 1 / 184

S. MBARKI Compilation 2014-2015 2 / 184

S. MBARKI Compilation 2014-2015 3 / 184

Pour mieux comprendre les erreurs de compilation.

Analyse lexicale : Scanner Analyse syntaxique : Parser

S. MBARKI Compilation 2014-2015 4 / 184

Comment l’utilisateur communique avec l’ordinateur ?

S. MBARKI Compilation 2014-2015 5 / 184

Exemple : C, C++, Java, ...

S. MBARKI Compilation 2014-2015 6 / 184

Exemple : Shell Unix, VB, PL/SQL, ...

S. MBARKI Compilation 2014-2015 7 / 184

S. MBARKI Compilation 2014-2015 8 / 184

Le flot de caractères est lu de gauche à droite.

S. MBARKI Compilation 2014-2015 10 / 184

Les unités lexicales sont :

L’unité syntaxique constitue l’arbre syntaxique.

S. MBARKI Compilation 2014-2015 12 / 184

S. MBARKI Compilation 2014-2015 13 / 184

Vérifie si le programme source contient des erreurs sémantiques.

S. MBARKI Compilation 2014-2015 14 / 184

S. MBARKI Compilation 2014-2015 15 / 184

S. MBARKI Compilation 2014-2015 16 / 184

S. MBARKI Compilation 2014-2015 17 / 184

Trois termes majeurs sont utilisés en analyse lexicale :

S. MBARKI Compilation 2014-2015 18 / 184

S. MBARKI Compilation 2014-2015 19 / 184

Input de l’analyseur lexical : WHILE A>3*B DO A<A-1 END

Une variable C de tye couleur qui peut prendre les valeurs :

typedef enum {VERT, BLEU, ROUGE, JAUNE} couleur;

S. MBARKI Compilation 2014-2015 21 / 184

S. MBARKI Compilation 2014-2015 23 / 184

S. MBARKI Compilation 2014-2015 24 / 184

={ε, a, b, aa, ab, ba, bb, ...}

L+ est appelé fermeture de Kleene positive de L : L+ =L∗ -{ε}

S. MBARKI Compilation 2014-2015 27 / 184

Soit Σ un alphabet, les expressions régulières et les langages qu’ils décrivent

S. MBARKI Compilation 2014-2015 28 / 184

S. MBARKI Compilation 2014-2015 29 / 184

S. MBARKI Compilation 2014-2015 30 / 184

S. MBARKI Compilation 2014-2015 31 / 184

S. MBARKI Compilation 2014-2015 32 / 184

S. MBARKI Compilation 2014-2015 33 / 184

S. MBARKI Compilation 2014-2015 34 / 184

Exemple : Introduction aux automates

S. MBARKI Compilation 2014-2015 35 / 184

S. MBARKI Compilation 2014-2015 36 / 184

Mot appartient au langage → dernier état est un état final.

: état initial : état final

S. MBARKI Compilation 2014-2015 38 / 184

On dit qu’un automate A=<Q, Σ, δ, q0 , F> accepte un mot x=x1 x2 ...xn , si

S. MBARKI Compilation 2014-2015 39 / 184

Il est difficile de passer directement d’une ER à un AFD.

P({a, b, c})={∅ , {a}, {b}, {c}, {a,b}, {a,c}, {b,c}, {a,b,c}}

S. MBARKI Compilation 2014-2015 40 / 184

S. MBARKI Compilation 2014-2015 41 / 184

Deux cas sont possibles :

un état final de l’AFN).

S. MBARKI Compilation 2014-2015 42 / 184

S. MBARKI Compilation 2014-2015 43 / 184

Cas d’un AFN avec ε- transitions :