Compilation AL LL LR As-1

Plan
q Introduc)on et rappel
q Analyseur lexical
q Analyseur syntaxique
Compila(on q Analyseur séman)que
q Représenta)on intermédiaire
Pr. Youness Tabii
q Généra)on de code
q Op)misa)on
22/10/2024 1 22/10/2024 2
Introduc)on Introduc)on
n Les micro-processeurs deviennent indispensables et sont embarqués n Programma'on en langages de bas niveau (proches de la machine)
dans tous les appareils que nous utilisons dans la vie quotidienne ¨ très difficile (complexité)
¨ Transport n Courbe d’appren'ssage très lente
n Véhicules, Systèmes de navigation par satellites (GPS), Avions, … n Débuggage fas'dieux
¨ très coûteuse en temps (perte de temps)
¨ Télécom
n Tâches récurrentes
n Téléphones portables, Smart Phones, …
n Tâches automa'sables
¨ Électroménager ¨ très coûteuse en ressource humaine (budget énorme)
n Machine à laver, Micro-ondes, Lave vaisselles, … n Tâches manuelles
Maintenance
¨ Loisir n
¨ très ingrate (ar'sanat)

n e-book, PDA, Jeux vidéo, Récepteurs, Télévision, TNT, Home Cinéma…
n Centrée sur les détails techniques et non sur les modèles conceptuels
¨ Espace ¨ n’est pas à 100% bug-free (fiabilité)
n Satellites, Navettes, Robots d’exploration, … n Le programmeur humain n’est pas parfait
n Pour fonctionner, ces micro-processeurs nécessitent des programmes
spécifiques à leur architecture matérielle
22/10/2024 3 22/10/2024 4
Introduc)on Compilateur- Défini2on
n Besoin continu de n Un compilateur est un logiciel (une fonc%on) qui prend en
v Langages de haut niveau entrée un programme P1 dans un langage source L1 et produit
en sor7e programme équivalent P2 dans un langage L2
v avec des structures de données, de contrôles et des modèles
conceptuels proches de l’humain
Langage source Compilateur Langage cible
v Logiciels de génération des langages bas niveau
(propres aux microprocesseurs) à partir de langages
haut niveau et vice versa Messages d’erreurs
v Compilateurs
v Interpréteurs n Exemple de compilateurs :
v Pré-processeurs ¨ C pour Motorola, Ada pour Intel, C++ pour Sun, doc vers pdf, ppt vers
v Dé-compilateur Postscript, pptx vers ppt, Latex vers Postscript, etc.
v etc.
22/10/2024 5 22/10/2024 6
Interpréteur- Défini.on Dé-compilateur

n Un interpréteur est logiciel qui prend en entrée un n Dé-Compilateur est un compilateur dans le sens
programme P1 dans un langage source L1 et produit inverse d’un compilateur (depuis le langage bas
en sor5e les Résultats de l’exécu5on de ce
programme niveau, vers un langage haut niveau)
n Applica<ons :
langage source Interpréteur Résultats
¨ Récupéra<on de vieux logiciels
n Portage de programmes dans de nouveaux langages
Messages d’erreurs
n Recompila<on de programmes vers de nouvelles architectures
n Exemples d’interpréteurs : ¨ Autres
¨ Batch DOS, Shell Unix, Prolog, PL/SQL, Lisp/Scheme, Basic, n Compréhension du code d’un algorithme
Calculatrice programmable, etc. n Compréhension des clefs d’un algorithme de sécurité
22/10/2024 7 22/10/2024 8
Quelques éléments de
Ques%ons réponses
n Quels sont les constituants d’un langage n Quelques cons*tuants d’un langage naturel ?
¨ Vocabulaire (lexique), Syntaxe (grammaire), Séman*que
naturel ? (sens selon le contexte)
n Un macro-algorithme pour traduire de l’Anglais vers

le Français que proposeriez-vous comme ?
n Si l’on veut programmer un traducteur de 1. Analyser les mots selon le dic*onnaire Anglais
l’Anglais vers le Français que proposeriez- 2. Analyser la forme des phrases selon la grammaire de
l’Anglais
vous comme algorithme ? 3. Analyser le sens des phrases selon le contexte des mots
dans la phrase anglaise
4. Traduire le sens des phrases dans la grammaire et le
vocabulaire du Français
22/10/2024 9 22/10/2024 10
Étapes et Architecture d’un Étapes et Architecture d’un

compilateur compilateur
ü Autres Fonc+onnalités
1. Compréhension des entrées (Analyse)
¨ Analyse des éléments lexicaux (lexèmes : mots) du programme :
analyseur lexical
¨ Analyse de la forme (structure) des instructions (phrases) du
¨ ges+on les erreurs et guide le
programme : analyseur syntaxique programmeur pour corriger son
¨ Analyse du sens (cohérence) des instructions du programme :
analyseur sémantique programme : ges$onnaire d’erreurs
2. Préparation de la génération (Synthèse)
¨ Génération d’un code intermédiaire (nécessitant des passes
d’optimisation et de transcription en code machine) : générateur de
¨ ges+on du dic+onnaire des données du
pseudo-code compilateur (symboles réservés, noms
¨ Optimisation du code intermédiaire : optimisateur de code des variables, constantes) :
3. Génération finale de la sortie (Synthèse suite)
ges$onnaire de la table des symboles
¨ Génération du code cible à partir du code intermédiaire : générateur
de code
22/10/2024 11 22/10/2024 12
Architecture d’un compilateur Rappel
Code Source
Comment Transcrire une expression régulière en langage C ?
Analyseur Lexical
Expression : L(L+C)* Avec L=[a-zA-Z] et C=[0-9]
Analyseur Syntaxique
Ges.on de Analyse Séman4que

la table des Traitement
symboles des erreurs
Généra4on de code intermédiaire
Op4misa4on de code
Génération de code
22/10/2024 13 22/10/2024 14
Rappel Rappel
ER à DFA minimal à Programme en C ER à DFA minimal à Programme en C
typedef enum {S0, S1, S2} State;
L,C
int main(int argc,char *argv[]){
L
// 1- traitement intial
s0 s1
State state = S0;
C
s2 printf(”S0\n");
Etat mort/Trash automate(state);
return 0;
}
22/10/2024 15 22/10/2024 16
void automate(State current_state){
State state = current_state;
char c = getchar();
if (c != '$') { Rappel
// 2- traitement récursif
switch (state){ ER à DFA minimal à Programme en C
case S0 :
if (((c >= 'a') && (c <='z')) || ((c >= 'A') && (c <='Z'))){ ./idAutomate ./idAutomate
state = S1; printf(”S0 --> S1\n"); state0 a123456$ state0 12345$
}else {state = S2; printf(”S0 --> S2\n");}
break;
state0 --> state1 state0 --> state2
case S1 : state1 --> state1 state2 --> state2
if (((c >= 'a') && (c <='z')) || ((c >= 'A') && (c <='Z')) || ((c state1 --> state1
>= '0') && (c <= '9'))) state2 --> state2
state = S1; printf(”S1 --> S1\n"); state1 --> state1
state2 --> state2
break;
state1 --> state1
case S2 : state2 --> state2
state = S2; printf(”S2 --> S2\n"); state1 --> state1
} state1 --> state1 mot refusé par l'automate des
automate(state); iden:ficateurs
mot accepté par l'automate des
}else{
iden:ficateurs
// 3- traitement final
if (state == S1) printf("mot accepté par l'automate des identificateurs\n");
else printf("mot refusé par l'automate des identificateurs\n");}}
22/10/2024 17 22/10/2024 18
Définitions
q Le lexique d’un langage de programma1on est son
vocabulaire.
q Un lexème (token) est une collec1on de symboles
Analyse Lexical
élémentaires (un mot) ayant un sens pour le langage.
q Plusieurs lexèmes peuvent appartenir à une même
classe. Une telle classe s’appelle une unité lexicale.
q L’ensemble des lexèmes d’une unité lexicale est décrit
par une règle appelée modèle associé à l’unité lexicale.
22/10/2024 19 22/10/2024 20
Analyseur Lexical Définition
qLe module qui effectue l’analyse lexicale s’appel q Unités lexicales (Tokens):
un analyseur lexical (lexer ou scanner).
qUn analyseur lexical prend en entrée une q Symboles : iden-ficateurs, chaînes, constantes
séquence de caractères individuels et les regroupe numériques
en lexèmes.
qAutres tâches d’un analyseur lexical q Mots clefs : while, if, case, …
q Ignorer tous les éléments n’ayant pas un sens pour le code
machine (Les espaces, les tabulations, les retours à la ligne,
et les commentaires). q Opérateurs : <=, =, ==, +, -, …
22/10/2024 21 22/10/2024 22
Analyseur Lexical
Exemple Analyseur Lexical
ü Les meilleurs modèles qui existent pour iden2fier les types lexicaux de
Input : a = b+c*2; tokens sont les expressions régulières
Tokens Unité Lexical
Ouput : a Identificateur Ø Alphabé(que : (‘a’ | ‘b’ | ... | ‘z’ | ‘A’ | ‘B’ | ... | ‘Z’)
= Opérateur Affectation
Ø Numérique : (0 | ...| 9)
IDENTIFICATEUR b Identificateur
OPPAFFECT Ø Opérateurs : (+ | - | / | * | = | <= | >= | < | >)
IDENTIFICATEUR + Opérateur Plus
PLUS Ø Naturel : Numérique+
c Identificateur
IDENTIFICATEUR * Opérateur Multiplication ØEn(er : ( + | - | e ) Naturel
OPPMULT
CONSTANTE 2 Constante Ø Iden(ficateur : (Alphabé(que ( Alphabé(que | Numérique)*)
PTVIRG
Ø ChaîneAlphaNumérique : " (Alphabé(que | Numérique)+ "
22/10/2024 23 22/10/2024 24
Analyseur Lexical
Il existe des algorithmes et ou0ls
perme2ant de générer le code
implantant l’automate d’états finis
Générateur de
(scanner) correspondant à une
expression régulière (Lex)
scanner - FLEX
22/10/2024 25 22/10/2024 26
FLEX (FAST LEX) FLEX (FAST LEX)

q Flex est un outil de génération automatique d’analyseurs Fichier Source
lexicaux.
q Un fichier Flex contient la description d’un analyseur Compilateur FLEX
lexical à générer.
qCette description est donnée sous la forme d’expressions Lex.yy.c
régulières étendues et du code écrit en langage C (ou C + +).
q Flex génère comme résultat un fichier contenant le code C Compilateur C
du future analyseur lexical (nommé lex.yy.c).
q La compilation de ce fichier par un compilateur C, génère Analyseur
finalement le code exécutable de l’analyseur lexical en Syntaxique
question.
22/10/2024 27 22/10/2024 28
FLEX
Etapes FLEX
qLorsque l’exécutable est mis en
Expressions régulières Lex Lex.yy.c œuvre, il analyse le fichier source pour
chercher les occurrences d’expressions
Lex.yy.c régulières.
gcc Executable
Autres modules qLorsqu’une régulière est trouvée, il
exécute le code C correspondant.
Source à analyser Executable Résultats de l’analyse
22/10/2024 29 22/10/2024 30
Structure d’un programme FLEX Variables FLEX

%{ q Dans les ac(ons, on peut accéder à certaines variables
/∗ Déclara(ons ∗/ • Déclara(on/Code u(lisateur: du C tout à fait
spéciales :
%} classique q yylex() : est la fonc(on principale du programme LEX.
/∗ Défini*ons ∗/
qyyleng : con(ent la taille du token reconnu ;
• Défini(ons : Expressions ra(onnelles q yytext : est une variable de type char* qui pointe vers la
%% auxquelles on a;ribue un nom chaîne de caractères reconnue par l’expression régulière.
/∗ Règles ∗/ q yylval : qui permet de passer des valeurs en(ères à YACC.
• Règles de produc(on : Associa(ons ER →
%% code C à exécuter q Il existe aussi une ac(on spéciale : ECHO qui équivaut à
prin3("%s",yytext).
/∗ Code u(lisateur ∗/
q yyin : entrée du scanner
q yyout : sor(e du scanner
22/10/2024 31 22/10/2024 32
Expression régulière FLEX FLEX
Commandes
qLes étapes à suivre pour obtenir un analyseur
avec Flex :
1. Ecrire votre analyseur dans un fichier portant une
extension ”.l” ou ”.lex”. Par exemple, ”prog.lex”.
2. Compiler votre analyseur par la commende flex : flex
prog.lex
3. Compiler le fichier par la commande gcc le fichier lex.yy.c
produit par l’étape précédente :
gcc lex.yy.c −lfl –o prog
4. Lancer l’analyseur en uHlisant le nom de celui-ci : prog
22/10/2024 33 22/10/2024 34
Exemple
/*reconnaître les chiffres, lettres, réels et identificateurs*/
%{
/* Déclaration VIDE */ 12 à en&er 12
%}
%option noyywrap 3.4à reel 3.4 Exercice 1
/* Définition */
chiffre [0-9]
L à iden&ficateur L qCompte le nombre de Voyelles, Consonnes et les
lettre [a-zA-Z] caractères de ponctua4on d’un texte entré en
6.5e+4 à reel 6.5e+4
entier {chiffre}+ clavier.
reel {chiffre}+(\.{chiffre}+(e(\+|\-)?{chiffre}+)?)?
ident {lettre}({lettre}|{chiffre})*
%% qEtapes :
/* Régles exrp à action*/
{entier} printf("\n entier %s \n ", yytext); qDéclara4on des compteurs
{reel} printf("\n reel %s \n ", yytext); qDéfini4on des expressions régulières (les consonnes,
{ident} printf("\n identificateur %s \n ", yytext); voyelles et ponctua4on)
%%
qL’ac4on à exécuté pour chaque expression régulière
int main(void){ qLa fonc4on main (pour affichage des résultat)
yylex();
return 0;}
22/10/2024 35 22/10/2024 36
%{
int nbConsonnes,nbVoyelles,nbPonctuation;
%}
Solu%on
%option noyywrap
consonne [b-df-hj-np-xz]
ponctuation [,;:?!\.]
%%
Analyse
[aeiouy] nbVoyelles++;
{consonne} nbConsonnes++;
{ponctuation} nbPonctuation++;
.|\n // ne rien faire
Syntaxique
%% $ bonjour,
int main(void){ Nb Consonnes : 4, Nb Voyelles : 3, Nb Ponctuation : 1

nbConsonnes=0;
nbVoyelles=0;
nbPonctuation=0;
yylex();
printf("\n Nb Consonnes : %d,
Nb Voyelles : %d,
Nb Poncuation : %d \n",
nbConsonnes,nbVoyelles,nbPonctuation);
return 0;
}
22/10/2024 37 22/10/2024 38
Analyseur Syntaxique-Parser- Analyseur Syntaxique

q L’analyseur syntaxique vérifie que l’ordre des qPour effectuer efficacement une analyse
tokens correspond à l’ordre définit pour le syntaxique, le compilateur nécessite :
langage. q Une défini;on formelle du langage
qOn dit que l’on vérifie la syntaxe du langage à source,
par;r de la défini;on de sa grammaire.
q Une fonc;on indicatrice de
l’appartenance d’un programme au
q L’analyse syntaxique produit une langage source,
représenta;on sous forme d’arbre de la suite q Un plan de ges;on des entrées illégales.
des tokens obtenus lors de l’analyse lexicale
22/10/2024 39 22/10/2024 40
Analyseur Syntaxique
Analyseur Syntaxique Arbre syntaxique - Exemple
q Arbre syntaxique suivant représente la
Unité lexicale Arbre
Syntaxique
structure de : (1+2)*3*4 Instruc?on
Analyseur Analyseur Analyseur
Lexical Syntaxique Sémantique Instruction
Prochain Token
Instruc?on
instruction
Table des Erreur de
Symboles Syntaxe Instruction Instruc?on
( 1 + 2 ) * 3 * 4
22/10/2024 41 22/10/2024 42
Syntaxe et Grammaire Grammaire

q La syntaxe est traditionnellement exprimée à qUne grammaire est formellement définie par :
l’aide d’une grammaire q Un ensemble de symboles terminaux (token) : Les
symboles élémentaires du langage.
q Une grammaire G est une collection de règles de q Un ensemble de symboles non-terminaux
réécriture qui définissent mathématiquement q Un ensemble de règles syntaxiques (ou de productions).
quand une suite de symbole d’un certain alphabet Tête à terminaux et/ou non-terminaux
constitue un mot d’un langage q Un axiome (symbole initial, un non-terminal).
qUne grammaire définit un langage formé par l’ensemble des
séquences finies de symboles terminaux qui peuvent être
qL’ensemble des mots pouvant être dérivées de G dérivées de l’axiome par des applications successives des
est appelé le langage défini par G, noté L(G). productions.
22/10/2024 43 22/10/2024 44
Grammaire Grammaire
Exemple Exemple
q Exemple d’une structure du if en langage C : G1 = ( {« a », « b », « c », « d », /* terminaux */
« + », « - », « * », « / »,
« ( » , « ) », « ^ »},
{<expression>, <facteur> },/* non-terminaux */
q<structure_if> ::= if «(» <condition> «)» «{» <instruction> «}»
{<expression> ::= <facteur>, /* productions */
<expression> ::= <expression> « + » <expression>,
<expression> ::= <expression> « - » <expression>,
q <structure_if>, <condition>, <instruction> : non-terminaux. <expression> ::= <expression> « * » <expression>,
q ::= : est un méta-symbole (symbole de la grammaire) signifiant <expression> ::= <expression> « / » <expression>,
«est défini par». <facteur> ::= « a »,
<facteur> ::= « b »,
q if, «(» , «)» , «{» et «}» : des terminaux. <facteur> ::= « c »,
Lorsque les terminaux ne font qu’un caractère, ou qu’ils <facteur> ::= « d »,
contiennent des caractères non alphanumériques, ou qu’ils <facteur> ::= « ( » expression « ) »,
peuvent être confondus avec des méta-symboles, ils sont écrits <facteur> ::= <facteur> « ^ » <facteur> },
entre guillemets. <expression> /* axiome */)
22/10/2024 45 22/10/2024 46
Grammaire
Résumé Grammaire hors-Contexte (GHC)
qUne grammaire dérive des chaînes en qUne Grammaire hors-contexte (GHC) G est un 4-
commençant par l’axiome et en remplaçant uplet G = <T, NT, S, P> où :
q T est l’ensemble des symboles terminaux (concrets) ou
de façon répétée les non-terminaux décrits lettres de l’alphabet
par les productions de la grammaire. q NT est l’ensemble des symboles non-terminaux
(abstraits)
qLes chaînes de terminaux dérivables à q SÎ NT, appelé symbole initial (Start ou axiome)
partir de l’axiome forment le langage défini qToute dérivation d’un mot de L(G) débute par S
par la grammaire. qÀ partir de S, on dérive l’ensemble des mots de L(G)
q P est l’ensemble des règles de réécriture ou de
production. Formellement, une règle de P est sous la
forme : NT → (T È NT)∗
22/10/2024 47 22/10/2024 48
Grammaire hors-Contexte (GHC)
Langage dérivé Exemple
qSoit G = <T, NT, S, P> une grammaire. q Soit G=<T,NT,S,P> avec:
On appelle langage engendré par G üT = {a,b}
l’ensemble L(G) = {w Î T* / S ÞrÎP+ w} üNT={S,A,B}
üS : l’axiome.
q où ÞrÎP , est appelée dérivation et dénote üP ={S→AB|aS|A, A→Ab|ε, B→AS}
l’application d’une règle de production r
de P
q et ÞrÎP + dénote la répétition de règles q Pour cette grammaire, les mots AB, aaS et ε sont
ÞrÎP des formes sur G.
22/10/2024 49 22/10/2024 50
Grammaire hors-Contexte (GHC) Grammaire hors-Contexte (GHC)

Exemple Ecriture
q Une grammaire hors-contexte qui q G = <T={0,1}, NT={S}, S, P={r1,..,r5} >
engendre les palindromes sur {a, b} : q1ère écriture des règles
qr1: S ® e
q2ème écriture des règles
qr1: S ® e
qr2: S ® 0 qr2: |0
qr3: S ® 1 qr3: |1
qr4: S ® 0 S 0 qr4: |0S0
qS → aSa qr5: S ® 1 S 1 qr5: |1S1
q |bSb q3ème écriture des règles (BNF -Backus-Naur Form)

qr1: <S> ::= (e n’est pas représentable : c’à dire : un vide = e )
qr2: |0
q |ε qr3:
qr4:
|1
| 0 <S> 0
qr5: | 1 <S> 1
22/10/2024 51 22/10/2024 52
BNF-Backus-Naur Form Grammaire hors-Contexte (GHC)
Exemple Exercice 1
Grammaire BNF pour la construc3on d’un langage naturel simple q Quel est le langage L(G) décrit par la
<Phrase> ::= <sujet> <verbe> <complément> grammaire hors-contexte suivante ?
<sujet> ::= <article> <adjectif> <nom> |
<article> <nom> <adjectif> |
<article> <nom>
qG = < T ={a}, NT ={S}, S, P = {r1, r2} >
<article> ::= «le» | «la» | «l’» | q r1: S à aS
«les» | «un» | «une» | «des» q r2: | a
<adjectif> ::= «grand» | «petit» | <couleur>
<couleur> ::= «bleu» | «vert» | «rouge»
<verbe> ::= (etc)
22/10/2024 53 22/10/2024 54

Solution 1 Exercice 2
qG: On considère la grammaire G = <T,NT,S,P> où
q r1: S ® aS
q r2: | a
qRaisonnons par induction sur la taille des mots w de L(G)

T = {b,c}
q|w| = 1 : S Þr2 a
q|w| = 2 : S Þr1 aS Þr2 aa = a2
NT = {S}
q|w| = 3 : S Þr1 aS Þr1 aaS Þr2 aaa = a3
q|w| = 4 : S Þr1 aS Þr1 aaS Þr1 aaaS Þr2 aaaa = a4
P = { S→bS|cc}
q|w| = i : S Þr1 aS Þr1 aaS Þr1 aaS Þr1 …Þr1 aaa..aaS Þr2 aaa..aaa = ai
qL(G) = È1£ i {w Î T* / w = ai } = { w Î T* / w = a+}

qL(G) est le langage de mots formés d’une suite non vide de la lettre ‘a’
Déterminer L(G).
22/10/2024 55 22/10/2024 56
Solution 2 Exercice 3
En effet, partant de l’axiome S, toute dérivation On considère la grammaire G = <T,NT,S,P> où
commencera nécessairement par appliquer 0, 1 ou
plusieurs fois la première règle puis se terminera en T = { a,b,0}
appliquant la deuxième règle.
NT = { S,U}
On représentera cela en écrivant le schéma de dérivation
P = { S→ aSa | bSb | U
suivant :
U → 0U | ε }
! ⟹∗#$ & ' ! ⟹#( & ' )) * ∈ ℕ
Alors L(G) = {& ' )) / * ∈ ℕ}

Déterminer L(G).
22/10/2024 57 22/10/2024 58

Solu6on 3 Exercice 4
Prenons les cas suivants On considère la grammaire G = <T,NT,Ph,P> où
4 ⟹67 (4( ⟹67 (8( ⟹%69 (0% (
T = { un , une , le , la , enfant , garçon , fille , cerise , haricot , cueille , mange }
NT = {Ph,Gn,Gv,Df,Dm,Nf,Nm,V }
4 ⟹67 (4( ⟹67 (*4*( ⟹%69 (*0% *( P = { Ph→Gn Gv
Gn→Df Nf | Dm Nm
Gv → V Gn
ab0nba Df → une | la
Dm→ un | le
On définit inverse(u) est le mot inverse de u, tel que v=inverse(u) Nf→ fille | cerise
Nm → enfant | garçon | haricot
V → cueille | mange
}
∗ - La phrase “une cerise cueille un enfant” apparKent-elle au langage L(G)?
Alors L(G) = {#0% &⁄# ∈ {(, *} , & = ./&0120 # , / ∈ ℕ}
22/10/2024 59 22/10/2024 60
Grammaire hors-Contexte (GHC)
Solu6on 4 GHC Linéaire Droite
Pour montrer qu’une phrase appar0ent au langage, on construit une dériva0on
de l’axiome Ph jusqu’à la phrase.
qUne grammaire G = <T, NT, S, P> HC
est dite :
On souligne à chaque fois le symbole non terminal qui est remplacé par la
dériva0on.
Ph ⇒ Gn Gv ⇒ Df Nf Gv ⇒ Df Nf V Gn q Linéaire Droite : si l’ensemble de ses
⇒ Df Nf V Dm Nm ⇒ une Nf V Dm Nm P = {Ph→Gn Gv règles de réécriture P sont de la forme :
Gn→Df Nf | Dm Nm NT → (T È T.NT)
⇒ une cerise V Dm Nm Gv → V Gn q La partie droite des règles de récriture
Df → une | la
⇒ une cerise cueille Dm Nm Dm→ un | le
contient un symbole terminal OU un symbole
Nf→ fille | cerise
terminal suivi d’un symbole non-terminal
⇒ une cerise cueille un Nm
Nm → enfant | garçon | haricot q e.g. G : S ® aS | a
⇒ une cerise cueille un enfant V → cueille | mange }
22/10/2024 61 22/10/2024 62
GHC Linéaire Gauche Langages réguliers et Grammaire

qUne grammaire G = <T, NT, S, P> HC qThéorèmes :
est dite :
q Toute grammaire HC Linéaire Droite G
q Linéaire Gauche : si l’ensemble de ses génère un langage régulier L(G) (L(G)
règles de réécriture P sont de la forme : est reconnu par un automate d’état fini)
NT → (T È NT.T) q e.g. G : S ® aS | a
q La partie droite des règles de récriture
contient un symbole terminal OU un symbole
non-terminal suivi d’un symbole terminal q Tout langage régulier L possède une
q e.g. G : S ® Sa | a grammaire HC Linéaire Droite G (L(G)
= L)
22/10/2024 63 22/10/2024 64
Algorithme DFA à GHC
Algorithme DFA à GHC Autrement dit
Principe de la construc0on : Input : A = <S, S, d, s0, F >
Output : G = <T, NT, S, P>
q Soit le DFA M = ⟨Q,T,δ,q0,F⟩
Øsi #$ ∉F : on définit G = ⟨T,Q, q0,P ⟩ équivalent qOn fait correspondre
avec
üp→aq ∈ P ⇐⇒ δ(p,a)=q qA chaque s de S, un élément de NT ( NT(s) )
üp→a ∈ P ⇐⇒ δ(p,a)∈F qA chaque élément l de S, un élément de T ( T(l) )
Øsi q0 ∈ F : on fait comme le cas précédant + on qA chaque élément (s,l,s’) de d, un élément de P ( P(s,l,s’) )
qA s0 le non terminal S
rajoute la variable S et
qA chaque élément s de F, une règle NT(s)--> e
üS → q0 | ε
22/10/2024 65 22/10/2024 66
Algorithme DFA à GHC Algorithme DFA à GHC

Exercice Solu3on
1
Trouvez la grammaire linéaire droite correspondante
0
A→ 0B |1D |0 A B C
B → 0D |1C 0
0
1
C → 0B|1D|0 1 1
0
A B C D → 0D |1D D
0
0
0,1
1 1 Après élimina9on de D inu9le :
D A→ 0B|0
B → 1C
0,1
C → 0B|0
22/10/2024 67 22/10/2024 68
Dérivation : Gauche & Droite Dériva'on : Gauche & Droite
Exemple Exemple
q Soit la grammaire HC G3 = < Exemples de dériva'ons gauches de mots dans L(G3)
üT={Number,+,-, ×, ÷ },
üNT ={Expr, Op}, 1: !"#$ ⟹&' !"#$ () *+,-./ ⟹&0 *+,-./ 1# *+,-./ ⟹&2 *+,-./ + *+,-./
üS=Expr,
üP = {r1,..,r6} > 2: !"#$ ⟹&' !"#$ () *+,-./ ⟹&' !"#$ () *+,-./ () *+,-./
ü r1 : Expr àExpr Op Number
⟹&0 *+,-./ 1# *+,-./ () *+,-./ ⟹&2 *+,-./ + *+,-./ 1# *+,-./
ü r2: | Number
ü r3 : Op à + ⟹&4 *+,-./ + *+,-./ ∗ *+,-./
ü r4 : |-
ü r5 : |×
ü r6 : |÷
22/10/2024 69 22/10/2024 70
Dériva'on : Gauche & Droite

Exercice Analyseur Syntaxique
Dériva'on à droite de l’expression Number+Number*Number q L’analyseur syntaxique doit découvrir automa5quement pour
une expression donnée en langage L, son arbre syntaxique de
Dériva'on à Droite dériva5on par rapport à la grammaire de ce langage L
!"#$ ⟹&' ()*+ ,# -./01+ ⟹&2 !"#$ ∗ -./01+ ⟹&' ()*+ ,# -./01+ ∗ -./01+
⟹&4 !"#$ + -./01+ ∗ -./01+ ⟹&6 -./01+ + -./01+ ∗ -./01+ qLa racine de l’arbre syntaxique est : le symbole non-
terminal ini5al S
Règles appliquées : (r1, r5, r1, r3, r2)
Mêmes règles mais pas dans le même ordre qLes nœuds de l’arbre syntaxique sont : le résultat de
l’applica5on des règles de produc5on ∈ (T È NT)∗
Dérivation à Gauche
!"#$ ⟹ &' !"#$ 7* -./01+ ⟹ &' !"#$ 7* -./01+ 7* -./01+ ⟹ &6 -./01+ ,# -./01+ 7* -./01+ qLes feuilles de l’arbre syntaxique sont : les éléments de
⟹ &4 -./01+ + -./01+ ,# -./01+ ⟹ &2 -./01+ + -./01+ ∗ -./01+
l’expression donnée en entrée ∈ T*
Règles appliquées : (r1, r1, r2, r3, r5)

22/10/2024 71 22/10/2024 72
Arbre Syntaxique (Arbre de dériva3on) Arbre Syntaxique (Arbre de dériva3on)
Dérivation à Gauche
!"#$ ⟹&' !"#$ () *+,-./ ⟹&0 *+,-./ 1# *+,-./ ⟹&2 *+,-./ + *+,-./ !"#$ ⟹ &' !"#$ () *+,-./ ⟹ &' !"#$ () *+,-./ () *+,-./ ⟹ &0 *+,-./ 1# *+,-./ () *+,-./
⟹ &2 *+,-./ + *+,-./ 1# *+,-./ ⟹ &4 *+,-./ + *+,-./ ∗ *+,-./
Expr Expr
Expr Op Number Expr Op Number
Number + Expr Op Number
Number + *
22/10/2024 73 22/10/2024 74
Arbre Syntaxique (Arbre de dériva3on)

Dériva'on à Droite
!"#$ ⟹&' ()*+ ,# -./01+ ⟹&2 !"#$ ∗ -./01+ ⟹&' ()*+ ,# -./01+ ∗ -./01+ Grammaire
⟹&4 !"#$ + -./01+ ∗ -./01+ ⟹&6 -./01+ + -./01+ ∗ -./01+
Expr hors-contexte
Expr Op Number Ambigüe
Expr Op Number Mêmes
Arbre Syntaxique
Number + *
22/10/2024 75 22/10/2024 76
Grammaire ambigüe
Grammaire ambigüe Exemple
q Pour une CFG G tout string w de L(G) a au moins qSoit les règles de la grammaire suivante :
un arbre de dériva6on pour G.
q Grammaire Simpliste :
q w ∈ L(G) peut avoir plusieurs arbres de dériva6on q r1: GroupeNominal → Nom
pour G : dans ce cas on dira que la grammaire est
q r2 : | Adjectif Nom
ambigüe.
q r3 : | GroupeNominal de GroupeNominal
q Idéalement, pour perme@re le parsing, une
grammaire ne doit pas être ambigüe. En effet,
l’arbre de dériva6on détermine le code généré par q Trouver un arbre de dérivation du mot
le compilateur. q w = « Ecole de Commerce de jeunes filles »
22/10/2024 77 22/10/2024 78
Grammaire ambigüe Grammaire ambigüe GroupeNominal
Exemple Exemple GroupeNominal de GroupeNominal
GroupeNominal de GroupeNominal
Nom
GroupeNominal GroupeNominal
Nom Adjectif Nom
Ecole de commerce de jeunes filles Ecole
GroupeNominal de GroupeNominal GroupeNominal de GroupeNominal
jeunes filles
Commerce
GroupeNominal de GroupeNominal GroupeNominal de GroupeNominal Adjec8f Nom
Nom Nom’ Ecole
Nom Nom jeunes filles
Nom Adjec8f Nom GN’ Nom AD’ de
Ecole
filles Commerce
Commerce jeunes Ecole de de de Commerce
GN Nom
GN Nom Nom de
GN de de
2 arbres syntaxiques différents d’une expression (i.e. ambigüité de la grammaire) Þ de de
2 interprétations différentes Þ 2 sémantiques différentes Þ 2 codes possibles à générer GN GN de Jeunes’
pour cette expression Þ Problème de non-déterminisme pour le compilateur !!
Nom GN’ Nom Filles’
22/10/2024 79 22/10/2024 80
Grammaire ambigüe GroupeNominal
Grammaire ambigüe
Exemple Exemple
GroupeNominal de GroupeNominal
GroupeNominal de GroupeNominal Adjec7f Nom

GroupeNominal
GroupeNominal
Ecole de commerce de filles jeunes Nom Nom jeunes filles
GroupeNominal de GroupeNominal GroupeNominal de GroupeNominal

Commerce
Ecole
GroupeNominal de GroupeNominal GroupeNominal de GroupeNominal Adjec7f Nom
AD GN’ AD Ecole Nom
Nom Adjec7f Nom Nom Nom jeunes filles

Nom de Nom de Ecole
GN jeunes filles Commerce
de Nom de Commerce Commerce Ecole
GN de
GN de Nom de Ecole de commerce de jeunes filles Ecole de commerce de filles jeunes
GN de Nom
de Nom de filles
GN AD 2 arbres syntaxiques différents d’une expression (i.e. ambigüité de la grammaire) Þ
GN’ AD Nom’ jeunes 2 interprétations différentes Þ 2 sémantiques différentes Þ 2 codes possibles à générer
pour cette expression Þ Problème de non-déterminisme pour le compilateur !!
22/10/2024 81 22/10/2024 82
Grammaire ambigüe Grammaire ambigüe

Exercice 1 Solu/on
La grammaire suivante est-elle ambiguë ? qLe mot “1 + 2 ´ 3” possède deux dérivations droites
q E Þr1 E ´ E Þr2 E + E ´ E Þ*r3 1 + 2 ´ 3
Garith: q E Þr2 E + E Þr1 E + E ´ EÞ*r3 1 + 2 ´ 3
qDonc 2 arbres syntaxiques
r1 : E ® E ´ E ´ +
r2 : E ® E + E Arbre 1 + 3
Arbre 2 ´
1
r3 : E ® Nombre 1 2 2 3
qDonc 2 interprétations possibles

Si Oui Pourquoi ? q (1 + 2) ´ 3 º 9
q 1 + (2 ´ 3) º 7
22/10/2024 83 22/10/2024 84
Exercice Solu/on 1
q Stmt Þr1 Stmt
qG: q if ( Expr ) then
q Stmt
q r1: Stmt → if ( Expr ) then Stmt else q else Stmt if ( ) then else
Stmt q Þr2
Expr Stmt Stmt
q if ( Expr ) then
q r2: | if ( Expr ) then Stmt q if ( Expr ) then
q Stmt
q … q else Stmt
Expr1 Stmt2
q rn |... q … if ( ) then
q Þ Expr Stmt
q if (Expr1) then
q if (Expr2) then
q Trouver un arbre de dérivation du mot w = if
q Stmt1
(Expr1) then if (Expr2) then Stmt1 else Stmt2 Expr2 Stmt1
q else
q Stmt2
22/10/2024 85 22/10/2024 86
Grammaire ambigüe
Solu/on 2 Grammaire ambigüe
qStmt Þr2 Stmt qL’ambiguïté implique que l’analyseur syntaxique
qif ( Expr ) then ne pourra pas découvrir d’une manière unique et
q Stmt définitive l’arbre syntaxique de cette expression.
qÞr1 if ( ) then
qif ( Expr ) then
q if ( Expr ) then Expr Stmt q Si l’analyseur syntaxique ne peut pas décider la
q Stmt
else Stmt
structure syntaxique d’une expression, décider du
q…
q
Expr1 sens (i.e. la sémantique) et donc du code
qÞ
exécutable équivalent à cette expression ne sera
qif (Expr1) then
if ( ) then else Stmt pas possible !!
q if (Expr2) then Expr Stmt
Stmt1
q
q
else Stmt2 qL’Ambiguïté est donc une propriété indésirable
q Stmt2
Expr2 Stmt1
dans une grammaire.
G est une grammaire ambiguë du fait qu’on a trouvé deux dériva>ons
du mot w = « if (Expr1) then if (Expr2) then Stmt1 else Stmt2 »
22/10/2024 87 22/10/2024 88
Grammaire ambigüe
Grammaire ambigüe Exemple
qLorsque le langage définit des strings composés qLe mot “1 + 2 ´ 3” possède deux dérivations droites
q E Þr1 E ´ E Þr2 E + E ´ E Þ*r3 1 + 2 ´ 3
d’instruc5ons et d’opéra5on, l’arbre syntaxique (qui q E Þr2 E + E Þr1 E + E ´ EÞ*r3 1 + 2 ´ 3
va déterminer le code produit par le compilateur) qDonc 2 arbres syntaxiques
doit refléter : ´ +
Arbre 1 + Arbre 2 ´
3 1
q Les priorités 1 2 2 3
qDonc 2 interprétations possibles

q Les associa5vités q (1 + 2) ´ 3 º 9
C’est la 2ème interpréta9on qui correspond
q 1 + (2 ´ 3) º 7
aux règles de priorité usuelles des opérateurs
arithmé9ques !!
22/10/2024 89 22/10/2024 90

Elimina.on de l’ambiguïté Elimina.on de l’ambiguïté
qAmbiguïté pour les expressions de Garith sur l’opérateur ´ qAccepter l’associativité à gauche de ´
q Cause : Garith accepte aussi bien l’associativité gauche que droite de ´ ´ ´ ´
q Solution : On choisit d’accepter l’associativité à gauche de ´
(e.g. l’interprétation (1 ´ 2) ´ 3 mais pas 1 ´ (2 ´ 3).)
´
qAmbiguïté pour les expressions de Garith sur l’opérateur + 3 ´ 4 ´
q Cause : Garith accepte aussi bien l’associativité gauche que droite de + 5
q Solution : On choisit d’accepter l’associativité à gauche de + 1 2
(e.g. l’interprétation (1 + 2) + 3 mais pas 1 + (2 + 3).) ´
3 ´ 4
qAmbiguïté pour les expressions de Garith sur les 2 opérateurs ´ et +
q Cause : Garith ne différencie pas entre les priorités de ´ et + 1 2 ´
q Solution : On choisit priorité( ´ ) > priorité( + )
(e.g. l’interprétation 1 + (2 ´ 3) mais pas (1 + 2) ´ 3.) 3
1 2
qNB. Rien ne nous empêche d’adopter l’associativité droite !!
qSuite de l’exercice : Þ Introduire des règles récursives gauches
q Essayer de réfléchir sur les transformations de Garith pour supporter ces q R11 : Mult ® Mult ´ Nombre
contraintes nécessaires à sa désambiguïsation q R12 : Mult ® Nombre
22/10/2024 91 22/10/2024 92
qAccepter l’associativité à gauche de + qChoisir priorité( ´ ) > priorité( + )
+ + + ´ + + +
+ + ´ ´ ´
+ 2 2
3 + 4 + ´ 1 2 3 4
1 2 5 3 4 3 4
+ ´
3 + 4 + 4 4
1 2 + 2 3
+
3 3
1 2 1 2
Þ Introduire des règles récursives gauches
q R21 : Add ® Add + Nombre
q R22 : Add ® Nombre Þ Introduire des règles récursives gauches
¨ R31 : Add ® Add + Mult (plus générale que R21, car R12 : Mult ® Nombre)
¨ R32 : Add ® Mult (plus générale que R22, car R12 : Mult ® Nombre)
22/10/2024 93 22/10/2024 94

G’arith < T={Nombre,+, ×}, NT ={Mult, Add}, S=Add, P = {R11, R12,
qDéfaut de G’arith
q
R31, R32} >
R11 : Mult ® Mult ´ Nombre
q
q R12 : Mult ® Nombre
q C’est impossible de forcer
q R21 : Add ® Add + Nombre (car R31 est plus générale que R21) q 1 + 2 × 3 à être interprété (1 + 2) × 3
q R22 : Add ® Nombre (car R32 est plus générale que R22) q et 3 × 1 + 2 à être interprété 3 × (1 + 2)
q R31 : Add ® Add + Mult
q R32 : Add ® Mult
q On a pris S=Add car Add est plus général de Mult (c.f. R32, de qSuite de l’exercice :
Add on peut aller vers Mult mais l’inverse est faux)
q Penser à une solution à ces nouveaux
q G’arith n’est pas ambiguë par construction !! problèmes
22/10/2024 95 22/10/2024 96
qSolution possible : introduire les parenthèses q 4 cas avec deux opérations dans une expression parenthèsées
q + à gauche du × : x + y + z
q NT devient {Mult, Add, Aux} q Cas particuliers : Nombre + Add, Add + Nombre
q P devient {R’11, R’12, R’13, R’14, R31, R32} q × à gauche du + : x + y × z

q R’11 : Mult ® Mult ´ Aux (plus générale que R11, car R’13 : Aux® q Exemples : (1 + 2) × 3
Nombre) q Cas particuliers : Nombre + Mult, Add ´ Nombre
q R’12 : Mult ® Aux (plus générale que R12, car R’13 : Aux® Nombre)
q + à gauche du + : x × y + z
q R’13 : Aux ® Nombre q Exemples : 3 × (1 + 2)
q R’14 : Aux ® ( Add ) q Cas particuliers : Nombre ´ Add, Mult + Nombre
q × à gauche du × : x × y × z
q Au lieu de q Cas particuliers : Mult ´ Nombre, Nombre ´ Mult
q R11 : Mult ® Mult ´ Nombre
qSeuls l’associativité gauche sera bien sûr prise en compte
q R12 : Mult ® Nombre
22/10/2024 97 22/10/2024 98
Grammaire ambigüe Analyseur Syntaxique

Elimina.on de l’ambiguïté Types
qG’arith < T= {Nombre,+, ×}, NT = {Mult, Add, Aux}, S = Add, P = {R1, R2, R3, R4, R5,
R6}>
qIl existe 2 types d’analyseurs
q R1 (R’11) : Mult ® Mult ´ Aux syntaxiques (parseurs)
q R2 (R’12) : Mult ® Aux
q R3 (R’13) : Aux ® Nombre
q
q
R4 (R’14) : Aux ® ( Add )
R5 (R31) : Add ® Add + Mult
q Analyseur descendant (top-down)
q R6 (R32) : Add ® Mult
q 1 + 2 × 3 pourra être interprété sans ambiguïté (1 + 2) × 3 : q Analyseurs ascendants (bottom-up)

q Add Þ R6 Mult Þ R1 Mult ´ Aux Þ R2 Aux ´ Aux Þ R4 ( Add ) ´ Aux Þ R5 (Add + Mult) ´ Aux Þ R6
(Mult + Mult) ´ Aux Þ R2 (Aux + Mult) ´ Aux Þ R2 (Nombre + Mult) ´ Aux Þ*
(Nombre + Nombre) ´ Nombre
q 3 × 1 + 2 peut être interprété sans ambiguïté 3 × (1 + 2)

q Add Þ R6 Mult Þ R1 Mult ´ Aux Þ R2 Aux ´ Aux Þ R3 Nombre ´ Aux Þ R4 Nombre ´ (Add) Þ*
Nombre ´ (Nombre + Nombre)
22/10/2024 99 22/10/2024 100

Analyseur Syntaxique Analyseur Syntaxique
Types Types
q Analyseur descendant (top-down) q Analyseurs ascendants (bottom-up)
q Algorithme : q Algorithme :
q Commence par la racine et procède en descendant l’arbre q Commence par les feuilles et procède en remontant l’arbre
syntaxique jusqu’aux feuilles. syntaxique jusqu’à la racine.
q A chaque étape, l’analyseur choisit un nœud parmi les q A chaque étape, l’analyseur ajoute des nœuds qui
symboles non-terminaux et développe l’arbre à partir de ce développent l’arbre partiellement construit.
nœud.
q Exemples : Analyseur LR(1), Analyseur LALR(1),
q Exemples : Analyseur récursif descendant, Analyseur Analyseur SLR(1)
LL(1) q LR(1) É LALR(1) É SLR(1)
22/10/2024 101 22/10/2024 102
Analyseur Syntaxique Descendant

Exemple
q Pour une grammaire du type
q R1 : S ® Mult
q R2 : Mult ® Mult ´ Aux
Analyseur Syntaxique q
q
R3 : Mult ® Aux
R4 : Aux ® Nombre
Descendant (top-down) q Problème :

q L’algorithme risque de développer Mult en Mult ´ Aux puis en Mult ´
Mult ´ Aux puis en Mult ´ Aux ´ Aux ´ Aux … ´ Aux ´ Aux indéfiniment
: bouclage de l’analyseur !!
q Solution :
q Éliminer la récursivité gauche de la grammaire pour une analyse top-
down
22/10/2024 103 22/10/2024 104

Récursivité a gauche Analyseur Syntaxique Descendant
n Une règle de réécriture est dite récursive gauche qG : Grammaire récursive gauche (NT = {S})
si q
q
S→Sα
|β
(i.e. tout mot de L(G) se termine pas une suite de α)
(i.e. tout mot de L(G) commence par β ou contient seulement β)
¨ Le premier symbole sur la partie droite de la règle est
le même que celui sur sa partie gauche q S Þ S α Þ S α α Þ … Þ S α* Þ β α*
n Exemple : q L(G’) = β α*
¨ S → Sa
q G’ : Grammaire non-récursive gauche équivalente à G (NT’ = {S,R})
¨ ou si le symbole de la partie gauche de la règle q S→βR (i.e. tout mot de L(G’) commence par β)
R→αR
apparaît sur sa partie droite et tous les symboles qui le q (i.e. tout mot de L(G’) se termine éventuellement pas une suite de α)
q |e
précèdent peuvent dériver le mot vide
n Exemple : q S Þ β R Þ β α R Þ α α R Þ … Þ α* R Þ β α*
¨ S → TSa q L(G’) = β α*
¨ T→e|…
q L(G) = L(G’) donc la transformation de G en G’ a conservé le langage reconnu
22/10/2024 105 22/10/2024 106
Elimina'on de la récursivité a gauche Elimina'on de la récursivité a gauche

Solu'on Solu'on
Entrée: Une grammaire G.
q Éliminer la récursivité gauche de la
Sor2e: Une grammaire équivalente sans récursivité à gauche.
Méthode:
grammaire suivante :
Ordonner les non-terminaux par indices A1, ..., An. q G’arith < T={Nombre,+, ×}, NT={Mult, Add,
Pour i:=1 à n faire
Pour j : = 1 à i - 1 faire
Aux}, S=Add, P = {R1, R2, R3, R4, R5, R6}>
Remplacer chaque produc2on de la forme Ai → Ajγ q R1 : Mult ® Mult ´ Aux
par les produc2ons Ai → δ1γ | ... | δkγ, q R2 : Mult ® Aux
où Aj → δ1 | . . . | δk sont les Aj -produc2ons actuelles q R3 : Aux ® Nombre
Fin q R4 : Aux ® ( Add )
Eliminer les récursivité immédiates à gauche des Ai-produc2ons q R5 : Add ® Add + Mult
Fin
q R6 : Add ® Mult
22/10/2024 107 22/10/2024 108

Elimination de la récursivité a gauche Elimination de la récursivité a gauche
Solution Solution
Grammaire récursive droite équivalente
Règles récursives gauche (i.e. conserve l’associativité droite et les
priorités de G’arith)
qÉliminer la récursivité gauche de la
NT={Mult, Aux, Add}
NT={Mult, Mult’, Aux, Add, Add’} grammaire suivante :
// Transformation directe de Mult
R1 : Mult ® Mult ´ Aux Mult ® Aux Mult’
R2 : Mult ® Aux
Mult’ ® ´ Aux Mult’ q S® S + A | S x B | C | D
|e
// Aux n’est pas récursive gauche

R3 : Aux ® Nombre Aux ® Nombre
R4 : Aux ® ( Add ) Aux ® ( Add )
// Transformation directe de Add

R5 : Add ® Add + Mult Add ® Mult Add’
R6 : Add ® Mult Add’ ® + Mult Add’
|e
22/10/2024 109 22/10/2024 110
Elimina'on de la récursivité a gauche Factorisa)on à gauche

Solu'on Algorithme
S → S α1 | S α2 | S α3 | … | S αn S → β1 R | β2 R | …. | βn R qPour chaque A Î NT
| β1 | β2 | …. | βn è R → α1 R | α2 R | … | αn R
|e q Trouver le plus long préfixe « α » commun à deux ou
plusieurs parties droites de règles relatives à A
q Si (α ¹ e) alors
q S®S+A|SxB|C|D q remplacer les règles de A de la forme
q A → αβ1 | αβ2 | · · · | αβn | γ
q par :
q A→αB|γ
q B → β1 | β2 | · · · | βn
NT ¬ NT È {B} // ajouter B à l’ensemble des symboles non-
q S ® C S’ | D S’ q
terminaux
q S’ ® + A S’ | x B S’ | e qRépéter jusqu’à ce qu’il n’y ait plus de préfixe commun
22/10/2024 111 22/10/2024 112

Factorisation à gauche Factorisa)on à gauche
Exemple Exercice
Factorisa)on à gauche de:
q S ® aS | aB | aC | aD
q S ® *aA
Simple factorisation
q |*aB
q S ® a S’ q |*C
q S’ ® S | B | C | D
22/10/2024 113 22/10/2024 114
Factorisa)on à gauche
Solu)on
q S ® *aA | *aB | *C
q S ® *aS’ | *C Analyseur Syntaxique Descendant

q S’ ® A | B Grammaire prédic7ve LL(1)
q S ® *S’’
q S’’ ® aS’ | C
22/10/2024 115 22/10/2024 116

Analyseur Syntaxique Descendant Analyseur Syntaxique Descendant
Grammaire prédic7ve LL(1) Grammaire prédictive LL(1)
LL : Le> to right – Le>most deriva7on LL : Left to right – Leftmost derivation
q Commence par la racine et procède en q Une grammaire est dite LL(k) si, et seulement si, elle
descendant l’arbre syntaxique peut être analysée en ne disposant, à chaque instant,
que des n prochains terminaux non encore
jusqu’aux feuilles. consommés.
q Le k appelé lookahead (regarder en avant) indique le
qA chaque étape, l’analyseur choisit un nombre de terminaux qu’il faut avoir lus sans les avoir
nœud parmi les symboles non- encore consommés pour décider quelle dérivaBon
faire.
terminaux et développe l’arbre à partir
de ce nœud. qL’analyse d’une grammaire LL(3) impose de gérer 3
variables contenant les 3 prochains terminaux non
encore consommés à chaque instant.
22/10/2024 117 22/10/2024 118

LL : Le> to right – Le>most deriva7on Exemple
qSoit A → α une règle de production, on qLa grammaire S à a | bS est LL(1):
définit First(α) = qProductions(Sàa) = First(a) = {a}
q {ensemble des symboles terminaux qui peuvent qProductions(Sà bS) = First(bS) = First (b) = {b}
apparaître comme premiers symboles dans les
mots dérivables à partir de α}
q Soit G = <T, NT, S, P> une grammaire, G est

dite prédictive (dite LL(1)) ssi qLa grammaire S à a | aS n’est pas LL(1):
q " les règles A→ α1 | α2 | α3 | · · ·αn de P
qProductions(Sàa) = First (a) = {a}
qProductions(Sà aS) = First (aS) = First (a) = {a}
q " i,j First(αi) ∩ First(αj) = Æ
22/10/2024 119 22/10/2024 120

First/Follow First/Follow
qL’ensemble premier : qL’ensemble suivant :
Productions(Sàa) = Premier(a) si a n’est pas vide. Produc'ons(Sàa) = Follow(S) si a est vide.

qSi a est de la forme aS ou a est un terminal alors nous
avons First(aS) = {a}. q Si une règle est de la forme S à aTb alors l’ensemble
Follow(T) con<ent l’ensemble First(b).
qSi a est de la forme AS ou A est un non-terminal alors
nous avons First(AS) = First(A). qSi une règle est de la forme Aà aT alors l’ensemble
Follow(T) con<ent l’ensemble Follow(A).
22/10/2024 121 22/10/2024 122

Grammaire prédic7ve LL(1) Grammaire prédic7ve LL(1)
Exercice : First Solu7on: First
Calculer l’ensemble First (S) des règles suivantes :
q S ® Aa
q S ® Aa
First (S) = First (A) + First(S si A=e) = {b,a}
q A ® bB q A ® bB
q |e q |e
Calculer l’ensemble First des non terminaux de la grammaire suivante :
First (S) = {a,b,c,d}
q S ® ETC
q S ® ETC First (E) = {a,e}
q E ® aE | e
q E ® aE | e
q T ® bT | cT | e First(T) = {b,c,e}
q T ® bT | cT | e
q C ® dC | da | dE
q C ® dC | da | dE First(C) = {d}
22/10/2024 123 22/10/2024 124
Grammaire prédic7ve LL(1) Grammaire prédic7ve LL(1)
Exercice : Follow Solu7on: Follow
Calculer l’ensemble Follow des non terminaux de la grammaire suivante First (S) = {a,b,c,d}
: q S ® ETC
q E ® aE | e
First (E) = {a,e}
q S ® ETC q T ® bT | cT | e
First(T) = {b,c,e}
q E ® aE | e q C ® dC | da | dE
First(C) = {d}
q T ® bT | cT | e
q C ® dC | da | dE
Follow (S) = {$}
Folow (E) = First(T)+First(C)={b,c,d,$}
Follow(T) = First(C) = {d}
Follow (C) = Follow(S) = {$}
22/10/2024 125 22/10/2024 126

Grammaire prédictive LL(1) Grammaire prédic7ve LL(1) qfact è “a“ | “b“ | “c“ | “d“
Exemple Exemple q | (“expr“)
q | fact “^“fact
qDéterminons un programme perme/ant une analyse syntaxique en Pour la fonc+on fact, nous obtenons alors :
reprenant la grammaire G suivantes:
qexpr è term void _fact()
q | term “+“ expr {
q | term “-“ expr if (sTerminal == “ ( “) { /*commençons par “(“ expr “)“ */
q term è fact _expr();
q | fact “*“ term if (sTerminal != “ ) “)
q | fact “/“ term {_ErrSyntax("après expr “ ) “ attendu");}
q fact è “a“ | “b“ | “c“ | “d“ else
q | (“expr“) {_avancer();}
q | fact “^“fact } /*fin de “(“ expr “)“ */
qexpr /*axiome*/) else
q Nous décrirons seulement les règles de producGons de fact. {
22/10/2024 127 22/10/2024 128

Grammaire prédic7ve LL(1) qfact è “a“ | “b“ | “c“ | “d“
Exemple q | (“expr“) Grammaire prédic7ve LL(1)
q | fact “^“fact
{
if (sTerminal == (“a“ || “b“ || “c“ || “d“) {
qNous venons de produire un programme
_avancer() permettant de construire uniquement une
}
else analyse de la production Fact. Mais pouvons-
{
_fact();
nous être plus général pour l’ensemble des
if (sTerminal != “^“) constructions ?
{_ErrSyntax(‘’après FACT “^“ attendu ’’);}
else {
_fact(); qL’analyse prédictive se fait à l’aide d’une
_avancer();
} /*fin de fact “^“ fact*/ table d’analyse syntaxique prédictive.
}
} /*Fin de la fonction pour les règles de fact*/
22/10/2024 129 22/10/2024 130

Grammaire prédictive LL(1) Grammaire prédictive LL(1)
Table d’Analyse Table d’Analyse First Follow
q S ® ETC S {a,b,c,d} {$}
First (S) = {a,b,c,d} Follow (S) = {$} q E ® aE | e E {a,e} {b,c,d,$}
C ® dC’
First (E) = {a,e} Folow (E) = First(T)+First(C)={b,c,d,$} q T ® bT | cT | e C’ ® C | a| E T {b,c,e} {d}
First(T) = {b,c,e} Follow(T) = First(T) = {d} q C ® dC | da | dE C {d} {$}
First(C) = {d} Follow (C) = Follow(S) = {$} a b c d $
S S ® ETC S ® ETC S ® ETC S ® ETC
First Follow
S {a,b,c,d} {$} E E ® aE E®e E®e E®e E®e
T ® bT T ® cT T®e
Table
E {a,e} {b,c,d,$} T
d’Analyse
T {b,c,e} {d} C C ® dC
C ® da
C {d} {$}
C ® dE
N’est pas une grammaire LL(1) Factorisation
22/10/2024 131 22/10/2024 132

Exercice Solution
. Etape 1: Supprimer la récursivité a gauche
Soit la grammaire suivante :
q S®S+T|T q S ® TS’
q S®S+T|T
q T ® T*F | F q S’ ® + T S’ | e
q T ® T*F | F
q F ® (S) | id q T ® FT’
q F ® (S) | id
q T’ ®*FT’ | e
q F ® (S) | id
Construire la table d’analyse
Nouvelle grammaire
22/10/2024 133 22/10/2024 134

Grammaire prédictive LL(1) Grammaire prédictive LL(1) First Follow
Solution Solution S { ( , id } {),$}
Calculer l’ensemble First et Follow q S ® TS’ S’ { + , e} {),$}

First Follow
q S’ ® + T S’ | e T { ( , id } {+,),$}
q T ® FT’
T’ { * , e} {+,),$}
q S ® TS’ S { ( , id } {),$} q T’ ®*FT’ | e
F { ( , id } {*,+,),$}
q F ® (S) | id
q S’ ® + T S’ | e S’ { + , e} {),$} Table d’analyse
q T ® FT’ id + * ( ) $
T { ( , id } {+,),$}
q T’ ®*FT’ | e S S ® TS’ S ® TS’
q F ® (S) | id T’ { * , e} {+,),$} S’ S’ ® + T S’ S’ ® e S’ ® e
T T ® FT’ T ® FT’
F { ( , id } {*,+,),$}
T’ T’ ® e T’ ®*FT’ T’ ® e T’ ® e
F F ® id F ® (S)
22/10/2024 135 22/10/2024 136

Exemple: Vérification de mot Exemple: Vérification de mot
qPrenons la grammaire G suivante : qS à Term Exp
q Exp à +Term Exp | e First Follow
q S à Term Exp qTerm à Entier ou “0“ | “1“ | .. | “9“ | .. S { entier } {$}
q Exp à +Term Exp | e Exp {+ , e} {$}
qTerm à Entier ou “0“ | “1“ | .. | “9“ | ..
Term { entier } {+ , $ }
Table d’analyse
+ entier $
S S à Term Exp
Exp Exp à +Term Exp Exp à e
Term Term à Entier
22/10/2024 137 22/10/2024 138

Grammaire prédictive LL(1)
Exemple: Vérification de mot Exercice 1
Le mot :1+3 qOn s’intéresse à une 1. Cette grammaire n’est
Reconnu Pile Entrée Action grammaire GI de calcul pas LL(1) : pourquoi?
S$ 1 + 3$ S à Term Exp d’itinéraire suivante: 2. Donner une grammaire
Term Exp$ 1 + 3$ Term à Entier qG = <T,NT, {ROUTE}, P> avec G’ équivalente à G et qui
Entier Expr$ qT = { go, tg, td, pan },
1 + 3$ Entier = 1 (dépilé Entier)
qNT = {ROUTE, INST, PANNEAU , TOURNE}
vous semble LL(1).
1 Expr$ + 3$ Exp à +Term Exp
qLes règles P 3. Calculer les ensembles
ü ROUTE→ INST| INST ROUTE Premier et Suivant pour
1 +Term Exp$ + 3$ +=+ (Dépilé +)
ü INST→ go| PANNEAU TOURNE Gʹ.
1+ Term Exp$ 3$ Term à Entier ü TOURNE→ tg| td 4. Donner la table d’analyse
1+ Entier Expr$ 3$ Entier = 3 (dépilé Entier) ü PANNEAU→ ε | pan
LL(1) de Gʹ
1+3 Expr$ $ Exp à e
$ $ Accepté
22/10/2024 139 22/10/2024 140

ü ROUTE → INST ROUTE’
ü ROUTE→ INST| INST ROUTE
ü ROUTE’ → ε | ROUTE
G ü INST→ go| PANNEAU TOURNE G’ ü INST→ go| PANNEAU TOURNE
ü TOURNE→ tg| td
Solution ü PANNEAU→ ε | pan Solution ü
ü
TOURNE→ tg| td
PANNEAU→ ε | pan
1. Cette grammaire n’est pas LL(1) : pourquoi? Premier (PANNEAU) = { ε, pan }
Premier (TOURNE) = {tg , td}
Premier(INST) = premier (INST ROUTE)
Premier (INST) = {go} U Premier(PANNEAU) U Premier (TOURNE si PANNEAU = ε)
N’est pas une grammaire LL1 = {go , pan , tg , td }
Premier (ROUTE) = Premier(INST) ={go , pan , tg , td }
Premier (ROUTE’) = { ε } U Premier (ROUTE) = {go , pan , tg , td , ε }
2. G’ équivalente à G
ü ROUTE → INST ROUTE’ Suivant (PANNEAU) = Premier (TOURNE) = {tg , td}
Suivant (ROUTE) = { $ }
ü ROUTE’ → ε | ROUTE Suivant (INST) = { go , pan , tg , td } U Suivant (ROUTE si ROUTE’= ε) = { go , pan , tg , td , $
ü INST→ go| PANNEAU TOURNE }
Suivant (ROUTE’) = Suivant (ROUTE) = = { $ }
ü TOURNE→ tg| td Suivant (TOURNE) = Suivant (INST) = { go , pan , tg , td , $ }
Factorisation à gauche
ü PANNEAU→ ε | pan
22/10/2024 141 22/10/2024 142
First Follow ü ROUTE → INST ROUTE’

ROUTE {go , pan , tg , td } {$} ü ROUTE’ → ε | ROUTE
ü INST→ go| PANNEAU TOURNE
Autres Exercices
ROUTE’ {go , pan , tg , td , ε } {$}
ü TOURNE→ tg| td
INST {go , pan , tg , td } {go , pan , tg , td , $ } ü PANNEAU→ ε | pan
TOURNE {tg , td} { go , pan , tg , td , $ La table d’analyse LL(1) pour les deux grammaires :
PANNEAU { ε, pan } {tg , td}
G1 ={
q Table d’analyse S à (A) | a | b Vérification de : (a->(b->a))
Aà S | A -> S
tg td go pan $ }
ROUTE ROUTE → ROUTE → ROUTE → ROUTE →
INST ROUTE’ INST ROUTE’ INST ROUTE’ INST ROUTE’ G2={
ROUTE’ ROUTE’ → ROUTE ROUTE’ → ROUTE ROUTE’ → ROUTE ROUTE’ → ROUTE ROUTE’ → ε Sà iEa
INST INST→ INST→ INST→ go INST→ Eà TE½ e Vérification de : id[e]a
PANNEAU TOURNE PANNEAU TOURNE PANNEAU TOURNE Tà d[eF] ½ di
TOURNE TOURNE→ tg TOURNE→ td Fà d½ e
PANNEAU PANNEAU→ ε PANNEAU→ ε PANNEAU→ pan }
22/10/2024 143 22/10/2024 144

Exercice 2 Solution
ØSoit la grammaire G suivante: üE → E ou T | T üE → TE’
üE → E ou T | T üT → T et F | F üE’ → ou TE’ | ε
üT → T et F | F üF → non F | (E) | vrai | faux üT → FT’
üF → non F | (E) | vrai | faux üT’ → et FT’ | ε
1. La grammaire est-elle LL(1) ?
üF → non F | (E) | vrai | faux
2. Supprimer la récursivité gauche.
3. Calculer les ensembles First et Follow des symboles variables de la Non récursive a gauche
nouvelle grammaire.
4. Donner la table d’analyse LL(1) de la nouvelle grammaire.
5. Donner la pile d’analyse du mot ”vrai et (faux ou vrai)”, et en déduire
l’arbre de dérivation pour ce mot
22/10/2024 145 22/10/2024 146
Solution Solution
üE → TE’ üE → TE’
üE’ → ou TE’ | ε üE’ → ou TE’ | ε
üT → FT’ üT → FT’
üT’ → et FT’ | ε üT’ → et FT’ | ε
üF → non F | (E) | vrai | faux üF → non F | (E) | vrai | faux
First(E) = First(T) =First(F)= { non , ( , vrai , faux } Follow (E) = { ) , $ }

Follow (E’) = { ) , $ }
First(E’) = { ou , ε} Follow (T) = { ou, ) , $ }
Follow (T’) = { ou, ) , $ }
First(T’) = {et , ε } Follow (F) = { et , ou, ) , $ }
22/10/2024 147 22/10/2024 148

Solution
Table d’analyse
et ou Non vrai faux ( ) $

E
E’ E’àouTE’
EàTE’ EàTE’ EàTE’ EàTE’
E’àε E’àε
Analyse Syntaxique Ascendante
T
T’ T’àetFT’ T’àε
TàFT’ TàFT’ TàFT’ TàFT’
T’àε T’àε
LR
F FànonF Fàvrai Fàfaux Fà( E )
Vérification de mot : vrai et (faux ou vrai) (sur tableau)
22/10/2024 149 22/10/2024 150
Analyse syntaxique Ascendante Analyse syntaxique Ascendante

LR : Left to right – Rightmost derivation LR : Left to right – Rightmost derivation
qCette classe de méthodes ascendantes couvre la méthode q C’est la méthode la plus générale d’analyse
d’analyse déterministe la plus générale connue applicable
syntaxique par décalage-réduction sans retour-
aux grammaires non ambiguës.
arrière.
q Nous pouvons construire des analyseurs LR
qElle présente les avantages suivants :
q Détection des erreurs de syntaxe le plus tôt possible, en lisant les
reconnaissant quasiment toutes les constructions
terminaux de gauche à droite. des langages.
q Analyse de toutes les constructions syntaxiques des langages
courants. q La classe des grammaires analysées est un sur-
ensemble de la classe des grammaires analysées
en LL.
22/10/2024 151 22/10/2024 152

Analyse syntaxique Ascendante
LR : Left to right – Rightmost derivation Analyse syntaxique Ascendante
Architecture générale LR
qLes méthodes LR sont les plus générales, au prix de tables
d’analyse volumineuses.
Entrée Sn Sn-1 … $
qLa méthode LR comprend plusieurs cas particuliers,
Sn
correspondant au même algorithme d’analyse :
Pile q SLR où S signifie simple : c’est la construction de l’automate LR à
Sn-1 Analyseur partir de la grammaire. Transitions données uniquement par la table
(Symboles Sortie
et Etats) … Syntaxique LR ALLER_A.
$ q LALR où LA signifie LookAhead (YACC/Bison) : ce cas couvre
beaucoup de langages, avec une taille de table d’analyse de la même
taille que SLR.
Action Aller_à
qLes méthodes LR construisent l’arbre d’analyse de dérivation en
ordre inverse, en partant des feuilles.
22/10/2024 153 22/10/2024 154

Analyse syntaxique Ascendante LR : Left to right – Rightmost derivation
SLR Exemple
qUne position d’analyse LR placé dans le expression è expression • ’’ + ‘’ terme
corps de chaque production de la
grammaire est schématisée par un point •.
qL’idée centrale de la méthode LR est : Étant
donnée une position d’analyse •, nous
cherchons à obtenir par fermeture transitive
q Ce • indique que nous avons accepté ce toutes les possibilités de continuer l’analyse
qui précède dans la production, et que nous du texte source, en tenant compte de toutes
sommes prêts à accepter ce qui suit le point. les productions de la grammaire par
décalage ou réduction.
22/10/2024 155 22/10/2024 156

SLR
SLR Décalage – Réduction (shift-reduce)
Décalage – Réduction (shift-reduce) Exemple
qRéduc&on (REDUCE) : remonter la dériva&on du Pile … … … $
handle en chaînage arrière Au départ
Flux d’entré
Ø On décale de l’entrée vers la pile 0, 1 ou plusieurs

qDécalage (SHIFT) : Quand la fron&ère haute ne En cours
symboles jusqu’à ce qu’un manche se trouve en
con&ent aucun « manche », l’analyseur repousse sommet de pile.
(décale) la fron&ère en ajoutant un token à droite Ø On le remplace par la parFe gauche de la producFon
de la fron&ère.
S
$
Fin Ø Détection d’une Erreur ou $
22/10/2024 157 22/10/2024 158

Analyseur LR Analyse syntaxique Ascendante
Décalage – Réduction (shift-reduce) Fermeture transitive
Exemple Définition
üE à E+E id + id * id $ Ø Transitive signifie que nous propageons la
üE àE * E Flux d’entrée
connaissance que nous avons de la
üE à (E) position d’analyse en tenant compte des
üEà id Reduce $ E + E *id $ productions définissant la notion non
terminale que nous sommes prêts à
Reduce $ E *id $
Au départ $ id+id*id $ accepter.
Shift id $
Shift $ id +id*id $ $ E * Ø Fermeture signifie que nous faisons cette
Reduce $ E +id*id $ Shi< $ E * id $ propagation de toutes les manières
id*id $ Reduce $ E * E $ combinatoires possibles, jusqu’à
Shift $ E +
$
saturation.
*id $ Reduce $ E
Shift $ E + id
22/10/2024 159 22/10/2024 160

LR : Left to right – Rightmost derivation Analyse SLR
Exemple Exemple
qUne position d’analyse est de la forme: q Soit la grammaire G, avec des productions récursives à gauche
suivantes :
q notion è préfixe • non-terminal suffixe
üSà exp
qSa fermeture transitive (transitive closure) üexp àexp + term | term
se construit suivant toutes les productions üterm à term * fact | fact
définissant la notion non-terminal de la forme: üfact à ( exp ) | Entier
q Non-terminal è corps
qNous ajoutons à l’état d’analyse le point • q L’axiome S permet d’avoir qu’un seul état accepteur (méthode
pour marquer son début : ascendante, Grammaire Augmentée).
q Non-terminal è • corps
22/10/2024 161 22/10/2024 162

SLR Analyse SLR
Exemple Exemple
qAu début de l’analyse nous nous trouvons dans la position initiale : q De l’état_0 initial, Etat_1 // accepter exp
noté Etat_0 dans l’automate SLR.
üSà • exp nous pouvons accepter Sà exp •
exp à exp • + term
qNous n’avons encore rien consommé et nous sommes prêt à tout ce qui se trouve à
accepter une exp : droite du point Etat_2 // accepter term
üexp à • exp + term exp à term •
üexp à • term
d’analyse; nous nous term à term • * fact
qD’après les productions de notre grammaire nous sommes dans

retrouvons alors dans Etat_3 // accepter fact
l’une des positions d’analyse initiales suivantes: un des états suivants : term à fact •
üterm à • term * fact Etat_4 // accepter (
üterm à • fact term à ( • exp )
üfact à • ( exp )
üfact à • Entier
Etat_5 // accepter Entier
term à Entier •
22/10/2024 163 22/10/2024 164

fact
6 6
Sà exp • 1 exp à exp + • term Sà exp • 1 exp à exp + • term
exp à exp • + term + term à • term * fact term 9 exp à exp • + term + term à • term * fact term 9
term à • fact exp à exp + term • term à • fact exp à exp + term •
exp fact à • ( exp ) term à term • * fact exp fact à • ( exp ) term à term • * fact
fact à • Entier fact à • Entier
exp à term • 2 exp à term • 2 *
* 7 * 7
term à term • * fact fact term à term • * fact fact
term à term * • fact 10 term à term * • fact 10
term fact à • ( exp ) term fact à • ( exp )
0 fact à • Entier term à term * fact • 0 term fact à • Entier term à term * fact •
Sà • exp Sà • exp
Entier (
exp à • exp + term 3 exp à • exp + term 3 Entier
(
exp à • term fact term à fact •
exp à • term fact term à fact •
term à • term * fact term à • term * fact ( +
term à • fact term à • fact
fact
fact à • ( exp ) fact à • ( exp )
fact à • Entier fact à (• exp ) 4 fact à • Entier fact à (• exp ) 4
exp à • exp + term exp à • exp + term
( exp à • term exp 8 ( exp à • term exp 8
term à • term * fact fact à (exp •) ) term à • term * fact fact à (exp •) )
term à • fact exp à exp • + term term à • fact exp à exp • + term
fact à • ( exp ) fact à • ( exp )
Entier fact à • Entier
11 Entier fact à • Entier
11
5 fact à (exp ) • 5 fact à (exp ) •
fact à Entier • fact à Entier •

Entier
22/10/2024 165 22/10/2024 166
fact
6
1 + term
exp 9
term 2 SLR
* Construction de la table d’analyse: Action et Aller_à
7
* 10 qSi l’état état_i contient une position d’analyse de la forme: notion Þ préfixe ● terminal suffixe
term fact qet que: Aller_à( état_i, terminal ) = état_destination

Entier ( q alors on choisit:
fact En1er q ACTION ( état_i, terminal ) = SHIFT état_destination

0 3 ( qSi l’état état_i contient une position d’analyse: notion Þ corps ● où notion n’est pas S,
( + q alors pour tout terminal de Suivant(notion) on fixe:
fact q ACTION( état_i, terminal ) = REDUCE notion Þ corps

4 qSi l’état état_i contient la position d’analyse : S Þ axiome ●
( q alors on choisit :
8 ACTION( état_i, $) = ACCEPT (dernier REDUCE)
exp q
qToutesles entrées de la table action qui n’ont pas été garnies par les quatre considérations ci-dessus sont
) marquées par:
11 q ACTION( état_i, terminal_i ) = ERROR
Entier
qon garde le contenu de la table ALLER_A pour toutes les entrées dont le second argument est une notion non
5
terminale
Entier
Automate final
22/10/2024 167 22/10/2024 168

Analyse SLR Analyse syntaxique Ascendante
Construction de la table Action Construction de la table Aller_à
Etat Entier + * ( ) $ Etat exp term fact
Etats x å = T-->états Etats x å = NT-->états
0 S5 S4 0 1 2 3
1 S6 Acc 1
S i= Shift, décaler
2 R2 S7 R2 R2 2
et empiler l’état i
3 R4 R4 R4 R4 3
4 S5 S4 R j = Reduce avec la régle j 4 8 2 3
5 R6 R6 R6 R6 5
6 S5 S4 6 9 3
7 S5 S4 R1: exp à exp + term 7 10
8 S6 S 11 R2: exp à term 8
R3: term à term * fact 9
9 R1 S7 R1 R1
R4: term à fact
10 R3 R3 R3 R3 10
R5: fact à ( exp )
11 R5 R5 R5 R5 R6: fact à Entier 11
22/10/2024 169 22/10/2024 170
R1: exp à exp + term Exemple

R2: exp à term
R3: term à term * fact
R4: term à fact Entier * Entier + Entier $
R5: fact à ( exp )
R6: fact à Entier Flux d’entrée
*entier+entier$ *entier+entier$ *entier+entier$ entier+entier$
0 S 5 0 Entier 5 R 6 0 fact 3 R 4 0 term 2 S 7 0 term 2 * 7
+entier$ +entier$
S5 0 term 2 * 7 Entier 5 R 6 0 term 2 * 7 fact 10
R3 0
+entier$
term 2 R2 0
+entier$
exp 1 S6 0
entier$
exp 1 + 6
Analyse sémantique
$ $
S5 0 exp 1 + 6 Entier 5 R 6 0 exp 1 + 6 fact 3
$ $
R4 0 exp 1 + 6 term 9 R1 0 exp 1 Acc
22/10/2024 171 22/10/2024 172

Analyse Sémantique Analyse Sémantique
q Contrôle des types qContrôle d'existence et d'unicité
qUn iden2ficateur doit être déclaré avant d'être u2lisé
qNe pas déclarer 2 fois le même iden2ficateur dans le
qAffecta1on d'une variable d'un certain type même contexte
avec une expression de type diffèrent qGérer la portée des iden2ficateurs
qRéférence à une variable inappropriés : qContrôle du flux d'exécu2on

qTab[I] : erreur si Tab n'est pas un tableau qOn peut re-déclarer en local un iden2ficateur déjà
déclaré en global
qX + I : erreur si X n'est pas un en1er ou un réel
qi<= 10 : erreur si i n'est pas une variable numérique qL'instruc2on doit se trouver à l'intérieur d'une fonc2on
et doit concerner une donnée de type aFendu
22/10/2024 173 22/10/2024 174

q A chaque symbole de la grammaire: on associe un ensemble Analyseur séman-que :
d'a5ributs
q parcourt l’arbre syntaxique
qChaque symbole (terminal ou non) possède un ensemble d'a5ributs (
des variables) q sauvegarde des informa-ons à propos
q Des types des variables (selon leur déclara-on)
q A chaque produc=on: un ensemble de règles séman+ques pour q Des dimensions des variables (selon leur déclara-on)
calculer la valeur des a5ributs associés. q Taille de stockage (selon le type et la dimension),
qChaque règle possède un ensemble de règles séman=ques q U-lise ces informa-ons pour vérifier la correc-on des
qUne règle séman=que est une suite d'instruc=ons algorithmiques types de différentes expressions et instruc-ons du code
qLa grammaire et l'ensemble des règles séman=ques cons=tuent la q Détermine où il doit insérer une conversion entre des
traduc=on dirigée par la syntaxe. types de données (e.g. transformer un floIant en un
en-er)
22/10/2024 175 22/10/2024 176

Analyse Sémantique
Analyse sémantique Grammaire attribuée
Code Source
qUne grammaire a(ribuée est cons)tuée
Analyseur Lexical qd’une grammaire hors-contexte
qAugmentée
Analyseur Syntaxique qd’un ensemble d’a9ributs
qd’un ensemble de règles qui spécifient certains calculs (ac)ons
Gestion de Analyse Séman4que séman)ques)
la table des Traitement qChaque règle définit la valeur d’un a9ribut (variable), fonc)on des valeurs
symboles des erreurs des autres a9ributs
Génération de code intermédiaire qChaque règle associe l’a9ribut (qu’elle décrit) à un symbole de la
grammaire
Optimisation de code qChaque instance des symboles de la grammaire apparaissant dans l’arbre
syntaxique correspondent à une instance de l’a9ribut
qd’un ensemble de condi)ons (prédicats)
Génération de code
22/10/2024 177 22/10/2024 178

Grammaire attribuée Attribut: Notation
qVérifica(on de type (analyse contextuelle : context- qOn notera X.a l'a,ribut a du symbole X.
sensi*ve analysis)
qS'il y a plusieurs symboles X dans une produc7on :
qon notera X(0) s'il est en par7e gauche
qConstruc(on de représenta(on intermédiaires (AST) qX(1) si c'est le plus à gauche de la par7e droite,
q ..., X(n) si c'est le plus à droite de la par7e droite
qCalcul dirigé par la syntaxe (interpréteur)
q On appelle arbre syntaxique décoré un arbre
syntaxique sur les nœuds duquel on rajoute la valeur
qGénéra(on de code (compilateur) de chaque a,ribut
22/10/2024 179 22/10/2024 180

Arbre décoré: Exemple Attributs synthétisés
üE à E+E qUn a$ribut est synthé'sé si sa valeur, à un nœud d'un
E =2*(3+1) arbre syntaxique, est déterminée à par9r de valeurs
üE àE * E d'a$ributs des fils de ce nœud.
üE à (E) E (8)
qL'a$ribut de la par9e gauche est calculé en fonc9on des
üEà id
E (2) * E (4) a$ributs de la par9e droite.
üidà0 | 1 |…. | 9
( E (4) ) qLe calcul des a$ributs se fait des feuilles vers la racine.
Id (2)
qLes a$ributs synthé9ses peuvent être donc évalués au
2
Id (3) Id (1) cours d'un parcours ascendant de l'arbre de dériva9on
+
3 1
22/10/2024 181 22/10/2024 182
Analyse Sémantique Analyse Séman,que

Attributs synthétisés : Exemple A/ributs hérités
üE à E+T E Val:9 qUn a$ribut hérité est un a$ribut dont la valeur à un nœud
d'un arbre syntaxique est définie en terme des a$ributs du
üE àT Val:7
E Val:2 T père et/ou des frères de ce nœud
üT à (E) qLe calcul est effectué à par@r du non terminal de la par@e
üTà id Val:3 Val:4
E T gauche et éventuellement d'autres non terminaux de la par@e
droite
Val:3 T qSi les a$ributs d'un nœud donné ne dépendent pas des
üE(0).val à E(1).val + T.val a$ributs de ses frères droits, alors les a$ributs hérités
üE.val àT.val Val:3 id Val:4
Val:2
id peuvent être facilement évalués lors d'une analyse
id
üT.val à (E.val) descendante
üE.valà id.val 4 2
3
22/10/2024 183 22/10/2024 184

Analyse Séman,que Analyse Sémantique
A/ributs hérités : Exemple Exemple
Régles. Ac2on séman2que: S’ qSoit les règles suivantes avec les actions sémantiques
S’àS S.nb:=0
Sà(S)S S(1):=S(0).nb+1 nb:=0
S Grammaire Règles sémantique
S(2):=S(0).nb
Sà ε Ecrire S.nb D→T L { D.type = T .type L.type = T .type}
( Snb:=1 ) S nb:=0 T→int { T.type = int }
T→real { T.type = real }
nb:=2 nb:=1
( S ) S ( Snb:=1 ) S nb:=0 L→L,i { L(1).Type = L(0).Type }
{ addSymbTable(i.token,L(1).type) }
nb:=0
( Snb:=1 ) S L→i { i.Type = L(0).Type }
ε nb:=2 ε nb:=1 ( S nb:=2 ) S nb:=1 { addSymbTable(i.token , L.type) }
ε nb:=1 ε nb:=0
D représente le début de la déclaraKon
Arbre décoré pour le
ε nb:=2
( S nb:=2) S nb:=1 i représente les idenKficateurs
mot: T représente le type des variable
(( )) ( ( ) ( )) () ε nb:=2 ε nb:=1 L la liste des variables séparées par une virgule
22/10/2024 185 22/10/2024 186
Exemple : Analyse syntaxique Analyse Sémantique

Soit la déclara,on suivante : int a,b,c int a,b,c
D Type:=int
D
Type:=int
T L Type:=int T L
D→T L L i Type:=int L i Type:=int

T→int
T→real D→T L { D.type = T .type L.type = T .type} Type:=int
L i Type:=int L i
L→L,i T→int { T.type = int }
L→i T→real { T.type = real }
int i , b , c L→L,i { L(1).Type = L(0).Type } int i Type:=int
, b , c
{ addSymbTable(i.token,L(1).type) }
L→i { i.Type = L(0).Type }
a { addSymbTable(i.token , L.type) } a
22/10/2024 187 22/10/2024 188

Analyse Sémantique
qGrammaires s-a$ribuées: possèdent seulement des
a1ributs synthé/sés. Elles sont donc compa6bles avec une
évalua6on effectuée en parallèle avec une analyse Générateur d’Analyseur
syntaxique ascendante
qLes générateurs d'analyseurs ascendants (LR) ne perme1ent
d'u6liser que des grammaires s-a1ribuées
Syntaxique
q Grammaires l-a$ribuées: possèdent seulement des YACC/BISON
a1ributs hérités. Les a1ributs d'un nœud ne dépendent que
du père ou des frères a sa gauche, d’où leur compa6bilité
avec une évalua6on effectuée en parallèle avec une analyse
syntaxique descendante
22/10/2024 189 22/10/2024 190
Générateur d’Analyseur Syntaxique Générateur d’Analyseur Syntaxique

YACC/BISON YACC/BISON
q YACC synthétise une grammaire (LALR(1) q YACC: générateur d’analyseur syntaxique.
de la famille des LR) et produit le texte
source d’un analyseur syntaxique du langage q Prend en entrée la définition d’un schéma de
engendré par la grammaire donnée. traduction (grammaire + actions sémantiques).
Produit un analyseur syntaxique pour le schéma de
traduction.
q Le langage cible c’est celui dans lequel le
code de l’analyseur syntaxique synthétisé est qIl existe plusieurs versions de YACC, nous
écrit, en général C, C++, Java, et d’autres. utiliserons ici bison.
22/10/2024 191 22/10/2024 192

Schéma Format fichier .y
%{
.tab.c
/∗ Déclarations ∗/
.y %}
Bison
.tab.h /∗ Définitions Bison ∗/
gcc
%%
#include ”parser.tab.h” /∗ Règles de production ∗/
.l Lex.yy.c %%
FLEX
Analyseur /∗ Code utilisateur ∗/
Syntaxique
22/10/2024 193 22/10/2024 194

Format fichier .y Format fichier .y
qLes déclara+ons qLes déclara+ons de Bison
globales comprend : %{ comprend :
int variable1 = 0; %token terminal1
qL’inclusion des fichiers %token terminal2
d’en-tête. int variable2 = 0; q La défini+on des noms des symboles
terminaux et non-terminaux.
%}
qLa déclara+on des qLa spécifica+on de la précédence des
variables globales. opérateurs.
qLa déclara+on des qLa défini+on des types de données

fonc+ons globales. des valeurs séman+ques des divers
symboles.
22/10/2024 195 22/10/2024 196

Format fichier .y Format fichier .y
qLes règles de la grammaire définissent q Un peu de sémantique pour manipuler les valeurs.
qComment construire chaque non-terminal à par:r de ses composants. q Attributs : À chaque symbole est associée une valeur, qui est de type
qLa fonc:ons auxiliaires sont des fonc:ons écrites en langage C ou (C + +). int par défaut. Cette valeur peut être utilisée dans les actions
sémantiques (comme un attribut synthétisé).
Non-terminal : corps_1 {prod_ou_ac:on_1}
| corps_2 {prod_ou_ac:on_2} q Le symbole $$ référence la valeur de l’attribut associé au non-terminal de la
| corps_3 {prod_ou_ac:on_3} partie gauche.
| …
| corps_n {prod_ou_ac:on_n} q Le symbole $i référence la valeur associée au i-ème symbole (terminal ou
; non-terminal) ou action sémantique de la partie droite.
qL’analyse lexicale produit une séquence de terminaux, et q Lorsque aucune action n’est pas indiquée, YACC génère par défaut l’action :
l’analyse syntaxique accepte ou rejeEe ceEe séquence. {$$ = $1; }
22/10/2024 197 22/10/2024 198

Exemple Exemple
qSoit la grammaire suivante :
expr : term { prin1( ’’expression’’);}
qexpr è term
q | term + expr | term + expr {prin1( ’’+’’);}
q | term - expr | term - expr {prin1( ’’ -’’);}
;
expr : term { printf( ’’expression’’);} expr : term {$$ =$1; //par defaut}
| term + expr { printf( ’’+’’);} | term + expr {$$ =$1 + $3;}
| term - expr { printf( ’’ -’’);} | term - expr {$$ =$1 - $3;}
; ;
22/10/2024 199 22/10/2024 200

Exemple %{
#include "global.h”
Fichier Yacc
Fichier Lex #include <stdio.h>
#include <stdlib.h>
%{ #include <math.h>
#include "global.h" %}
#include "calcularice.tab.h "
#include <stdlib.h> %token NOMBRE
%} %token PLUS MOINS FOIS DIVISE PUISSANCE
blancs [ \t]+ %token PARENTHESE_GAUCHE PARENTHESE_DROITE
chiffre [0-9] %token FIN
entier {chiffre}+ %left PLUS MOINS
exposant [eE][+-]?{entier} %left FOIS DIVISE
reel {entier}("."{entier})?{exposant}? %left NEG
%% %right PUISSANCE
%start Input
{blancs} { /* On ignore */ } %%
{reel} { yylval=atof(yytext); return(NOMBRE); } Input: /* Vide */
"+" return(PLUS); | Input Ligne
"-" return(MOINS); ;
"*" return(FOIS); Ligne: FIN
"/" return(DIVISE); | Expression FIN { printf("Resultat : %f\n",$1); }
"^" return(PUISSANCE); ;
"(" return(PARENTHESE_GAUCHE); Expression: NOMBRE { $$=$1; }
")" return(PARENTHESE_DROITE); | Expression PLUS Expression { $$=$1+$3; }
"\n" return(FIN); | Expression MOINS Expression { $$=$1-$3; }
| Expression FOIS Expression { $$=$1*$3; }
| Expression DIVISE Expression { $$=$1/$3; }
| MOINS Expression %prec NEG { $$=-$2; }
bison -d calcularice.y | Expression PUISSANCE Expression { $$=pow($1,$3); }
flex calcularice.l | PARENTHESE_GAUCHE Expression PARENTHESE_DROITE { $$=$2; }
gcc -c lex.yy.c -o calcularice.lex.o ;
gcc -c calcularice.tab.c -o calcularice.y.o %%
gcc -o calcularice calcularice.lex.o calcularice.y.o -ll -lm int yyerror(char *s) { printf("%s\n",s); }
int main(void) { yyparse(); }
22/10/2024 201

Compilation AL LL LR As-1

Transféré par

Droits d'auteur :

Formats disponibles

Compilation AL LL LR As-1

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

Compilation AL LL LR As-1

Transféré par

Droits d'auteur :

Formats disponibles

Plan

¨ très ingrate (ar'sanat)

Interpréteur- Déﬁni.on Dé-compilateur

n Un macro-algorithme pour traduire de l’Anglais vers

Étapes et Architecture d’un Étapes et Architecture d’un

Ges.on de Analyse Séman4que

Etat mort/Trash automate(state);

FLEX (FAST LEX) FLEX (FAST LEX)

Structure d’un programme FLEX Variables FLEX

int main(void){ Nb Consonnes : 4, Nb Voyelles : 3, Nb Ponctuation : 1

Analyseur Syntaxique-Parser- Analyseur Syntaxique

Syntaxe et Grammaire Grammaire

Grammaire hors-Contexte (GHC) Grammaire hors-Contexte (GHC)

q |bSb q3ème écriture des règles (BNF -Backus-Naur Form)

Grammaire hors-Contexte (GHC) Grammaire hors-Contexte (GHC)

qRaisonnons par induction sur la taille des mots w de L(G)

qL(G) = È1£ i {w Î T* / w = ai } = { w Î T* / w = a+}

Alors L(G) = {& ' )) / * ∈ ℕ}

Grammaire hors-Contexte (GHC) Grammaire hors-Contexte (GHC)

GHC Linéaire Gauche Langages réguliers et Grammaire

Algorithme DFA à GHC Algorithme DFA à GHC

Dériva'on : Gauche & Droite

Règles appliquées : (r1, r1, r2, r3, r5)

⟹ &2 *+,-./ + *+,-./ 1# *+,-./ ⟹ &4 *+,-./ + *+,-./ ∗ *+,-./

Expr Op Number Expr Op Number

Number + Expr Op Number

Arbre Syntaxique (Arbre de dériva3on)

Grammaire ambigüe Grammaire ambigüe GroupeNominal

Exemple Exemple GroupeNominal de GroupeNominal

GroupeNominal de GroupeNominal Adjec7f Nom

GroupeNominal de GroupeNominal GroupeNominal de GroupeNominal

Nom Adjec7f Nom Nom Nom jeunes ﬁlles

Grammaire ambigüe Grammaire ambigüe

qDonc 2 interprétations possibles

qDonc 2 interprétations possibles

Grammaire ambigüe Grammaire ambigüe

Grammaire ambigüe Grammaire ambigüe

q P devient {R’11, R’12, R’13, R’14, R31, R32} q × à gauche du + : x + y × z

Grammaire ambigüe Analyseur Syntaxique

q 1 + 2 × 3 pourra être interprété sans ambiguïté (1 + 2) × 3 : q Analyseurs ascendants (bottom-up)

q 3 × 1 + 2 peut être interprété sans ambiguïté 3 × (1 + 2)

22/10/2024 99 22/10/2024 100

22/10/2024 101 22/10/2024 102

Analyseur Syntaxique Descendant

Descendant (top-down) q Problème :

22/10/2024 103 22/10/2024 104

22/10/2024 105 22/10/2024 106

Elimina'on de la récursivité a gauche Elimina'on de la récursivité a gauche

22/10/2024 107 22/10/2024 108

// Aux n’est pas récursive gauche

// Transformation directe de Add

22/10/2024 109 22/10/2024 110

Elimina'on de la récursivité a gauche Factorisa)on à gauche

22/10/2024 111 22/10/2024 112

22/10/2024 113 22/10/2024 114

q S ® *aS’ | *C Analyseur Syntaxique Descendant

22/10/2024 115 22/10/2024 116

Analyseur Syntaxique Descendant Analyseur Syntaxique Descendant

q Soit G = <T, NT, S, P> une grammaire, G est

⟹ &2 +,-./ + +,-./ 1# +,-./ ⟹ &4 +,-./ + +,-./ ∗ +,-./

q S ® aS’ | C Analyseur Syntaxique Descendant