Compilation : tutoriel simple
Les outils Flex et Bison
Prof. Rabhi Ahmed
Plan 2
1. Définir notre propre langage
Analyse lexicale.
Les mots acceptés : Expressions régulières
Les unités lexicales
Analyse syntaxique
Unités syntaxique
L’ordre possibles des mots: La grammaire
2. Code Flex pour effectuer l’analyse lexicale
Reconnaitre les mots acceptés
Retourner les mots accepté selon leurs unités lexicales
3. Code Bison pour effectuer l’analyse syntaxique
Vérifier si la sequence de mots est accepté
Prof. Rabhi Ahmed
Prérequis 3
Pour bien suivre ce tutoriel vous devez d’abord réviser les cours
suivants:
• Expression régulières
• Initiation à l’outil Flex:
• Les expressions régulières Flex
• La grammaire en théorie de langages
Prof. Rabhi Ahmed
Objectifs 4
Dans ce tutoriel, on traite un cas simple de compilateurs
Le compilateur doit
Analyser lexicalement le texte d’entrée:
Arrêter le traitement s’il détecte une erreur lexicale (un mot non accepté).
Rien à signaler : si tout les mots sont acceptés, et retourne les mots acceptés.
Analyser syntaxiquement le texte d’entrée après l’analyse lexicale.
Arrêter le traitement s’il détecte une erreur syntaxique (un mot accepté mais mal
placé).
Rien à signaler si tout les mots sont dans le bon ordre.
Prof. Rabhi Ahmed
Etapes basiques de création d’un langage 5
1. Etape 1: définir les mots acceptés et les unités lexicales
• Les mots acceptés à l’aide des expressions régulières Flex.
• Les unités lexicales en créant des groupes de mots qui peuvent appartenir à
la même unité lexicale
• Exemple : Mots Unité lexicale
int , float , double Type
+, * , - , / operateur
2. Etape 2: Définir la grammaire du langage G = (T, N, S, R)
• Définir les unités syntaxique du langage
• Définir les règles de production
3. Etape 3 : Implémentation en (Flex et Bison)
Prof. Rabhi Ahmed
Exemple de langage simple 6
Dans ce tutoriel, nous allons créer un compilateur qui vérifie la syntaxe d’une
expression conditionnel pour comparer les variables (en C) :
if ( a >= b )
if ( x == y && ta < u )
if ( x == y && ta < u || ba != n )
if (a >= b <) : erreur syntaxe
if (a > b =) : erreur syntaxe
Dans cet exemple on considère que l’identifiant d’une variable
doit se composer de lettres minuscules seulement
Prof. Rabhi Ahmed
Etape 1: définir les mots accepter et les unités lexicales 7
La première étape est la définition des mots acceptés et des unités lexicale
Pour simplifier ce tutoriel, on suppose que les identifiants de variables sont
formé uniquement de lettres minuscules
Mots acceptés Symboles des unités lexicale
If IF : Début d’expression
( PO : Parenthèse ouvrante
) PF : Parenthèse fermante
[a - z]* IDEN : Identifiants de variables
> , < , >= , <= , == , != CMP : Operateurs de comparaison
&& , || LG : Operateurs logique
Prof. Rabhi Ahmed
Etape 2: définir la grammaire du langage 8
Une grammaire G est définie par G = (T, N, S, R)
T : l’ensemble des symboles terminales (les mots acceptés)
N : l’ensemble des symboles non-terminales (les unités lexicales et syntaxiques)
S : l’axiome
R : l’ensemble des règles de production
T : l’ensembles des terminaux a été définie dans l’étape précédente
N : N = {EXP, CND, IF, PO, PF, IDEN, CMP, LG}
Les unités lexicales : on étaient définis dans l’étape précédente : IF, PO, PF, IDEN, CMP, LG
Les unités syntaxiques : EXP, CND
Unité syntaxique Description Exemples
EXP : Expression L’expression conditionnel if ( x > t )
conditionnel complète If ( ta == b && y <= b || p != rr)
CND : la condition Un condition constitué d’un x>t
operateur de comparaison et ta == b
deux opérandes c-a-d. y <= b
l’interieure des parenthèses p != rr Prof. Rabhi Ahmed
Etape 2: définir la grammaire du langage 9
N = { EXP, CND, IF, PO, PF, IDEN, CMP, LG }
R : les règles de productions
une expression est formé de if suivie de parenthèse
EXP → IF PO CND PF
ouvrante suivie de condition suivie de parenthèse
fermante
Prof. Rabhi Ahmed
Etape 2: définir la grammaire du langage 10
N = { EXP, CND, IF, PO, PF, IDEN, CMP, LG }
R : les règles de productions
EXP → IF PO CND PF une expression est formé de if suivie de parenthèse ouvrante
suivie de condition suivie de parenthèse fermante
CND → IDEN CMP IDEN : une condition peut être formé de : identifiant suivi d’un operateur
| CND LG CND de comparaison suivi d’un identifiant (exemple : x > y)
ou bien
Une condition peut être formé d’une condition suivi d’un operateur
logique suivie d’une condition (exemple : x > y && b = ta || y <= i )
Prof. Rabhi Ahmed
Etape 2: définir la grammaire du langage 11
N = { EXP, CND, IF, PO, PF, IDEN, CMP, LG }
R : les règles de productions
une expression est formé de if suivie de parenthèse ouvrante
EXP → IF PO CND PF
suivie de condition suivie de parenthèse fermante
: une condition peut être formé de : identifiant suivi d’un operateur
CND → IDEN CMP IDEN de comparaison suivi d’un identifiant (exemple : x > y)
| CND LG CND ou bien
Une condition peut être formé d’une condition suivi d’un operateur
logique suivie d’une condition (exemple : x > y && b = ta || y <= i )
Pour créer un analyseur syntaxique avec Bison on a besoin
seulement des règles de productions dont la partie gauche est
une unité syntaxique
Prof. Rabhi Ahmed
Etape 2: définir la grammaire du langage 12
N = { EXP, CND, IF, PO, PF, IDEN, CMP, LG }
R : les règles de productions
EXP → IF PO CND PF une expression est formé de if suivie de parenthèse ouvrante
suivie de condition suivie de parenthèse fermante
: une condition peut être formé de : identifiant suivi d’un operateur de
CND → IDEN CMP IDEN comparaison suivi d’un identifiant exemple : x > y
| CND LG CND ou bien
Une condition peut être formé d’une condition suivi d’un operateur logique suivie
d’une condition exemple : x > y && b = ta || y <= i
IF → if
PO → ( CMP → > | < | >= | <= | == | !=
PF → ) LG → && | ||
IDEN → [a - z]*
Prof. Rabhi Ahmed
Etape 3: implémentation avec Flex et Bison 13
Contenu du fichier Bison « parserIf.y »
• Tokens : déclaration les unités lexicales : IF, PO, PF, IDEN, CMP, LG
• Les règles de production
• Fonction retournant un message d’erreur en cas d’erreur syntaxique.
%{
#include<stdio.h>
void yyerror ( char *s ){ Fonction pour retourner une
printf("%s\n", s); erreur syntaxique
}
%}
%token CMP LG IF IDEN PO PF Les unités lexicales
%%
EXP : IF PO CND PF
CND : CND LG CND Les règles de production
| IDEN CMP IDEN
;
%%
main(){
yyparse();
} Prof. Rabhi Ahmed
Etape 3: implémentation avec Flex et Bison 14
Enregistrement du fichier Bison « parserIf.y »
Lors de l’enregistrement, il faut
sélectionner « all types » dans le
menu type
Puis donner un nom à votre
fichier avec l’extension .y :
parserIf.y
Prof. Rabhi Ahmed
Etape 3: implémentation avec Flex et Bison 15
Contenu du fichier Flex « scannerIf.lex »
• Expression régulière pour chaque unité lexicale
• Fonction pour interrompre le traitement en cas d’erreur lexical
%option noyywrap
%{
#include "parserIf.tab.h" NomDuFichierBison.tab.h
%}
%%
"<"|"=="|">"|"<"|"<="|">="|"!=" {return CMP;}
"&&"|"||" {return LG;} Retourne les identifiants des
"if" {return IF;} l’unités lexicale comme
[a-z]+ {return IDEN;} déclaré dans le fichier Bison
"(" {return PO;}
")" {return PF;}
"\n" {};
" " {}; Si Flex rencontre un mot
. {printf("%s:erreur lexical\n",yytext); exit(0);} non accepté il l’affiche et
%% arrête l’execution
Prof. Rabhi Ahmed
Etape 3: implémentation avec Flex et Bison 16
Enregistrement du fichier Flex « scannerIf.lex »
Lors de l’enregistrement, il faut
sélectionner « all types » dans le
menu type
Puis donner un nom à votre
fichier avec l’extension .y :
scannerIf.lex
Prof. Rabhi Ahmed
Etape 3: implémentation avec Flex et Bison 17
Architecture d’execution
Prof. Rabhi Ahmed
Exécution et création du compilateur 18
Etape 0
Notre dossier contient pour l’instant 2 fichiers :
• parserIf.y : Contenant le fichier Bison
• scannerIf.y : Contenant le fichier Flex
Prof. Rabhi Ahmed
Exécution et création du compilateur 19
Etape 1 : compiler le fichier Bison
La commande:
bison -d parserIf.y
Crée ces deux fichiers
parserIf.tab.c contient le programme C
qui fait l’analyse syntaxique
Si vous ne mettez pas le paramètre -d
le fichier .h ne sera pas crée
Prof. Rabhi Ahmed
Exécution et création du compilateur 20
Etape 2 : compiler le fichier Flex
La commande:
flex scannerIf.lex
Crée le fichier suivant :
Le fichier lex.yy.c contient le
programme C de l’analyseur lexicale
Prof. Rabhi Ahmed
Exécution et création du compilateur 21
Etape 3 : compiler les deux codes C en même temps
La commande:
gcc -o monCompilateur parserIf.tab.c lex.yy.c
Crée l’executable contenant notre compilateur
Prof. Rabhi Ahmed
Tester le compilateur 22
Pour tester on vas créer un fichier texte contenant le texte à analyser
Le texte est correcte lexicalement
et syntaxiquement, donc le
compilateur ne déclare rien
Prof. Rabhi Ahmed
Tester le compilateur 23
Cas : erreur lexicale
Le caractère + n’est inclus en aucun mot
accepté
Donc le compilateur affiche le mot non
accepté puis arrête le traitement
Prof. Rabhi Ahmed
Tester le compilateur 24
Cas : erreur syntaxique
Dans ce cas tout les mots d’entrée sont
acceptés mais ils ne respectent pas la
grammaire (l’ordre que nous avons défini
dans Bison)
Prof. Rabhi Ahmed
