Rapport

LES EXPRESSIONS REGULIERES, LES AUTOMATES A ETAT FINI ET L’INITIALISATION A L’ANALYSE
SYNTAXIQUE FLEX
UNIVERSITE JOSEPH KI-ZERBO (UJKZ)
*******
INSTITUT BURKINABE DES ARTS ET METIERS (IBAM)
RAPPORT DE TRAVAIL PRATIQUE
LES EXPRESSIONS REGULIERES, LES AUTOMATES A ETAT

FINI ET L’INITIALISATION A L’ANALYSE SYNTAXIQUE FLEX
Présenté par : TIEMTORE Styve Guy Anderson
Professeur : Dr GUINKO Ferdinand

Maitre de conférence
presente par styve guy Anderson Tiemtore 1

SYNTAXIQUE FLEX
SOMMAIRE
INTRODUCTION................................................................................................................................3
A. Partie de l’initialisation à l’analyseur syntaxique flex...........................................................4
1. Premiers Pas : Analyse lexicale pour un langage informatique............................................5
Reconnaissance d'identificateurs.............................................................................................5
Analyse lexicale.........................................................................................................................8
Modifications et complétions de la spécification pour reconnaître plusieurs unités
lexicales..................................................................................................................................8
Complétion de l'analyseur avec de nouvelles fonctionnalités............................................9
2. Deuxième Pas : Commentaires en C....................................................................................11
Traitement d'un commentaire sur une ou plusieurs lignes.................................................11
Gestion de commentaires successifs......................................................................................15
Première stratégie : Utilisation d'une expression régulière complexe............................15
Deuxième stratégie : Utilisation d'une variable de comptage pour gérer l'imbrication
des commentaires................................................................................................................16
Troisième stratégie : Utilisation des "start-conditions" avec un super état
COMMENTAIRE..............................................................................................................18
Gestion de commentaires imbriqués (avancé)......................................................................20
CONCLUSION...................................................................................................................................22

SYNTAXIQUE FLEX
INTRODUCTION
L’analyse lexicale est une étape fondamentale dans le processus de compilation des langages
de programmation. Cette étape consiste à transformer un texte source brut en une série
d’unités lexicales, ou tokens, qui seront ensuite utilisées par les phases ultérieures du
compilateur, notamment l’analyse syntaxique. Pour accomplir cette tâche, des outils
spécialisés, tels que Flex, sont largement utilisés.
Flex (Fast Lexical Analyzer) est un générateur d’analyseurs lexicaux qui permet de décrire
des motifs à l’aide d’expressions régulières et de les associer à des actions spécifiques. Il se
distingue par sa simplicité d’utilisation et son efficacité dans la génération de code C, qui
implémente l’analyseur lexical basé sur les règles définies par l’utilisateur.
Cette partie se concentre sur les premières étapes pour débuter avec Flex : depuis la mise en
place de l’environnement de travail et la création d’un projet structuré, jusqu’au
développement d’un analyseur lexical fonctionnel. Les concepts théoriques sont illustrés par
des cas pratiques, comme la reconnaissance d’identificateurs ou la gestion des commentaires
dans un code source. Ces exemples permettent de comprendre les bases de Flex et d’explorer
ses fonctionnalités avancées, tout en posant les fondations pour des développements plus
complexes.

SYNTAXIQUE FLEX
A. Partie de l’initialisation à l’analyseur syntaxique flex
L'initialisation d'un analyseur syntaxique avec Flex marque le début d'un voyage fascinant
dans le monde du traitement lexical, où chaque ligne de code devient une opportunité de
transformer des séquences de caractères en unités de sens significatifs, ouvrant ainsi la voie à
une compréhension plus profonde et structurée des langages de programmation.
Pour donner vie à notre analyseur syntaxique et transformer nos idées en code opérationnel,
la première étape cruciale consiste à installer et configurer l'outil Flex de manière méthodique
et précise, en s'assurant que chaque composant nécessaire est correctement mis en place.
Installation de fex
L’installation de flex peut se faire sur plusieurs systèmes d’exploitation à savoir sur
Windows, MacOs et Linux. Voici les étapes à suivre :
Sur Windows
 Téléchargez et installez Flex via Cygwin ou une distribution Windows de GNU
Tools.
 Ajoutez le chemin de Flex à la variable d'environnement PATH.
Sur macOS :
 Utilisez Homebrew pour installer Flex :
brew install flex
Sur Linux (Ubuntu) :
 Ouvrez un terminal et entrez les commande :
sudo apt-get update

sudo apt-get install flex
Après l’installation de flex vous pouvez vérifier s’il est bel et bien installé en tapant la
commande suivante sur le terminal :
flex --version
L’utilisation en fonction de son système d’exploitation pourra avoir flex sur sa machine.Mais
dans notre travail nous nous focaliserons sur le système linux. Et pour ce faire nous allons
organiser notre travail comme de la façon suivante :
 Nous avons créé un dossier principal pour le projet portant comme nom
"TiemtoreAnderson "
 À l'intérieur de ce dossier, nous avons créé les sous-dossiers suivants :

SYNTAXIQUE FLEX
 "exercices" : pour les différents exercices dans lequel se trouve les sous-
dossiers suivants :
o "comments"
o "first00"
o "first01"
o "first02"
 "data" : pour les fichiers de données de test
 "common" : pour les fichiers communs comme les prototypes et le Makefile
1. Premiers Pas : Analyse lexicale pour un langage

informatique
Reconnaissance d'identificateurs
Dans cette partie l'analyseur a pour objectif de reconnaître des mots qui commencent par une
lettre et peuvent être suivis de plusieurs lettres ou chiffres. Pour cela nous avons créé un
fichier first00.flex dans le sous-dossier flex00 du sous-dossier exercice.
 Contenu du fichier first00.flex

Le fichier Flex contient la définition des motifs que l'analyseur reconnaîtra. Voici le contenu
du fichier :
%%
[a-zA-Z][a-zA-Z0-9]* printf("[ %s ]", yytext );
%%
 Explication du fichier :
La première règle indique que l'analyseur doit reconnaître des mots (tokens) qui commencent
par une lettre ([a-zA-Z]) et peuvent être suivis de zéro ou plusieurs caractères
alphanumériques ([a-zA-Z0-9]*).
Chaque mot reconnu est affiché à l'écran dans un format spécifique à l'aide de printf,
encapsulé dans des crochets.
Dans cette partie nous avons créé le fichier first.data dans le sous-dossier data.
 Contenu du fichier de test first.data
Pour tester l’analyseur, nous utilisons le fichier suivant, qui contient différents éléments de
code :
for( i=0; i < 10; i++ ) {

SYNTAXIQUE FLEX
truc[i] = 0;
machin = 12.3;
bidule = .0;
}
 Etape à suivre :
 Génération de l'analyseur lexical avec Flex :
La commande suivante a été utilisée pour générer le fichier source C à partir du

fichier .flex :
flex first00.flex
Cette commande produit un fichier nommé lex.yy.c, qui contient le code C de

l'analyseur lexical.
 Compilation du fichier généré :
La commande suivante compile le fichier lex.yy.c pour produire un exécutable :
gcc lex.yy.c -ll
L'option -ll lie la bibliothèque Flex nécessaire pour l'exécution.
 Exécution de l'analyseur lexical :
Le fichier exécutable produit (a.out) est utilisé pour analyser un fichier d'entrée
(first.data) avec la commande suivante :
./a.out < ../../data/first.data
 Résultats
Lors de l'exécution de la commande ci-dessus, l'analyseur lexical traite le fichier first.data et
identifie les mots qui répondent aux critères spécifiés.
Cette figure ci-dessous illustre les différentes étapes de la compilation, l’exécution jusqu’au
résultat.

SYNTAXIQUE FLEX
Nous remarquons que tous les mots commençant par une lettre, sont mis en crochets et le
reste ignoré.
Dans cette partie, pour intégrer la spécification "first00.flex" avec un Makefile générique,
nous allons tirer parti des fichiers prototypes fournis, tels que Makefile, proto-color.h,
et proto0.flex en renommant "first00.flex" par "first01.flex". Ces fichiers nous permettront de
structurer notre projet de manière organisée et d'automatiser le processus de compilation.
Voici les fichiers utilisés :
 Makefile : Ce fichier gère les règles de compilation et les commandes nécessaires

pour construire notre analyseur.
 proto-color.h : Ce fichier fournit des macros pour des impressions colorées sur la
console, ce qui facilite le débogage et le traçage.
 proto0.flex : Ce fichier contient une spécification Flex "légère" qui peut être utilisée
sans Bison.
Dans cette partie nous avons créé le fichier first01.flex dans le sous-dossier flex01 du sous-
dossier exercice.
 Compilation et Exécution :
Pour compiler et exécuter l'analyseur lexical, les étapes suivantes ont été suivies :
 Génération de l’analyseur lexical à partir de la spécification Flex :
make first01
La commande make first01 a été utilisée pour compiler le fichier first01.flex à l'aide
de Flex et GCC. Elle génère un exécutable appelé first01.
 Exécution de l’analyseur avec le fichier de test :
./first01 < ../../data/first.data
La commande ./first01 < ../data/first.data a été utilisée pour exécuter l'analyseur

lexical sur le fichier de données first.data.

SYNTAXIQUE FLEX
La figure ci-dessous nous montre le processus de compilation et d’exécution jusqu’au résultat

obtenu :
Les résultats affichés représentent l'analyse ligne par ligne du fichier d'entrée. Les différents
tokens identifiés par l'analyseur sont classés dans plusieurs catégories.
 [VALIDE:] : Ce préfixe semble indiquer que le token reconnu correspond à un
identificateur ou un mot valide selon les règles définies dans le fichier .flex.
 [INCONNU:] : Les éléments classés comme "inconnus" ne correspondent à aucune
règle spécifique dans le fichier .flex. Cela pourrait inclure des caractères spéciaux ou
des combinaisons inattendues.
 [WHITESPACE:] : Cette catégorie identifie les espaces blancs (espaces, tabulations,
retours à la ligne).
 \n : Le retour à la ligne est explicitement indiqué, montrant la fin de chaque ligne
d'entrée.
Analyse lexicale
Cette partie de l'exercice demande de modifier et compléter la spécification d'un analyseur

lexical en Flex pour qu'il puisse reconnaître et distinguer plusieurs catégories de jetons, et
afficher chaque fragment reconnu selon sa catégorie. Voici une explication détaillée de ce qui
est demandé :
Modifications et complétions de la spécification pour reconnaître plusieurs unités

lexicales
Nous aurons entre autres :

 La reconnaissance des mots-clés du langage : L'analyseur lexical doit être capable
de reconnaître des mots-clés comme for, while, if, etc. Chaque mot-clé doit être
identifié et catégorisé en tant que tel. Lorsqu'un mot-clé est détecté, il doit être affiché
dans un format particulier.
 La reconnaissance des opérateurs arithmétiques : L'analyseur doit reconnaître les
opérateurs arithmétiques de base comme +, *, /, et -. Ces opérateurs doivent être
catégorisés et affichés.

SYNTAXIQUE FLEX
 La reconnaissance des opérateurs de comparaison : Les opérateurs de comparaison

<et >doivent également être identifiés et affichés dans une catégorie propre
 La reconnaissance des séparateurs : L'analyseur doit reconnaître les symboles

utilisés comme séparateurs, par exemple (, ), {, }, ;, ,, [, ]. Chaque séparateur doit
être affiché comme suit :
 Et la fonction echo()pour l'affichage : Une fonction echo()doit être définie dans le
fichier de spécification Flex. Elle sera utilisée pour afficher chaque unité lexicale
reconnue, en indiquant sa catégorie et son contenu dans un format clair comme
montré ci-dessus.
Complétion de l'analyseur avec de nouvelles fonctionnalités
 Reconnaissance des valeurs numériques : L'analyseur doit être capable de

reconnaître les valeurs numériques, à la fois entières et flottantes. Par exemple :
 Une valeur entière comme 42 sera reconnue et affichée
 Une valeur flottante comme 3.14 sera également reconnue et affichée
 Reconnaissance des identificateurs ou symboles : L'analyseur doit reconnaître les
noms de variables ou identificateurs, c'est-à-dire toute séquence de caractères
alphanumériques commençant par une lettre.
 Mise en place d'une règle-balai (ou wildcard Rule) : Cette règle est utilisée pour
capturer et afficher tout caractère qui ne correspond pas aux autres règles définies.
Ces caractères non reconnus seront affichés de manière spéciale, par exemple :
 Gestion des espaces, tabulations et retours à la ligne : L'analyseur doit ignorer les
caractères invisibles comme les espaces ( ), tabulations ( \t) et retours à la ligne ( \n).
Ces caractères ne doivent pas être affichés, mais ils doivent être pris en compte pour
permettre une analyse correcte du texte.
 Élimination des derniers caractères non reconnus : Il est possible d'ajouter des
règles pour ignorer ou traiter les derniers caractères qui ne sont pas reconnus par les
règles précédentes, afin d'éviter des erreurs d'analyse.
 Compatibilité avec les fichiers Unix, DOS, et Mac : La spécification mentionne
trois versions de fichiers de test ( first.data, first.data_DOS, first.data_MAC). Ces
fichiers se différencient principalement par leur manière de gérer les fins de ligne :
 Unix utilise le caractère \n(LF - Line Feed) pour les retours à la ligne.
 DOS/Windows utilise les caractères \r\n(CRLF - Carriage Return + Line
Feed).
 Macintosh (anciennes versions) utilise le caractère \r(CR - Carriage Return)
pour les retours à la ligne.
L'analyseur doit être compatible avec ces trois formats, ce qui signifie qu'il doit gérer
correctement les différentes conventions de fin de ligne.
Dans cette partie nous avons créé le fichier first02.flex dans le sous-dossier flex02 du sous-
dossier exercice et le fichier first.data dans le sous dossier data.

SYNTAXIQUE FLEX
 Copie des fichiers Makefile et proto-color.h
cp ../../common/Makefile .
cp ../../common/proto-color.h
Les fichiers de common/Makefile et common/proto-color.h sont copiés dans le

répertoire de travail actuel.
 Génération du fichier C à partir de la spécification Flex :

flex first02.flex
La commande flex est utilisée avec un fichier source first02.flex. Cela génère un
fichier C (souvent nommé lex.yy.c) à partir des définitions d'un analyseur lexical
écrites dans le fichier .flex.
gcc lex.yy.c -ll
Le fichier généré lex.yy.c est compilé avec gcc pour produire un exécutable, en
l'occurrence first02.
 Génération de l’analyseur lexical à partir de la spécification Flex :
make first02
La commande make first02 a été utilisée pour compiler le fichier first02.flex à l'aide
de Flex et GCC. Elle génère un exécutable appelé first02.
./first01 < ../../data/first.data
L'analyseur lexical compilé est exécuté sur un fichier de données d'entrée first.data.
Le fichier de données est traité selon les règles définies dans le fichier .flex.
La figure ci-dessous nous montre le processus de compilation et d’exécution jusqu’au

résultat:

SYNTAXIQUE FLEX
La sortie montre la reconnaissance des tokens suivants :
 [IDENTIFIER]: Représente des mots-clés ou identifiants trouvés dans les données.

 [WHITESPACE]: Espaces blancs ou séparateurs.
 [INCONNU]: Cela indique qu'un token inconnu ou non défini a été trouvé.
 [NUMBER]: Des nombres dans les données.
 [SEPARATOR]: Caractères utilisés comme séparateurs tels que [, ], etc.
L'analyseur lexical a décodé les informations dans les données en identifiant les types de
tokens selon les règles spécifiées dans le fichier .flex.
2. Deuxième Pas : Commentaires en C
Le but est d'écrire un analyseur lexical permettant de reconnaître et de supprimer les

commentaires C du type /*... */.
Traitement d'un commentaire sur une ou plusieurs lignes
Cette partie du projet vise à développer un analyseur lexical capable de reconnaître et de

supprimer les commentaires en langage C, qui sont délimités par /*et */. Les commentaires
peuvent être sur une seule ligne ou s'étendre sur plusieurs lignes.
Étapes à suivre :
 Expression régulière pour les commentaires C : On doit écrire une expression

régulière qui détecte tout texte encadré par /*et */. Cette expression doit être
suffisamment flexible pour capturer les commentaires à la fois sur une seule ligne et
ceux sur plusieurs lignes.
 Première version de l'analyseur :

SYNTAXIQUE FLEX
 Dans un premier temps, l'analyseur doit simplement détecter les commentaires

et afficher leur contenu sans les supprimer. Cela permet de s'assurer que
l'expression fonctionne régulièrement correctement et que tous les
commentaires sont bien capturés.
 Par exemple, dans un fichier contenant du code avec un commentaire comme i
= 5; /* initialisation au nombre d'objets */, l'analyseur devrait afficher
uniquement le texte initialisation au nombre d'objets.
Dans cette partie nous avons créé le fichier comment1.flex et les fichiers comment1.data et
comment2.data dans le sous dossier data.
flex comment1.flex
La commande flex comment1.flex génère le fichier lex.yy.c à partir du fichier
comment1.flex, qui contient les règles lexicales pour analyser des commentaires.
gcc lex.yy.c –o comment1 –lfl
Vous compilez le fichier généré avec gcc en créant un exécutable nommé comment1.
Le drapeau -lfl est utilisé pour lier la bibliothèque Flex qui fournit des fonctions
comme yylex().
 Exécution de l’analyseur avec les fichiers de test :
./comment1 < coment1.data1
L'exécutable comment1 est ensuite exécuté avec le fichier de données comment.data1

en tant qu'entrée. Le programme scanne ce fichier en cherchant les motifs définis dans
comment1.flex.
./comment1 < coment1.data2
Vous exécutez ensuite l'analyseur lexical comment1 sur un autre fichier de données
comment.data2. Le programme scanne ce fichier en cherchant les motifs définis dans
comment1.flex.
Les figures suivantes montre les résultats de nos tests pour l’affichage des commentaires:

SYNTAXIQUE FLEX
Le texte "Contenu du commentaire : initialisation au nombre d'objets" est affiché, ce qui

semble être le résultat de l'analyse du fichier comment.data1. Cela indique que l'analyseur a
probablement reconnu un commentaire ou une chaîne de texte spécifique correspondant à une
règle dans le fichier .flex.
Le texte "Contenu du commentaire : ici je dois écrire le corps de ma fonction mais pour
l’instant elle est vide " est affiché, ce qui semble être le résultat de l'analyse du fichier
comment.data2. Cela indique que l'analyseur a probablement reconnu un commentaire ou une
chaîne de texte spécifique correspondant à une règle dans le fichier .flex.
 Suppression des commentaires :

 Une fois la détection correcte des commentaires validés, il faut modifier
l'analyseur pour supprimer les commentaires du texte source sans les afficher.
Seul le code sans commentaires sera conservé. Par exemple, le code i = 5; /*
initialisation au nombre d'objets */deviendrai = 5;.
 Test avec différents formats de commentaires :
 L'analyseur doit être testé avec des fichiers contenant des commentaires sur
une ligne ainsi que des fichiers avec des commentaires multi-lignes pour
s'assurer que la suppression fonctionne dans tous les cas.
 Finalité :
 L'objectif final est que l'analyseur soit capable de supprimer tout commentaire
sans modifier le code qui n'est pas commenté, afin de nettoyer le fichier source
des annotations non exécutables.
Dans cette partie nous avons créé le fichier comment2.flex dans le sous dossier data.

SYNTAXIQUE FLEX
flex comment2.flex
La commande flex comment1.flex génère le fichier lex.yy.c à partir du fichier
comment2.flex, qui contient les règles lexicales pour analyser des commentaires.
gcc lex.yy.c –o comment2 –lfl
Vous compilez le fichier généré avec gcc en créant un exécutable nommé comment1.
Le drapeau -lfl est utilisé pour lier la bibliothèque Flex qui fournit des fonctions
comme yylex().
./comment2 < coment.data1
L'exécutable comment2 est ensuite exécuté avec le fichier de données comment.data1

en tant qu'entrée. Le programme scanne ce fichier en cherchant les motifs définis dans
comment1.flex
./comment2 < coment.data2
Vous exécutez ensuite l'analyseur lexical comment2 sur un autre fichier de données
comment.data2. Le programme scanne ce fichier en cherchant les motifs définis dans
comment2.flex.
Les figures suivantes montre les résultats de nos tests pour la suppression des commentaires :
Nous remarquons que le résultat obtenu est uniquement i = 5 ;.
Nous remarquons que le résultat obtenu est uniquement la fonction void mafonction () {}.

SYNTAXIQUE FLEX
Gestion de commentaires successifs
Cette section décrit les exigences pour l'élaboration d'un analyseur lexical capable de traiter
plusieurs commentaires successifs dans un fichier source. L'objectif est d'éviter que l'effet
"glouton" de Flex n'agrège ces commentaires en un seul bloc. Trois stratégies différentes sont
proposées pour y parvenir :
Première stratégie : Utilisation d'une expression régulière complexe
La première consiste à utiliser une expression régulière plus élaborée pour s'assurer que
chaque commentaire est traité stratégiquement, même s'ils sont consécutifs. L'effet "glouton"
de Flex pourrait amener l'analyseur à consommer tout ce qui se trouve entre le premier /*et le
dernier */d'un bloc de commentaires successifs, ce qui regrouperait ces commentaires.
Dans cette partie nous avons créé le fichier comment_analyzer1.flex dans le dossier
comments du sous dossier exercice et le fichier comment3.data dans le sous dossier data.
flex comment_analyzer1.flex

Flex est un générateur d'analyseurs lexicaux, qui crée un programme C
capable de lire et d'analyser du texte selon les règles définies dans un
fichier .flex.
 Le fichier comment_analyzer1.flex contient des spécifications (règles
lexicographiques) qui définissent les types de tokens ou motifs (comme des
commentaires dans du code, des mots-clés, etc.) à reconnaître dans le texte
d'entrée.
 Cette commande génère un fichier C nommé par défaut lex.yy.c. Ce fichier
contient le code source de l'analyseur lexical, basé sur vos spécifications Flex.
gcc lex.yy.c –o comment_analyzer1 -lfl

Ici, nous utilisons gcc (GNU Compiler Collection) pour compiler le fichier C
généré (lex.yy.c) afin de créer un exécutable nommé comment_analyzer1.
 L'option -o comment_analyzer1 indique à GCC de nommer l'exécutable
produit sous ce nom.
 L'option -lfl est utilisée pour lier la bibliothèque Flex (libfl.a), qui contient les
fonctions nécessaires pour le fonctionnement de l'analyseur lexical généré
(comme yylex()).

SYNTAXIQUE FLEX
./comment_analyzer1 < ../../data/coment.data3

 Vous exécutez l'analyseur lexical compilé (comment_analyzer1) en
redirigeant l'entrée standard à partir d'un fichier de test (coment.data3). Cela
signifie que le contenu de coment.data3 est lu et analysé par l'analyseur
lexical.
 Le fichier coment.data3 contient probablement des données (par exemple, du
texte, du code source, etc.) qui seront analysées selon les règles définies dans
comment_analyzer1.flex.
 L'analyseur lexical lira le fichier, reconnaîtra les tokens (comme des
commentaires ou d'autres éléments) en fonction des règles Flex, et produira
une sortie décrivant ces tokens ou les afficher à l'écran.
 Résultat attendu :
Explication des Observations dans la Capture d'Écran
 Les commentaires sont bien détectés : Les segments /* initialisation (*) et /*

initialisation (**) sont correctement capturés par la règle des commentaires et
marqués comme [Commentaire].
 Les tokens [ANY] : Les mots contenant uniquement des lettres minuscules, comme i,
au, et nombre, sont marqués comme [ANY].
 Les tokens [UNK] : Les caractères non reconnus par les autres règles, comme =, ;, ' et
certains caractères d'apostrophes, sont marqués comme [UNK]. Cela inclut des parties
de mots contenant des symboles, comme 'objets.
 Sauts de ligne (\n) : Chaque saut de ligne est capturé par la règle \n et affiché en tant
que [\\n].
Deuxième stratégie : Utilisation d'une variable de comptage pour gérer l'imbrication

des commentaires
Cette méthode consiste à gérer l'imbrication des commentaires en utilisant une variable qui
convient aux niveaux d'ouverture et de fermeture des commentaires. Cela est particulièrement
utile dans le cas où des commentaires sont imbriqués (bien que les commentaires imbriqués
ne soient pas autorisés en standard C, cela pourrait arriver dans d'autres langages).
 Approche :
 Chaque fois qu'un /*est rencontré, la variable d'imbrication est incrémentée.

SYNTAXIQUE FLEX
 Chaque fois qu'un */est rencontré, la variable est décrémentée.

 Le commentaire n'est considéré comme terminé que lorsque la variable revient
à zéro, ce qui signifie que toutes les paires /* ... */ont été fermées.
comments du sous dossier exercice.
Cette commande utilise Flex pour générer un analyseur lexical basé sur le fichier de
spécifications comment_analyzer2.flex. Flex produit un fichier C nommé par défaut
lex.yy.c, contenant le code source de l’analyseur lexical. Le fichier Flex (.flex)
contient les règles pour analyser les tokens dans le texte d'entrée. Flex traduit ces
règles en un programme C.
Cette commande compile le fichier généré lex.yy.c en un exécutable nommé

comment_analyzer2.
Description :
 -o comment_analyzer2 : Spécifie que l'exécutable compilé doit être nommé

comment_analyzer2.
 -lfl : Lien avec la bibliothèque libfl (fournie avec Flex), qui contient des
fonctions nécessaires pour l’analyseur lexical, comme yywrap.

Cette commande exécute l’analyseur lexical pour traiter le fichier de test
coment.data3.
Description :
 ./comment_analyzer2 : Exécute l'analyseur généré.

 < ../../data/coment.data3 : Redirige le contenu du fichier coment.data3
comme entrée pour l’analyseur.

SYNTAXIQUE FLEX
Explication des Observations dans la Capture d'Écran
 Mots simples (ANY) : Tous les mots composés de lettres minuscules (comme i, au,
nombre, etc.) sont reconnus comme ANY.
 Jetons inconnus (UNK) : Les opérateurs (=, ;), chiffres (5, 6), lettres isolées (d) ou
avec apostrophes ('o) et symboles spécifiques sont marqués comme UNK.
 Commentaires (Commentaire) :
Les délimitations de commentaires /* et */ sont bien reconnues grâce au suivi

d'imbrication (niveau_imbrication).
Leur contenu interne (initialisation, (*), etc.) est traité comme UNK.
 Structure cohérente : Le programme suit les règles définies mais ne reconnaît pas les
éléments hors des séquences prévues (par exemple, contenu des commentaires ou
chiffres).
Troisième stratégie : Utilisation des "start-conditions" avec un super état

COMMENTAIRE
Flex permet de définir des "start-conditions" pour passer d'un état à un autre dans l'automate,
ce qui est utile pour des analyses plus complexes comme la gestion des commentaires. Dans
cette méthode, nous définissons un état spécifique, nommé COMMENT, qui sera activé dès
qu'un commentaire est détecté.
 Approche :
Nous définissons un état COMMENT dans lequel l'analyseur entre lorsqu'il rencontre un /*.
Pendant que l'analyseur est dans cet état, tout le contenu du commentaire est ignoré.
L'analyseur retourne à l'état initial lorsqu'il rencontre */, ce qui indique la fin du
commentaire.

SYNTAXIQUE FLEX
 Avec une expression complexe régulière, chaque commentaire sera traité

séparément en utilisant une expression suffisamment robuste pour détecter la
fermeture de chaque bloc /* ... */.
 Avec une variable de comptage, même si des niveaux d'imbrication sont présents,
chaque commentaire est capturé et fermé de manière correcte. Dans ce cas, il n'y a pas
de risque d'amalgame entre les deux commentaires.
 Avec les "start-conditions", l'automate entre dans un état spécifique pour chaque
commentaire et ne revient à l'état initial que lorsque la fin du commentaire est
détectée. Cela garantit que chaque commentaire est traité séparément.
comments du sous dossier exercice.
Cette commande utilise Flex pour générer un analyseur lexical basé sur le fichier de
spécifications comment_analyzer3.flex. Flex produit un fichier C nommé par défaut
lex.yy.c, contenant le code source de l’analyseur lexical. Le fichier Flex (.flex)
contient les règles pour analyser les tokens dans le texte d'entrée. Flex traduit ces
règles en un programme C.
Cette commande compile le fichier généré lex.yy.c en un exécutable nommé

comment_analyzer2.
Description :
 -o comment_analyzer3 : Spécifie que l'exécutable compilé doit être nommé

comment_analyzer2.
 -lfl : Lien avec la bibliothèque libfl (fournie avec Flex), qui contient des
fonctions nécessaires pour l’analyseur lexical, comme yywrap.

coment.data3.

SYNTAXIQUE FLEX
Description :
 ./comment_analyzer3 : Exécute l'analyseur généré.

Le résultat obtenu montre que seules les parties non commentées du fichier d'entrée sont
affichées dans la sortie. Cela suggère que les règles définies dans comment_analyzer3.flex
ne gèrent pas ou n'affichent pas correctement les commentaires.
Gestion de commentaires imbriqués (avancé)
Dans cette section, il est demandé d'écrire un analyseur lexical capable de gérer les
commentaires imbriqués, ce qui n'est pas conforme à la syntaxe du langage C.
Théoriquement, les commentaires imbriqués constituent un langage algébrique non régulier,
appelé "langage de Dyck", qui ne peut pas être reconnu par des expressions régulières
simples.
 Objectif :
L'objectif est de développer un analyseur qui non seulement reconnaît ces imbrications, mais
qui suit également le niveau d'imbrication des commentaires à l'aide d'une "start-condition"
appelée COMMENT et d'une variable level pour compter les niveaux.
 Réalisation :
La réalisation va consister à :
 La gestion de l'imbrication : Une variable level est utilisée pour suivre la profondeur
des commentaires imbriqués. À chaque nouvelle ouverture de commentaire ( /*), la
variable est incrémentée, et à chaque nouvelle ouverture de commentaire ( */), elle
fermeture est décrémentée. Cela permet de gérer correctement les différents niveaux
d'imbrication.
 La start-conditionCOMMENT : L'utilisation d'une start-condition dans Flex permet
de traiter les commentaires imbriqués modifiant le reste du code. Dès qu'un

SYNTAXIQUE FLEX
commentaire est détecté, l'analyseur bascule en mode COMMENT pour suivre et

compter les niveaux d'imbrication.
 Et l’affichage du niveau d'imbrication : Pour visualiser le niveau d'imbrication, la
fonction SET_COLOR(i) est utilisée. Chaque niveau de commentaire est affiché avec
une couleur différente, facilitant ainsi la compréhension visuelle de l'imbrication.
Dans cette partie nous avons créé le fichier comment_imbrique.flex dans le dossier comments
du sous dossier exercice et le fichier comment.data4 dans le sous dossier data.
./comment_imbrique < ../../data/coment.data4

coment.data4.
Description :
 ./comment_imbrique : Exécute l'analyseur généré.

Nous remarquons que ce programme traite les commentaires imbriqués de type /* ... */ et
modifie la couleur de sortie en fonction du niveau d'imbrication.
CONCLUSION

SYNTAXIQUE FLEX
En conclusion, notre travail pratique sur la mise en œuvre d'un analyseur lexical à l'aide de
l'outil Flex a été une expérience enrichissante qui nous a permis d'approfondir notre
compréhension des principes fondamentaux de l'analyse lexicale et de la compilation des
langages de programmation. En intégrant des fonctionnalités pour la reconnaissance des
commentaires, y compris des cas complexes tels que les commentaires multi-lignes et
imbriqués, nous avons été confrontés à des défis techniques qui nous ont poussés à
développer des solutions innovantes. Ce projet a non seulement renforcé nos compétences en
matière de programmation, mais il a également illustré l'importance d'une conception
méthodique et rigoureuse pour garantir que des éléments non pertinents, tels que les
commentaires, soient correctement exclus du processus d'analyse syntaxique. En synthèse, ce
rapport documente non seulement les étapes pratiques de notre développement, mais il
témoigne aussi d'une immersion concrète dans le domaine des langages informatiques et des
outils de compilation, préparant ainsi le terrain pour de futures applications et
approfondissements dans ce domaine.

Rapport

Transféré par

Droits d'auteur :

Formats disponibles

Rapport

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

Rapport

Transféré par

Droits d'auteur :

Formats disponibles

LES EXPRESSIONS REGULIERES, LES AUTOMATES A ETAT FINI ET L’INITIALISATION A L’ANALYSE

UNIVERSITE JOSEPH KI-ZERBO (UJKZ)

INSTITUT BURKINABE DES ARTS ET METIERS (IBAM)

RAPPORT DE TRAVAIL PRATIQUE

LES EXPRESSIONS REGULIERES, LES AUTOMATES A ETAT

Présenté par : TIEMTORE Styve Guy Anderson

Professeur : Dr GUINKO Ferdinand

presente par styve guy Anderson Tiemtore 1

presente par styve guy Anderson Tiemtore 2

presente par styve guy Anderson Tiemtore 3

A. Partie de l’initialisation à l’analyseur syntaxique flex

 Utilisez Homebrew pour installer Flex :

brew install flex

Sur Linux (Ubuntu) :

 Ouvrez un terminal et entrez les commande :

sudo apt-get update

presente par styve guy Anderson Tiemtore 4

1. Premiers Pas : Analyse lexicale pour un langage

 Contenu du fichier first00.flex

presente par styve guy Anderson Tiemtore 5

 Génération de l'analyseur lexical avec Flex :

La commande suivante a été utilisée pour générer le fichier source C à partir du

Cette commande produit un fichier nommé lex.yy.c, qui contient le code C de

 Compilation du fichier généré :

La commande suivante compile le fichier lex.yy.c pour produire un exécutable :

gcc lex.yy.c -ll

L'option -ll lie la bibliothèque Flex nécessaire pour l'exécution.

 Exécution de l'analyseur lexical :

./a.out < ../../data/first.data

presente par styve guy Anderson Tiemtore 6

 Makefile : Ce fichier gère les règles de compilation et les commandes nécessaires

La commande ./first01 < ../data/first.data a été utilisée pour exécuter l'analyseur

presente par styve guy Anderson Tiemtore 7

La figure ci-dessous nous montre le processus de compilation et d’exécution jusqu’au résultat

Cette partie de l'exercice demande de modifier et compléter la spécification d'un analyseur

Modifications et complétions de la spécification pour reconnaître plusieurs unités

Nous aurons entre autres :

presente par styve guy Anderson Tiemtore 8

 La reconnaissance des opérateurs de comparaison : Les opérateurs de comparaison

 La reconnaissance des séparateurs : L'analyseur doit reconnaître les symboles

Complétion de l'analyseur avec de nouvelles fonctionnalités

 Reconnaissance des valeurs numériques : L'analyseur doit être capable de

presente par styve guy Anderson Tiemtore 9

Les fichiers de common/Makefile et common/proto-color.h sont copiés dans le

 Génération du fichier C à partir de la spécification Flex :

 Exécution de l’analyseur avec le fichier de test :

./first01 < ../../data/first.data

La figure ci-dessous nous montre le processus de compilation et d’exécution jusqu’au

presente par styve guy Anderson Tiemtore 10

La sortie montre la reconnaissance des tokens suivants :

 [IDENTIFIER]: Représente des mots-clés ou identifiants trouvés dans les données.

2. Deuxième Pas : Commentaires en C

Le but est d'écrire un analyseur lexical permettant de reconnaître et de supprimer les

Traitement d'un commentaire sur une ou plusieurs lignes

Cette partie du projet vise à développer un analyseur lexical capable de reconnaître et de

 Expression régulière pour les commentaires C : On doit écrire une expression

presente par styve guy Anderson Tiemtore 11

 Dans un premier temps, l'analyseur doit simplement détecter les commentaires

L'exécutable comment1 est ensuite exécuté avec le fichier de données comment.data1

./comment1 < coment1.data2

 Les commentaires sont bien détectés : Les segments /* initialisation () et /