COMPILATION L3 ARIDJ Mohamed

ANNEXE A : Description de LEX (FLEX)

1. INTRODUCTION : ......................................................................................................................... 2
2. UTILISATION DU LEX ................................................................................................................ 2
3. STRUCTURE D'UN FICHIER SOURCE POUR LEX ................................................................ 3
La section des déclarations et définitions ......................................................................................... 3
La section des règles .................................................................................................................. 4
4. Fonctionnement d’un programme LEX .......................................................................... 5
5. Définition des expressions régulières....................................................................................... 6
Les meta-symboles ........................................................................................................................... 6
Les operateurs ................................................................................................................................. 6
Les actions ....................................................................................................................................... 7
6. L’ambigüité des actions .......................................................................................................... 8

UHBC Faculté des Sciences Exactes et Informatique département informatique 2023/2024 Page 1
 COMPILATION L3 ARIDJ Mohamed

ANNEXE A : Description de LEX (FLEX)

1. INTRODUCTION :
Les analyseurs lexicaux basées sur des tables de transitions sont les plus efficaces une fois la
table de transition construite. Or, la construction de cette table est une opération longue et
délicate.
Le programme LEX fait cette construction automatiquement : il prend en entrée un ensemble
d’expressions régulières et produit en sortie le texte source d’un programme C qui, une fois
compilé, représente l’analyseur lexical correspondant au langage défini par les expressions
régulières en question.

2. UTILISATION DU LEX
A partir d’un fichier source « .1 » ,LEX produit un fichier source C, nommé lex.yy.c,
contenant la définition de la fonction int yytext(void), qui est le code source de l’analyseur
lexicale du langage : un programme appelle cette fonction et elle renvoie une unité lexicale
reconnue dans le texte source.

La forme générale d’une application LEX correspond au schéma suivant :

1 On crée un fichier texte dont l’extension est « .L ». Ce fichier contiendra les descriptions
en termes d’expressions régulières et les actions en termes de code C.
2 On compile ce fichier par la commande Lex. Cela génère un fichier qui contient le code C
du futur analyseur lexical. Ce fichier est nommé ”lex.yy.c”.
3 On compile le fichier ”lex.yy.c” par un compilateur C,(gcc, par exemple).
4 Le résultat est un fichier exécutable qui représente l’analyseur lexical.
5 L’appel de l’exécutable sur un fichier d’entrée (ou sur les données de l’entrée standard)
provoquera l’analyse lexicale de ce fichier.
UHBC Faculté des Sciences Exactes et Informatique département informatique 2023/2024 Page 2
 COMPILATION L3 ARIDJ Mohamed

Exemple
>> lex scanner.l
>> gcc -o scanner lex.yy.c -lfl
>> scanner < source.atl

3. STRUCTURE D'UN FICHIER SOURCE POUR LEX

Un fichier source pour LEX doit avoir un nom qui se termine par « .l ». Il est composé de
trois sections, délimitées le symbole %% :
La forme générale d’un programme LEX(FLEX) est le suivant :

<< Déclarations et définitions >>

%%
<< Règles >>
%%
<<Sous-programmes >>
Seul le premier ”%%” est obligatoire. Ce symbole marque le début et la fin de la
description du langage à reconnaître. Le second ”%%” est optionnel et n’est pas
nécessaire que dans le cas de la présence de sous-programmes. Ainsi, le source
lex minimum est :
%%

Ce programme minimal produit un analyseur lexical qui recopie le texte d’entrée (tel
quel) sur la sortie.

La section des déclarations et définitions

Cette section comprend une partie pour les déclarations et une partie pour les
définitions des expressions régulières. Dans la première partie, on peut mettre :
• des macros d’inclusion de fichiers d’en-têtes ou autres.
• des commentaires.
• des déclarations de variables et fonctions globales.
Cette partie est é́crite comme suit :

%{
/* Les déclarations */
%}

UHBC Faculté des Sciences Exactes et Informatique département informatique 2023/2024 Page 3
 COMPILATION L3 ARIDJ Mohamed

Dans la partie réservée aux définitions, on peut mettre une définition d’une
expression régulière par ligne. Ces définitions doivent ê̂tre placées entre les symboles
”%}” et le premier ”%%”. Elles correspondent en fait à̀ des macros définitions et
permettent de simplifier l’écriture des expressions régulières. Elles ne doivent pas
contenir de caractère blanc en première colonne et ont la forme suivante :
<< nom >> << description >>
La chaîne de texte ”nom” est alors remplacés par la chaîne de caractères ”description” à
chaque occurrence de la forme ”{nom}”. Par exemple, pour dé́finir un identificateur C,
un nombre entier ou flottant, on peut utiliser Lettre pour lettre, souligne pour le
caractère souligné, Chiffre pour chiffre et E xposant pour exposant. Le programme
Flex est alors simplifié comme suit :

%{
#include <stdio.h>
%}
Chiffre [0-9]
Exposant [Ee][-+]?{C}+ Lettre [a-zA-Z] Souligne _
Identif ({Lettre}|{Souligne})({Lettre}|{Souligne}|{Chiffre})*
%%
{Chiffre}+ printf("un entier\n");
{Chiffre}+{Exposant} printf("un flottant\n");
{Identif} printf("un identificateur\n");
Comme vous le remarquez, pour référencer un nom dans une règle on doit le mettre
entre { et }.

La section des règles

Cette section contient une ou plusieurs règles (mais elle peut ê̂tre vide, et
dans ce cas c’est la règle par défaut de LEX qui est activée). Elle occupe la zone
entre le premier et le second symbole %% et a la forme suivante :
%%
R1 A1
....
RnAn
%%

UHBC Faculté des Sciences Exactes et Informatique département informatique 2023/2024 Page 4
 COMPILATION L3 ARIDJ Mohamed

Une règle est de la forme :

Ri Ai
La partie ”Ri” est une expression régulière ”´étendue”. La partie ”Ai” est l’action à
exécuter (c’est un morceau de code C ). L’action ”Ai” sera exécutée dans le cas où un
mot d´écrit par l’expression régulière ”Ri” est reconnu. Elle doit ê̂tre séparée de la
partie ”Ri” par au moins un caractère blanc. Par exemple, le programme LEX
suivant va engendrer un analyseur lexical qui recopie le texte à analyser, tout en
traduisant les mots ”oui”, ”non”, et ”d’accord” en anglais :

%%
"oui" printf("yes");
"non" printf("no");
"d’accord" printf("ok");

Ainsi, si le texte d’entrée est : "oui, ou non. D’accord ?"

Le texte de sortie produit par l’analyseur est : "yes, ou no. ok ?"

4. Fonctionnement d’un programme LEX

L’analyseur lexical produit par LEX, lit l’entrée standard et recherche à
appliquer une de ses règles. Si aucune règle n’est pas applicable pour un caractère,
l’analyseur écrit ce caractère sur la sortie standard. Dans le cas contraire, il effectue
les actions définies par la règle qu’il applique. Une application d’une règle permet
de faire avancer la lecture de l’entrée standard. Une fois la règle appliquée,
l’analyseur continuer de rechercher une autre règle applicable avec le reste du
texte de l’entrée standard. Le processus se termine soit par la rencontre de la fin de
fichier d’entrée standard (le caractère EOF), soit par l’exécution d’une action qui
comprend une instruction ”return” ou ”exit”.

Par exemple, le programme Flex suivant engendre un analyseur lexical qui compte
le nombre de lignes du fichier source à analyser :

%{
int nb_lignes = 0;
%}
%%
\n nb_lignes++;
UHBC Faculté des Sciences Exactes et Informatique département informatique 2023/2024 Page 5
 COMPILATION L3 ARIDJ Mohamed

5. Définition des expressions régulières

Les meta-symboles
Les symboles suivants ont une signification pour Flex :
"\[]^-?.*+|()$/{}%<>

Pour introduire un de ces symboles dans un motif comme caractère du texte,

il faut soit le précéder par un caractère ant-slash ”\”, soit l’encadrer de ”...”.
Par exemple, pour reconnaître les caractère s ’+’ et ’−’, on écrit :
%%
"+" printf("plus\n");
\- printf("moins\n");

Les operateurs
Le tableau suivant résume le rôle de chacun des opérateurs de Flex :

Opérateur Description
[xyz] Correspond à un seul caractère parmi ceux indiqués
? Indique que le caractère précédent est optionnel
∗ Indique une répétition 0, 1, ..., n fois du caractère précédent
+ Indique une répétition 1, 2, ..., n = fois du caractère précédent
| Indique une alternative : (ac|b) signifie ac ou b
() Pour indiquer la portée dopérateurs comme +, ∗ et ?
b Placé en début du motif, indique que le motif doit se trouver en
débutde ligne
$ Placé en fin du motif, indique que le motif doit se trouver en fin de
ligne
r/s Correspond à r s’il est suivi de s (s ne fait pas partie du mo tif)
< cond > r Correspond à r si le contexte gauche de r satisfait la condition
initiale cond (cond est déclaré dans la partie définition)
{macro} Correspond à l’expansion de la macro désign é entre {...}
r{m, n} Correspond à m jusqu’à n occurrences de r
. N’importe quel caractère
− Correspond à un intervalle de caractère s

UHBC Faculté des Sciences Exactes et Informatique département informatique 2023/2024 Page 6
 COMPILATION L3 ARIDJ Mohamed

Les actions
L’action par défaut de Flex consiste à recopier tous les caractères qui ne
correspondent à aucun motif dans le fichier de description. Il existe d’autres
actions Prédéfinies par Flex :
• L’action vide ” ;” : elle serve à ne pas recopier les caractères non reconnus.
• L’action ”ECHO ;” : elle serve à recopier les caractères reconnus.
• L’action ”REJECT ;” : elle indique qu’une fois la règle appliquée, la chaîne
reconnue doit être rejetée si une autre règle est susceptible de convenir é́galement,
pour ê̂tre traitée aussi par cette autre règle. Cette action est en fait un branchement :
le code qui le suit immédiatement dans l’action ne sera pas exécuté.
• L’action ”|” : elle indique le report de l’action sur la règle suivante. Elle signifie :
” la même chose que l’action pour la règle suivante”.

L’exemple Flex suivant élimine tous les caractères blancs (sauf le retour à la
ligne), imprime les chiffres et les lettres majuscules :
%%
[0-9] |
[A-Z] |
\n ECHO;
. ;
Pour le traitement des actions un peu complexes, Flex fournit plusieurs variables
globales :
• char *yytext : conserve le texte de l’unité lexicale courante.
• int yyleng : conserve la taille de l’unité lexicale courante.
• FILE *yyin : spécifié le fichier à partir duquel Flex lit par défaut (fichier
source).
• FILE *yyout : spécifié le fichier dans lequel les actions ECHO seront effectuées.
Flex dispose é́galement d’autres actions données sous forme de routines :
• yymore() : indique à l’analyseur que la prochaine fois qu’il reconnait une règle,
l’unité lexicale correspondante devra ê̂tre concaténée à la valeur actuelle de yytext au
lieu de le remplacer.
• yyless(int n) : renvoie tout sauf les n premiers caractères de l’unité lexicale courante
dans le flux d’entrée, où ils seront réexaminés quand l’analyseur recherchera la
correspondance suivante :

UHBC Faculté des Sciences Exactes et Informatique département informatique 2023/2024 Page 7
 COMPILATION L3 ARIDJ Mohamed

• unput(int car) : replace le caractère car sur le flux d’entrée. Il sera le

prochain caractère à ê̂tre examiné. L’action suivante prendra l’unité lexicale
courante et le fera réexaminer enfermé dans des parenthèses.
• int input() : lit le caractère suivant du flux d’entrée.
• output(int car) : écrit le caractère car sur la sortie standard.
• int yyterminate() : arrête l’analyseur et renvoie 0 à l’appelant de
l’analyseur en indiquant un message ”all done ” (tout est terminé). Par
défaut, elle est également appelée quand une fin de fichier est rencontrée.

6. L’ambigüité des actions

Deux règles sont ambigües si elles peuvent ê̂tre déclenchées avec une
même entrée. La résolution de l’ambigüité s’effectue en appliquant l’une
des règles suivantes :
1. La règle qui correspond à la plus longue entrée est appliquée en priorité.
2. Si deux règles ambigües correspondent à̀ la même entrée, la première qui a
été définie est appliquée en
priorité. Voici un exemple :
%%
algo printf("mot cle");
[a-z]+ printf("identificateur");

Supposons que l’entrée contient la chaîne ”algorithme”. Elle sera reconnue

comme
”identificateur”, car les deux règles sont applicables, mais seule la
deuxième est applicable sur une longueur supérieure. Si maintenant
l’entrée contient ”algo”, elle sera reconnue comme ”mot clé”, car les deux
règles sont applicables sur la même longueur de l’entrée, mais seule la
première est applicable car c’est elle qui a
été définie la p r e m i è r e

UHBC Faculté des Sciences Exactes et Informatique département informatique 2023/2024 Page 8