Nom

flex - générateur d'analyseurs lexicaux rapides

Résumé

flex [-bcdfhilnpstvwBFILTV78+? -C[aefFmr] -osortie -Ppréfixe -Ssquelette] [--help --version] [nom_fichier ...]

RÉsumÉ

Ce manuel décrit flex , un outil de génération de programmes qui effectuent de la reconnaissance de motifs sur du texte. Le manuel inclut à la fois un tutorial et des sections de référence : .nf Description un bref résumé de l'outil Quelques Exemples Simples Format du Fichier d'Entrée Motifs les expressions rationnelles étendues utilisées par flex Comment l'Entrée est Reconnue les règles pour déterminer ce qui a été identifié Actions comment spécifier ce qu'il faut faire quand un motif est reconnu L'Analyseur Généré détails à propos de l'analyseur produit par flex ; comment contrôler la source d'entrée Conditions de Démarrage introduction de contexte dans vos analyseurs, et gestion de « mini-analyseurs » Tampons d'Entrée Multiples comment manipuler de multiples sources d'entrée ; comment analyser à partir de chaînes de caractères plutôt qu'à partir de fichiers Règles de Fin-De-Fichier (End-Of-File, EOF) règles spéciales pour la fin de l'entrée Macros Diverses un résumé des macros disponibles dans les actions Valeurs Disponibles pour l'Utilisateur une résumé des valeurs disponibles dans les actions Interface avec Yacc connecter des analyseur lexicaux flex à des analyseurs syntaxiques yacc Options options de ligne de commandes de flex, et la directive « %option » Considérations de Performance comment rendre votre analyseur le plus rapide possible Générer des Analyseurs C++ La fonctionnalité (expérimentale) de génération de classes d'analyseurs C++ Incompatibilités avec Lex et POSIX comment flex diffère du lex de AT&T et du lex POSIX standard Diagnostics les messages d'erreur produits par flex (ou les analyseurs lexicaux qu'il génère) dont la signification pourrait ne pas être évidente Fichiers fichiers utilisés par flex Défectuosités / Bogues problèmes connus de flex Voir Aussi autre documentation, outils apparentés Auteur inclut une information de contact .fi

Description

flex est un outil dédié à la génération d' analyseurs lexicaux , c.-à-d. des programmes qui reconnaissent des motifs lexicaux dans du texte. flex lit les fichiers d'entrée donnés, ou son entrée standard si aucun nom de fichier n'est fourni, pour obtenir une description de l'analyseur à générer. La description est effectuée sous la forme de paires d'expressions rationnelles et de code C, appelées règles . flex génère en sortie un fichier source C, lex.yy.c , qui définit une routine yylex() . Ce fichier est compilé et lié avec la bibliothèque -lfl pour produire un exécutable. Quand l'exécutable est lancé, il analyse son entrée pour détecter les occurrences des expressions rationnelles. Chaque fois qu'il en trouve une, il exécute le code C correspondant.

Quelques exemples simples


Tout d'abord, voici quelques exemples simples, pour avoir une idée de la façon d'utiliser flex . L'entrée flex suivante spécifie un analyseur qui, à chaque fois qu'il rencontre la chaîne de caractères « nomUtilisateur », la remplace par le nom de connexion de l'utilisateur : .nf % nomUtilisateur printf( "%s", getlogin() ); .fi Par défaut, tout le texte non reconnu par un analyseur flex est copié sur la sortie, et ainsi l'effet de bord de cet analyseur est de copier son fichier d'entrée sur sa sortie où chaque occurrence de « nomUtilisateur » est développée. Dans cette entrée, il n'y a qu'une seule règle. « nomUtilisateur » est le motif et « printf » est l' action . Le « % » marque le début des règles.

Voici un autre exemple simple : .nf int nombre_lignes = 0, nombre_cars = 0; %
++nombre_lignes; ++nombre_cars; . ++nombre_cars; % main() { yylex(); printf( "# de lignes = %d, # de caractères = %d
", nombre_lignes, nombre_cars ); } .fi Cet analyseur compte le nombre de caractères et le nombre de lignes de son entrée (il ne produit pas d'autre sortie que le rapport final d'occurrences). La première ligne déclare deux variables globales, « nombre_lignes » et « nombre_cars », qui sont accessibles à la fois à l'intérieur de yylex() et de la routine main() déclarée après le second « % ». Il y a deux règles, l'une qui reconnaît le retour à la ligne («
») et qui incrémente à la fois le nombre de lignes et le nombre de caractères, et l'autre qui reconnaît tous les autres caractères (ce qui est indiqué par l'expression rationnelle « . »).

Un exemple un peu plus compliqué : .nf /* analyseur pour un langage de type Pascal */ %{ /* besoin de ceci pour l'appel à atof() plus bas */ #include <math.h> %} CHIFFRE [0-9] ID [a-z][a-z0-9]* % {CHIFFRE}+ { printf( "Un entier : %s (%d)
", yytext, atoi(yytext)); } {CHIFFRE}+"."{CHIFFRE}* { printf( "Un nombre flottant : %s (%g)
", yytext, atof(yytext)); } if|then|begin|end|procedure|function { printf( "Un mot-clé : %s
", yytext ); } {ID} printf( "Un identificateur : %s
", yytext ); "+"|"-"|"*"|"/" printf( "Un opérateur : %s
", yytext ); "{"[^}
]*"}" /* manger les commentaires d'une ligne */ [
]+ /* manger les blancs */ . printf( "Caractère non reconnu : %s
", yytext ); % main( argc, argv ) int argc; char **argv; { ++argv, --argc; /* passer le nom du programme */ if ( argc > 0 ) yyin = fopen( argv[0], "r" ); else yyin = stdin; yylex(); } .fi C'est l'ébauche d'un simple analyseur pour un langage comme Pascal. Il identifie différents types d' éléments lexicaux (tokens) et rapporte ce qu'il a vu.

Les détails de cet exemple seront expliqués dans les sections suivantes.

Format du fichier dentrÉe

Le fichier d'entrée de flex est constitué de trois sections, séparées à chaque fois par une ligne composée uniquement de % : .nf définitions % règles % code utilisateur .fi La section de définitions contient les déclarations de simples définition de noms qui servent à simplifier la spécification de l'analyseur, et les déclarations de conditions de démarrage , qui sont expliquées dans une section ultérieure.

Les définitions de noms ont la forme : .nf nom définition .fi Le « nom » est un mot commençant par une lettre ou un caractère de soulignement (« _ ») suivi de 0 à n lettres, chiffres, « _ » ou « - » (tiret). La définition est supposée débuter au premier caractère non d'espacement suivant le nom et continue jusqu'à la fin de la ligne. La définition peut être référencée plus tard en utilisant « {nom} », qui sera développé en « (définition) ». Par exemple, .nf CHIFFRE [0-9] ID [a-z][a-z0-9]* .fi définit « CHIFFRE » comme étant une expression rationnelle correspondant à un chiffre unique, et « ID » comme étant une expression correspondant à une lettre suivie de zéro-ou-plusieurs lettres-ou-chiffres. Une référence ultérieure à .nf {CHIFFRE}+"."{CHIFFRE}* .fi sera identique à .nf ([0-9])+"."([0-9])* .fi et correspond à un-ou-plusieurs chiffres suivis d'un point, et de zéro-ou-plusieurs chiffres.

La section de règles dans l'entrée de flex contient une série de règles de la forme : .nf motif action .fi où le motif ne peut pas être indenté, et où l'action doit commencer sur la même ligne.

Voyez plus bas pour une description plus précise des motifs et des actions.

Finalement, la section du code utilisateur est simplement copiée telle quelle dans lex.yy.c . Elle est utilisée pour des routines d'accompagnement qui appellent ou sont appelées par l'analyseur. La présence de cette section est optionnelle ; si elle est manquante, le deuxième % du fichier d'entrée peut également être omis.

Dans les sections de définitions et de règles, tout texte indenté ou compris entre %{ et %} est copié tel quel dans la sortie (sans les %{}). Les %{} ne peuvent eux-mêmes être indentés sur leur ligne.

Dans la section de règles, tout texte indenté ou entre %{} qui apparaît avant la première règle peut être utilisé pour déclarer des variables qui sont locales à la routine d'analyse lexicale, et (après les déclarations) au code qui doit être exécuté à chaque fois que l'on entre dans cette même routine. Un autre texte indenté ou entre %{} présent dans la section de règles est toujours copié sur la sortie, mais sa signification n'est pas bien définie et pourrait provoquer des erreurs à la compilation (cette caractéristique est présente pour la conformité POSIX ; voyez plus bas pour d'autres caractéristiques similaires).

Dans la section de définitions (mais pas dans la section de règles), un commentaire non indenté (c.-à-d. une ligne commençant par « /* ») est également copiée telle quelle dans la sortie jusqu'au « */ » suivant.

Motifs

Les motifs en entrée sont écrits en utilisant un ensemble étendu d'expressions rationnelles. Ce sont : .nf x correspond au caractère 'x' . n'importe quel caractère (octet) sauf le retour à la ligne [xyz] une « classe de caractères » ; dans ce cas, le motif convient pour un 'x', un 'y', ou un 'z' [abj-oZ] une « classe de caractères » contenant un intervalle ; convient pour un 'a', un 'b', n'importe quelle lettre allant de 'j' à 'o', ou un 'Z' [^A-Z] une « classe de caractères niée », c.-à-d. tout caractère sauf ceux dans la classe. Dans cet exemple, tout caractère SAUF une lettre majuscule. [^A-Z
] tout caractère SAUF une lettre majuscule ou un retour à la ligne r* zéro ou plusieurs r, où r est une expression rationnelle quelconque r+ un ou plusieurs r r? zéro ou un r (c.-à-d. un r optionnel) r{2,5} entre deux et cinq r r{2,} deux r ou plus r{4} exactement 4 r {nom} le développement de la définition de « nom » (voir au dessus) "[xyz]"foo" la chaîne de caractères littérale : [xyz]"foo X si X est 'a', 'b', 'f', 'n', 'r', 't' ou 'v', alors la représentation C ANSI de x. Sinon, un 'X' littéral (utilisé pour protéger des opérateurs comme '*')