Compilation : De l'algorithme à la porte logique (2023-2024)

• Pour un fragment reconnu par une expression régulière :
  • l'action associée à l'expression est exécutée,
  • la valeur du fragment est accessible par la méthode String yytext(),
  • la méthode void ECHO() imprime la valeur de yytext(),
  • si l'action est vide, l'unité lexicale est "absorbée".
• Pour un fragment non reconnu, une exception Java est lancée.

• Un fragment débute avec la reconnaissance d'une expression régulière et se prolonge le plus loin possible jusqu'à la reconnaissance d'un autre fragment ou jusqu'à la fin de l'entrée.
• La reconnaissance est dite "gloutonne" (greedy) par opposition à d'autres outils permettant une reconnaissance dites "récalcitrante" (reluctant).
• Une action n'est réalisée que sur un fragment qui ne peut être prolongé.

Si plusieurs règles peuvent s'appliquer :

• l'expression reconnaissant le plus long fragment est choisie,
• en cas d'égalité de longueur, on choisit la règle en premier dans la spécification.

En permutant les deux premières règles dans la spécification. La règle R1 ne s'appliquera jamais car toujours devancée par R2. L'outil JFlex le signale à la compilation par un message Rule can never be matched.

L'entrée peut contenir des données erronées, ou sans utilité applicative, ou incorrectement traitées par la spécification. Il est donc utile d'ajouter des règles pour traiter ce qui n'est pas reconnu par le reste de la spécification.

Une réalisation simple consiste à ajouter en fin de spécification une "règle-balai" ou "ramasse-miettes", reconnaissant tous les caractères. Elle s'appliquera sur les fragments non reconnus par les règles précédentes. L'action associée permettra de faire du traitement d'erreur, ou de débogage, ou un traitement par défaut des caractères inutiles.

Traditionnellement la règle balai s'écrit sous la forme .|\n. Avec JFlex, on a une écriture plus systématique avec [^].

L'action notée | indique qu'il faut faire l'action de la règle suivante. On peut aussi le voir comme l'écriture d'une expression régulière sur plusieurs lignes séparées par l'opérateur "OU".

Les caractères suivants peuvent avoir une interprétation réservée dans une spécification JFlex : <>{}()[]|!~*+?"^$/.\,-.
Pour supprimer l'interprétation par JFlex des méta-caractères, on dispose de :

" "	Chaîne de caractères mono-ligne Dans une chaîne, seul " et \ sont des caractères réservés
\	Échappement du caractère suivant

Les expressions régulières sont définies à partir des opérateurs (ordre croissant de priorité) :

r1 | r2	Alternative
r1 r2	Concaténation
r *	Fermeture de Kleene
( r )	Groupement pour application des opérateurs

Un caractère C dans une expression régulière peut être obtenu par :

C	si C est imprimable et n'est pas un métacaractère JFlex
\C	si C est imprimable et n'est pas en conflit avec la suite
\xnm	ASCII avec nm 2 chiffres hexadécimaux ([0-9a-fA-F])
\ijk	ASCII avec ijk 3 chiffres octaux ([0-7])
\unmop	Unicode avec 4 chiffres hexadécimaux
\Unmopqr	Unicode avec 6 chiffres hexadécimaux
\b	ANSI-C Backspace
\f	ANSI-C Form Feed
\n	ANSI-C Newline
\r	ANSI-C Carriage Return
\t	ANSI-C Horizontal Tabulation

Une classe de caractères reconnaît un seul caractère choisi parmi un ensemble. on a ainsi :

[ab...]	un caractère parmi a, b,... (== a|b|....)
[i-p...]	un caractère dans l'intervalle ASCII de i à p ou...
[^ab...]	un caractère quelconque sauf a,b,... (Complémentaire)
.	un caractère quelconque sauf une fin de ligne == [^\r\n\u2028\u2029\u000B\u000C\u0085]

De manière spécifique à JFlex, on a aussi :

[^]	un caractère quelconque == (. | \R)
\R	"caractère" de fin de ligne == \r\n | [\r\n\u2028\u2029\u000B\u000C\u0085] n'est ni un caractère ni une classe, n'est pas utilisable à l’intérieur d'une classe

Pour une expression r, on a les "Répétitions" de r :

r *	répétition n fois avec n≥0
r +	répétition n fois avec n>0
r ?	répétition n fois avec n=0 ou n=1
r {N}	répétition exactement N fois
r {N,M}	répétition n fois avec N≤n≤M

Pour une expression r, on a les reconnaissances :

^ r	reconnaît r uniquement en début de ligne
r $	reconnaît r uniquement en fin de ligne
r / suite	reconnaît r uniquement avant "suite"

• Dans les différents cas, le contexte "\n" ou "suite" n'est pas consommé.
• Si quelque chose précède ^, ou suit $, les caractères ^ et $ reprennent leur sens littéral.
• ^r$ est interdit si r peut être vide.
• L'usage simultané de / et $ est interdit.

Les éléments suivants sont plus spécifiques à l'outil JFlex et l'on évitera de les utiliser :

[:jletter:] [:jletterdigit:] [:letter:] [:digit:] [:uppercase:] [:lowercase:]	Classes prédéfinies à la POSIX
\p{...} \P{...}	Classes prédéfinies selon les catégories Unicode
\d \D \s \S \w \W	Classes POSIX [:digit:], [:space:], [:word:] et complémentaires
! r ~ r	Opérateur Négation (Danger explosion combinatoire !) Opérateur UpTo (Danger explosion combinatoire !)
[ || ] [ && ] [ -- ] [ ~~ ]	Opérations ensemblistes sur les classes de caractères : Union, Intersection, Différence, et Différence symétrique

L'outil JFlex produit une classe Yylex.java avec un constructeur Yylex(java.io.Reader in).
L'analyse lexicale sera réalisée par la méthode Yytoken yylex() (ou suivant la configuration : int yylex(), int next_token(), java_cup.runtime.Symbol next_token()).
La méthode yylex() :

• lit les caractères en entrée jusqu'à reconnaître un fragment,
• exécute l'action correspondante,
• continue avec la lecture du prochain fragment, sauf si l'action contient une instruction return.

Ainsi la méthode yylex() ne termine que sur la fin de fichier (EOF), ou sur un return explicite dans une action.

Les variables et méthodes suivantes sont utilisables dans les actions :

String yytext()	le dernier fragment reconnu
int yylength()	yytext().length()
char yycharat(int pos)	yytext().charAt(pos)
int yybegin(int state)	change le super-état
int yystate()	retourne le super-état courant
static final int YYINITIAL	le super-état initial
int yyreset(java.io.Reader in)	réinitialise le scanner sur la nouvelle entrée.
void yypushback(int n)	remet les n derniers caractères lus dans le flot d'entrée (très sale mais parfois utile !)

Et avec les options du cours des fichiers Jflex*.include :

long yychar; int yycolumn, yyline	positions courantes dans l'entrée
String WHERE()	chaîne yyline/yycolumn(yychar)
void ECHO()	imprime yytext()
void ECHO(String categorie)	imprime [categorie:yytext()]
void WARN(String msg)	imprime message d'erreur
public static void main(String[] args)	main() avec lecture sur l'entrée standard ou sur le fichier args[0]
java_cup.runtime.Symbol TOKEN(int code)	génère une valeur de retour pour CUP
java_cup.runtime.Symbol TOKEN(int code, Object value)	idem avec valeur sémantique du token

• Un bloc %{...%} permet d'ajouter des variables ou des méthodes à la classe Yylex pour utilisation dans les actions.
• Un bloc %init{...%init} permet d'ajouter du code exécuté initialement dans le constructeur de Yylex.
• Un bloc %eof{...%eof} permet d'ajouter du code exécuté à la fin de l'entrée.