Utilisation d'un générateur. L'interface de l'analyseur lexicale. Diérents générateurs. Le code engendré dans le case de jex

Transcription

1 Analyse Lexicale Rappel : Objectif de l'analyse lexicale Ralf Treinen Lire le texte d'entrée, et faire un premier traitement en vue d'une simplication pour les étapes suivantes : Découpage de l'entrée en lexèmes (des mots élémentaires) Université Paris Diderot UFR Informatique Institut de Recherche en Informatique Fondamentale treinen@pps.univ-paris-diderot.fr 3 février 2016 Classer les lexèmes identiés, création de jetons Interpréter les lexèmes quand pertinent, par exemple transformer une suite de chires en un entier Abstraire l'entrée : ignorer des détails non pertinents pour la suite (espaces, commentaires....) c Ralf Treinen 2015, 2016 Analyse Lexicale Analyse Lexicale Spécication d'une analyse lexicale Implémenter une analyse lexicale Dénition des catégories lexicales diérentes : expressions régulières Dénition de la stratégie : chercher le mot le plus long ou le plus court? comment résoudre des ambiguïtés? La stratégie est souvent imposée par des outils. Dénir le type des jetons produits avec leurs arguments éventuels. Soit écrire un programme (Java ou autre) à la main, basé sur un automate ni : discuté au dernier cours. Les premiers compilateurs étaient eectivement écrits de cette façon (compilateur du langage FORTRAN, Backus et al : 18 personnes-années). Soit faire engendrer un analyseur lexicale à partir d'une spécication (ce cours). C'est la technique utilisée pour l'écriture des compilateurs modernes.

2 Analyse Lexicale Analyse Lexicale Utilisation d'un générateur L'interface de l'analyseur lexicale Code On pourrait imaginer que l'analyse lexicale va créer une liste Java avec tous les jetons créés lors de l'analyse. Problème : cette liste risque d'être très longue. Spéc. Générateur Code Compilateur Exécutable Normalement, la phase suivante de l'analyse a seulement besoin de lire les jetons une fois dans l'ordre. Pour ces raisons, l'analyse lexicale crée les jetons un après l'autre à la demande : fonction qui renvoie le jeton suivant. Code Diérents générateurs Le code engendré dans le case de jex Existent pour presque tous les langages de programmation. Le premier générateur était lex, publié en 1975 par Mike Lesk et Eric Schmidt. Engendre du code en C. Successeur : ex, Les générateurs modernes sont souvent issus de ex. Nous utilisons ici un générateur pour Java : jex. Les générateurs pour des autres langages de programmation sont très similaires. Une classe pour l'analyseur lexicale, le nom de la classe peut être déni dans la spécication (dans nos exemples : Lexer). La création d'un objet de cette classe (un analyseur) prend en argument un objet qui représente le ot d'entrée, par exemple un chier, ou l'entrée standard. Il y a une méthode pour demander le jeton suivant. Le nom de cette méthode, et le type des jetons, peuvent être dénis dans la spécication.

3 La spécication La partie Options et Déclarations Trois parties, séparées par des lignes : code utilisateur options et déclarations règles lexicales Code utilisateur : copié simplement au début du chier engendré (avant la dénition de la classe) partie souvent vide (sauf commentaires, et import...) Options : commencent avec le symbole %. Parmi les options les plus importantes : %class nom : donne le nom de la classe engendrée. %public : la classe engendrée est publique %type t : le type de résultat de la fonction yylex. %unicode : accepte des caractères Unicode en entrée de l'analyse lexicale (recommandé) %line : compte lignes pendant l'analyse lexicale (disponible en yyline). %column : compte colonnes pendant l'analyse lexicale (disponible en yycolumn). %state s : Déclaration de l'état s (voir plus tard) La partie Options et Déclarations La partie Options et Déclarations Code entre %{ et % (peut être sur plusieurs lignes) : copié au début de la classe engendré ce code a donc accès aux champs de la classe (par exemple, yyline, yycolumn) Code entre %eofval{ et %eofval : code exécuté quand l'analyse lexicale arrive à la n de l'entrée (défaut : null). Macros : système de dénitions d'expressions régulières mettre les mots entre apostrophes " et " pour utiliser une expression régulières préalablement dénie, par exemple du nom r : {r. classes de caractères, par exemple [a-z] quelque classes de caractère prédénies, par exemple [:letter:], [:digit:], [:uppercase:], [:lowercase:].

4 La partie Règles Lexicales Le premier exemple Séquence de expression-régulière { code-java dans le cas le plus simple, le code java est un return... Règles d'exécution : on cherche le lexeme le plus long possible, et on applique l'action de la première expression régulières qui s'applique. Analyse lexicale pour des expressions arithmétiques comme vu la dernière fois. Petite diérence au premier exemple : les entiers ne contiennent pas d'exposant. Dénition des classes pour les Symboles (type de jetons), puis pour les jetons éventuellement avec des arguments. Le chier de spécication pour jflex. Un petit programme principal pour tester. Utilisation de jex Fichier Sym.java p u b l i c enum Sym { INT, IDENT, PARG, PARD, MULT, PLUS ;.java.jex jex.java.java javac.class p u b l i c S t r i n g s t r ( ) { s w i t c h ( t h i s ) { c a s e INT : r e t u r n "INT" ; c a s e IDENT : r e t u r n "IDENT" ; c a s e PARG: r e t u r n "PARG" ; c a s e PARD: r e t u r n "PARD" ; c a s e MULT: r e t u r n "MULT" ; c a s e PLUS : r e t u r n "PLUS" ; d e f a u l t : r e t u r n " i m p o s s i b l e " ;

5 Fichier Token.java I c l a s s Token { p r o t e c t e d Sym symbol ; p u b l i c Token (Sym s ) { symbol=s ; p u b l i c Sym symbol ( ) { r e t u r n symbol ; p u b l i c S t r i n g s t r ( ) { r e t u r n ( symbol. s t r ( ) ) ; c l a s s StringToken e x t e n d s Token { p r i v a t e S t r i n g v a l u e ; p u b l i c StringToken (Sym c, S t r i n g s ) { s u p e r ( c ) ; v a l u e=s ; Fichier Token.java II p u b l i c S t r i n g s t r ( ) { r e t u r n ( symbol. s t r ( ) + ' ( ' + v a l u e + ' ) ' ) ; c l a s s IntToken e x t e n d s Token { p r i v a t e i n t v a l u e ; p u b l i c IntToken (Sym c, i n t i ) { s u p e r ( c ) ; v a l u e=i ; p u b l i c S t r i n g s t r ( ) { r e t u r n ( symbol. s t r ( ) + ' ( ' + v a l u e + ' ) ' ) ; Fichier arith.flex I %p u b l i c %c l a s s L e x e r %u n i c o d e %t y p e Token %{ p r i v a t e Token token (Sym t y p e ) { r e t u r n new Token ( t y p e ) ; p r i v a t e StringToken token (Sym type, S t r i n g v a l u e ) { r e t u r n new StringToken ( type, v a l u e ) ; p r i v a t e IntToken token (Sym type, i n t v a l u e ) { r e t u r n new IntToken ( type, v a l u e ) ; % Fichier arith.flex II EspaceChar = [ \n\ r \ f \ t ] Ch = [0 9] Le = [ a za Z ] {Ch+ { r e t u r n token (Sym. INT, I n t e g e r. p a r s e I n t ( y y t e x t ( ) ) ) ; {Le ({ Le { Ch) { r e t u r n token (Sym. IDENT, y y t e x t ( ) ) ; " ( " { r e t u r n token (Sym.PARG) ; " ) " { r e t u r n token (Sym.PARD) ; " " { r e t u r n token (Sym.MULT) ; "+" { r e t u r n token (Sym. PLUS ) ; { EspaceChar+ {

6 Fichier Test.java Ce que JFlex fait pour vous i m p o r t j a v a. i o. ; c l a s s Test { p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) t h r o w s E x c e p t i o n { F i l e i n p u t = new F i l e ( a r g s [ 0 ] ) ; Reader r e a d e r = new F i l e R e a d e r ( i n p u t ) ; L e x e r l e x e r = new L e x e r ( r e a d e r ) ; Token t ; do { t=l e x e r. y y l e x ( ) ; i f ( t!= n u l l ) { System. out. p r i n t l n ( t. s t r ( ) ) ; w h i l e ( t!= n u l l ) ; Création des classes de caractères : tous les caractères qui ne sont jamais distingués par les expressions régulières sont groupés dans la même classe. Les classes crées doivent être disjointes. Exemple : expressions régulières : "end" [a-z]* Quatre classes de caractères disjointes : [e], [n], [d], [a-cf-mo-z] Ce que JFlex fait pour vous Les états de l'analyseur lexical Création d'un automate non-déterministe pour l'union de toutes les expressions régulières. Déterminiser l'automate (et éliminer les ɛ-transitions). Minimiser l'automate. On peut demander à jflex de montrer ces trois automates (option -dot, visualiser les automates avec xdot par exemple) Par défaut (comme sur le premier exemple), votre analyseur lexical a un seul état. Il peut être utile d'avoir plusieurs états - dans chacque état, Flex peut utiliser des expressions régulières diérentes. Pour en avoir plusieurs : les déclarer à l'aide de %state (sauf YYINITIAL) mettre toutes les règles dans le contexte d'un état dans les actions : changer d'état à l'aide de yybegin. pas confondre les états de Flex, avec les états de l'automate ni obtenu des expressions régulières

7 Pourquoi utiliser plusieurs états? Reconnaître les commentaires (simplié) Un premier exemple sont les commentaires : avec une expression régulières comme "/*".* "*/" on a un problème quand il y a plusieurs commentaires dans le texte (pourquoi?) Dans ce cas on veut on fait trouver le mot le plus court décrit par l'expression régulière. Cela peut être simulé en utilisant deux états. %t y p e Token EspaceChar = [ \n\ r \ f \ t ] L e t t e r = [ a za Z ] %s t a t e INCOMMENT <YYINITIAL> { { L e t t e r + { r e t u r n token (Sym. IDENT, y y t e x t ( ) ) ; { EspaceChar { "/ " { y y b e g i n (INCOMMENT) ; <INCOMMENT> { " /" { y y b e g i n ( YYINITIAL ) ;. { Reconnaître les commentaires Les états de Flex dans l'exemple des commentaires {EspaceChar YYINITIAL est l'état par défaut /* Il est important que la dernière règle s'applique à un mot de longueur 1 seulement (c.-à-d. expression régulière., et pas.+) start YYINITAL INCOMMENT. */ {Letter+ return token(...)

8 Exemple : découper un mot en plusieurs parties Nouvelle version de arith.flex I Retour à notre premier exemple : on souhaite maintenant aussi reconnaître des entiers avec exposant (756e2, par exemple). On utilise deux états : quand on trouve un symbole e après une séquence de chires on stocke la valeur entière trouvée (devant le e) dans une variable, puis on va dans un deuxième état pour lire exposant. %p u b l i c %c l a s s L e x e r %t y p e Token %u n i c o d e %{ p r i v a t e Token token (Sym t y p e ) { r e t u r n new Token ( t y p e ) ; p r i v a t e StringToken token (Sym type, S t r i n g v a l u e ) { r e t u r n new StringToken ( type, v a l u e ) ; p r i v a t e IntToken token (Sym type, i n t v a l u e ) { r e t u r n new IntToken ( type, v a l u e ) ; i n t i n t b u f f =0; Nouvelle version de arith.flex II p r i v a t e S t r i n g chop ( S t r i n g s ) { r e t u r n ( s. s u b s t r i n g ( 0, s. l e n g t h () 1)); p r i v a t e i n t expo ( i n t base, i n t ex ) { i n t r e s u l t=base ; f o r ( i n t i = 1 ; i <=ex ; i ++) { r e s u l t=r e s u l t 1 0 ; r e t u r n r e s u l t ; % EspaceChar = [ \n\ r \ f \ t ] Ch = [0 9] Le = [ a za Z ] %s t a t e EXPONENT Nouvelle version de arith.flex III <YYINITIAL> { {Ch+ { r e t u r n token (Sym. INT, I n t e g e r. p a r s e I n t ( y y t e x t ( ) ) ) ; {Le ({ Le { Ch) { r e t u r n token (Sym. IDENT, y y t e x t ( ) ) ; " ( " { r e t u r n token (Sym.PARG) ; " ) " { r e t u r n token (Sym.PARD) ; " " { r e t u r n token (Sym.MULT) ; "+" { r e t u r n token (Sym. PLUS ) ; { EspaceChar+ { {Ch+ " e " { i n t b u f f=i n t e g e r. p a r s e I n t ( chop ( y y t e x t ( ) ) ) ; y y b e g i n (EXPONENT) ; <EXPONENT> { {Ch+ { y y b e g i n ( YYINITIAL ) ; r e t u r n ( token (Sym. INT,

9 Mots clefs d'un langage de programmation Attention à l'ordre des règles Solution naïve : une règle par mot clefs. %t y p e Token EspaceChar = [ \n\ r \ f \ t ] L e t t e r = [ a za Z ] " b e g i n " { r e t u r n token (Sym. BEGIN) " end " { r e t u r n token (Sym.END) " c l a s s " { r e t u r n token (Sym. CLASS) { L e t t e r + { r e t u r n token (Sym. IDENT, y y t e x t ( ) ) ; { EspaceChar { Entrée : beg begin beginner Premier appel à yylex() : seulement la quatrième règle s'applique token IDENT. Deuxième appel à yylex() : les règles (2) et (4) s'appliquent au même lexeme begin, c'est donc la première parmi ces deux qui gagne token BEGIN. Troisième appel à yylex() : les règles (2) et (4) s'appliquent mais la dernière reconnaît un lexeme plus long token IDENT. Mais regarder la taille de l'automate engendré! Contrôler la taille de l'automate Comment reconnaître les mots clefs sans catégories dédiées? Techniques utilisés par le générateurs : Utiliser des classes de caractères au lieu dans la représentation de l'automate. Minimiser l'automate engendré à partir des expressions régulières. dans la spécication : Éviter de créer une nouvelle classe lexicale pour chaque mot clef (Java : 46 mots clefs.) En Java (et pareil dans les autres langages de programmation) : tous les mots clefs sont des séquences de lettres en minuscules. Mettre une seule catégorie pour les identicateurs. Dans l'action associé, on cherche (par ex. dans une table de hachage) si le lexeme est un mot clefs, et crée un jeton en fonction.

10 Tables de hachage : pour faire quoi? Tables de hachage : comment ça fonnctionne Représenter des fonctions partielles nies f : D A D B Cas d'usage : Le domaine potentiel D A est très grand ou même inni ; par contre f est dénie seulement pour un petit nombre de valeurs. (1) On souhaite un coût mémoire plus au moins linéaire dans la taille du domaine plus la taille du co-domaine de f. (2) On souhaite une complexité constante pour accéder à la valeur de la fonction appliquée à un argument. (3) Fonctions modiables : possibilité d'ajouter ou de supprimer des paires (argument, résultat) Les tableaux répondent aux objectifs 2 (complexité constante) et 3 (fonctions modiables), à part du fait qu'il faudrait utiliser des valeurs d'un type D A en tant d'indices. On utilise une fonction de hachage h : D A int pour mapper les arguments de la fonction f vers des entiers (indices du tableau). Cela nous permet aussi de répondre à l'objectif 1 : la fonction de hachage h est non-injective, et on s'arrange pour que l'image de h soit un intervalle [0,..., d 1]. Le tableau peut donc avoir la taille d. Tables de hachage : le problème des conits Table de hachage avec listes chaînées On ne peut pas exclure des conits de la fonction de hachage : x y et h(x) = h(y), même si on essaye de les éviter par un bon choix de la fonction de hachage. Pour gérer les conits, les entrées du tableau ne sont pas des valeurs de D B, mais encore des fonctions partielles D A D B. Ces fonctions devront avoir un domaine vraiment petit (quelques éléments seulement), on peut donc les représenter par une liste d'association par exemple. Jorge Stol/Wikimedia, CC-Attribution-Share Alike

11 Le chier keys.flex I i m p o r t j a v a. u t i l. HashMap ; c l a s s Keys e x t e n d s HashMap<S t r i n g, Sym> { p u b l i c Keys ( ) { s u p e r ( ) ; t h i s. put ( " end ",Sym.END) ; t h i s. put ( " b e g i n ",Sym. BEGIN ) ; t h i s. put ( " c l a s s ",Sym. CLASS ) ; %p u b l i c %t y p e Token %c l a s s L e x e r %u n i c o d e EspaceChar = [ \n\ r \ f \ t ] L e t t e r = [ a za Z ] Le chier keys.flex II %{ p r i v a t e Keys k e y s = new Keys ( ) ; p r i v a t e Token token (Sym t y p e ) { r e t u r n new Token ( t y p e ) ; p r i v a t e Token token (Sym sym, S t r i n g v a l u e ) { Sym s = k e y s. g e t ( v a l u e ) ; i f ( s == n u l l ) { / not a keyword / r e t u r n new StringToken ( sym, v a l u e ) ; e l s e { / keyword / r e t u r n new Token ( s ) ; % { L e t t e r + { r e t u r n token (Sym. IDENT, y y t e x t ( ) ) ; { EspaceChar { Tutorat 2ème semestre 2015/2016 Jour Heure Salle Tuteur Lundi 12h-14h 436C Abderrahmane MEDADJELIA Mardi 12h30-14h30 443C Colin GONZALEZ Mercredi 12h-14h 548C Omar CHEBIB EL-ACHI Jeudi 12h-14h 557C Eric UZENAT Vendredi 11h45-13h45 531C Antoine HUCHET