Analyse de Données Structurées - Cours 3

(1)

Analyse de Données Structurées - Cours 3

Ralf Treinen

Université Paris Diderot UFR Informatique

Institut de Recherche en Informatique Fondamentale treinen@irif.fr

31 janvier 2017 c

Ralf Treinen 2015-2017

(2)

Rappel : Objectif de l'analyse lexicale

I Lire le texte d'entrée, et faire un premier traitement en vue d'une simplication pour les étapes suivantes :

I Découpage de l'entrée enlexèmes (des mots élémentaires)

I Classer les lexèmes identiés, création dejetons

I Interpréterles lexèmes quand pertinent, par exemple transformer une suite de chires en un entier

I Abstraire l'entrée : ignorer des détails non pertinents pour la suite (espaces, commentaires. . . .)

(3)

Spécication d'une analyse lexicale

I Dénition des catégories lexicales diérentes : expressions régulières

I Dénition de la stratégie :

I chercher le mot le plus long ou le plus court ?

I comment résoudre des ambiguïtés ?

I La stratégie est souvent imposée par des outils.

I Dénir le type des jetons produits avec leurs arguments éventuels.

(4)

Implémenter une analyse lexicale

I 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.

1957 : 18 personnes-années).

I Soit faireengendrer un analyseur lexicale à partir d'une spécication (ce cours).

C'est la technique utilisée pour l'écriture des compilateurs modernes.

(5)

Utilisation d'un générateur

Spéc. Générateur Code

Code

Compilateur Exécutable

I vert : écrit par le programmeur

I rouge : engendré

(6)

L'interface de l'analyseur lexicale

I On pourrait imaginer que l'analyse lexicale va créer une liste Java avec tous les jetons créés lors de l'analyse.

I Problème : cette liste risque d'être très longue.

I Normalement, la phase suivante de l'analyse a seulement besoin de lire les jetons au fur et à mesure.

I Pour ces raisons, l'analyse lexicale crée les jetons un après l'autre à la demande : fonction qui renvoie le jeton suivant.

(7)

Diérents générateurs

I Existent pour presque tous les langages de programmation.

I Le premier générateur était lex, publié en 1975 par Mike Lesk et Eric Schmidt. Engendre du code en C.

I Successeur :ex, 1987.

I Les générateurs modernes sont souvent issus de ex. Nous utilisons ici un générateur pour Java : jex.

I Les générateurs pour des autres langages de programmation sont très similaires.

(8)

Le code engendré dans le cas de jex

I Une classe pour l'analyseur lexicale, le nom de la classe peut être déni dans la spécication (dans nos exemples : Lexer).

I 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.

I 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.

(9)

La spécication

Trois parties, séparées par des lignes %% : 1. Code utilisateur

2. Options et déclarations 3. Règles lexicales

(10)

Fichier arith.flex I

// p a r t i e code u t i l i s a t e u r : v i d e

%%// p a r t i e o p t i o n s e t dé c l a r a t i o n s

%p u b l i c

%c l a s s L ex e r

%u n i c o d e

%type Token

EspaceChar = [ \n\ r \ f \ t ]

Ch = [0−9]

Le = [ a−zA−Z ]

%%

// p a r t i e r è g l e s l e x i c a l e s

{Ch}+ { r e t u r n new IntToken (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 new StringToken (Sym . IDENT , y y t e x t ( ) ) ; }

(11)

Fichier arith.flex II

" ( " { r e t u r n new Token (Sym .PARG) ; }

" ) " { r e t u r n new Token (Sym .PARD) ; }

"∗" { r e t u r n new Token (Sym .MULT) ; }

"+" { r e t u r n new Token (Sym . PLUS ) ; }

{ EspaceChar}+ {}

(12)

La partie Code utilisateur

I copiée simplement au début du chier engendré (devant la dénition de la classe)

I partie souvent vide (sauf commentaires, et import ...)

(13)

La partie Options et Déclarations

Options : commencent avec le symbole %. Parmi les options les plus importantes :

I %class nom : donne le nom de la classe engendrée.

I %public : la classe engendrée est publique

I %type t : le type de résultat de la fonction principale de l'analyse lexicale yylex.

I %unicode : accepte des caractères Unicode en entrée de l'analyse lexicale (recommandé)

I %line : compte lignes pendant l'analyse lexicale (disponible en yyline).

I %column : compte colonnes pendant l'analyse lexicale (disponible en yycolumn).

I %states : Déclaration de l'état s (voir plus tard)

(14)

La partie Options et Déclarations

I Code entre %{ et %} (peut être sur plusieurs lignes) :

I copié au début de la classe engendré

I ce code a donc accès aux champs de la classe (par exemple, yyline, yycolumn)

I Code entre %eofval{ et %eofval} : code exécuté quand l'analyse lexicale arrive à la n de l'entrée (défaut : null).

(15)

La partie Options et Déclarations

Macros : système de dénitions d'expressions régulières

I mettre les mots entre apostrophes " et "

I pour utiliser une expression régulières préalablement dénie, par exemple du nom r : {r}.

I classes de caractères, par exemple [a-z]

I quelque classes de caractère prédénies, par exemple

[:letter:], [:digit:], [:uppercase:], [:lowercase:].

(16)

La partie Règles Lexicales

I Séquence de

expression-régulière { code-java }

I Dans le cas le plus simple, le code java est un return ...

I 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.

(17)

Le premier exemple

I Analyse lexicale pour des expressions arithmétiques comme vu la dernière fois.

I Petite diérence au premier exemple : les entiers ne contiennent pas d'exposant.

I Dénition des classes pour les Symboles (type de jetons), puis pour les jetons éventuellement avec des arguments.

I Le chier de spécication pour jflex.

I Un petit programme principal pour tester.

(18)

Fichier Sym.java

// symboles , s o n t u t i l i s é s dans l e s j e t o n s p u b l i c enum Sym {

INT , IDENT , PARG, PARD, MULT, PLUS ; }

(19)

Fichier Token.java I

// j e t o n s , r é s u l t a t de l ' a n a l y s e l e x i c a l e p u b l i c c l a s s Token {

// j e t o n s i m p l e : seulement un symbole p r o t e c t e d Sym symbol ;

p u b l i c Token (Sym s ) { t h i s . symbol = s ; }

p u b l i c Sym symbol ( ) { r e t u r n t h i s . symbol ; }

@Override

p u b l i c S t r i n g t o S t r i n g ( ) {

r e t u r n t h i s . symbol . t o S t r i n g ( ) ; }

(20)

Fichier Token.java II

}

c l a s s StringToken extends Token {

// j e t o n StringToken , avec v a l e u r de type s t r i n g 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 ) { super ( c ) ;

t h i s . v a l u e = s ; }

@Override

r e t u r n t h i s . symbol + " ( " + t h i s . v a l u e + " ) " ; }

}

c l a s s IntToken extends Token {

// j e t o n IntToken , avec v a l e u r de type i n t

(21)

Fichier Token.java III

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 ) { super ( c ) ;

t h i s . v a l u e = i ; }

@Override

r e t u r n t h i s . symbol + " ( " + t h i s . v a l u e + " ) " ; }

}

(22)

Fichier arith.flex I

// p a r t i e code u t i l i s a t e u r : v i d e

%%// p a r t i e o p t i o n s e t dé c l a r a t i o n s

%p u b l i c

%c l a s s L ex e r

%u n i c o d e

%type Token

Ch = [0−9]

Le = [ a−zA−Z ]

%%

// p a r t i e r è g l e s l e x i c a l e s

(23)

Fichier arith.flex II

{ EspaceChar}+ {}

(24)

Fichier Test.java I

import j a v a . i o .∗; p u b l i c 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 r y {

// c r é e r l e r e a d e r u t i l i s é par l ' a n a l y s e u r l e x i c a l e pour l i r e // l e t e x t e d ' e n t r é e

B u f f e r e d R e a d e r r e a d e r =

new B u f f e r e d R e a d e r ( new F i l e R e a d e r ( new F i l e ( a r g s [ 0 ] ) ) ) ; // c r é e r l ' a n a l y s e u r l e x i c a l

L e x e r l e x e r = new L ex e r ( r e a d e r ) ;

// b o u c l e : a n a l y s e l e x i c a l e du t e x t e e n t i e r , e t a f f i c h e r // l e s j e t o n s engendr é s .

Token t ;

do {t = l e x e r . y y l e x ( ) ;

(25)

Fichier Test.java II

i f ( t != n u l l ) {

System . out . p r i n t l n ( t ) ; } w h i l e ( t != n u l l ) ;}

} catch ( IOException e ){

System . e r r . p r i n t l n ( " IOException : " + e . getMessage ( ) ) ; }

} }

(26)

Utilisation de jex

.jex jex .java

.java

javac .class

(27)

Ce que JFlex fait pour vous

I 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.

I Les classes crées doivent être disjointes.

I Exemple : expressions régulières :

"end"

[a-z]*

I Quatre classes de caractères disjointes : [e], [n], [d], [a-cf-mo-z]

(28)

Ce que JFlex fait pour vous

I Création d'un automate non-déterministe pour l'union de toutes les expressions régulières.

I Déterminiser l'automate (et éliminer les -transitions).

I Minimiser l'automate.

I On peut demander à jflex de montrer ces trois automates (option -dot, visualiser les automates avec xdot par exemple)

I Il y a également un mode autonome (standalone) pour des applications simple (pas de génération de jetons), voir le TP.

(29)

Les états de l'analyseur lexical

I Par défaut (comme sur le premier exemple), votre analyseur lexical a un seul état.

I Il peut être utile d'avoir plusieurs états - dans chacque état, Flex peut utiliser des expressions régulières diérentes.

I Pour en avoir plusieurs :

I les déclarer à l'aide de %state (sauf YYINITIAL)

I mettre toutes les règles dans le contexte d'un état

I dans les actions : changer d'état à l'aide de yybegin.

I pas confondre les états de Flex, avec les états de l'automate ni obtenu des expressions régulières

(30)

Pourquoi utiliser plusieurs états ?

I 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 ?)

I Dans ce cas on veut on fait trouver le mot le plus courtdécrit par l'expression régulière. Cela peut être simulé en utilisant deux états.

(31)

Reconnaître les commentaires (simplié)

%%%type 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 ) ; }

. {}

}

(32)

Reconnaître les commentaires

I YYINITIAL est l'état par défaut

I 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 .+)

(33)

Les états de Flex dans l'exemple des commentaires

YYINITAL

start INCOMMENT

{Letter}+

return token(...) {EspaceChar}

/*

*/

.

(34)

Exemple : découper un mot en plusieurs parties

I Retour à notre premier exemple : on souhaite maintenant aussi reconnaître des entiers avec exposant (756e2, par exemple).

I 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.

(35)

Nouvelle version de arith.flex I

%%

%p u b l i c

%c l a s s L ex e r

%type Token

%u n i c o d e

%{i n t i n t b u f f =0;

p r i v a t e S t r i n g chop ( S t r i n g s ) {

// e n v o i e s s a n s son d e r n i e r c a r a c t è r e 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 ) { // e n v o i e ( i n t ∗ 10∗∗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∗10;

(36)

Nouvelle version de arith.flex II

}

r e t u r n r e s u l t ;

%}}

Ch = [0−9]

Le = [ a−zA−Z ]

%s t a t e EXPONENT

%%

<YYINITIAL> {

(37)

Nouvelle version de arith.flex III

{ 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 new IntToken (Sym . INT ,

expo ( i n t b u f f , I n t e g e r . p a r s e I n t ( y y t e x t ( ) ) ) ) ; } }

(38)

Mots clefs d'un langage de programmation

Solution naïve : une règle par mot clefs.

%%%type Token

%%

" 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 } {}

(39)

Attention à l'ordre des règles

Entrée : beg begin beginner

I Premier appel à yylex() : seulement la quatrième règle s'applique ⇒token IDENT.

I 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.

I 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 regardez la taille de l'automate engendré !

(40)

Contrôler la taille de l'automate

I Techniques utilisés par le générateurs :

I Utiliser des classes de caractères dans la représentation de l'automate.

I Minimiser l'automate engendré à partir des expressions régulières.

I Optimisation dans la spécication : Éviter de créer une nouvelle classe lexicale pour chaque mot clef

(Java : 46 mots clefs.)

(41)

Comment reconnaître les mots clefs sans catégories dédiées ?

I En Java (et pareil dans les autres langages de

programmation) : tous les mots clefs sont des séquences de lettres en minuscules.

I Mettre une seule catégorie pour les identicateurs.

I 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.

(42)

Tables de hachage : pour faire quoi ?

I Représenter des fonctions partielles nies f:DA DB I Cas d'usage : Le domainepotentiel DA est très grand ou

même inni ; par contref est dénie seulement pour un petit nombre de valeurs.

I (1) On souhaite un coût mémoire plus au moins linéaire dans la taille du domaine plus la taille du co-domaine def.

I (2) On souhaite une complexité constante pour accéder à la valeur de la fonction appliquée à un argument.

I (3) Fonctions modiables : possibilité d'ajouter ou de supprimer des paires (argument, résultat)

(43)

Tables de hachage : comment ça fonnctionne

I 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 DA en tant d'indices.

I On utilise une fonction de hachage h:D_A →int pour mapper les arguments de la fonction f vers des entiers (indices du tableau).

I 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].

I Le tableau peut donc avoir la taille d.

(44)

Tables de hachage : le problème des conits

I On ne peut pas exclure des conits de la fonction de hachage : x 6=y eth(x) =h(y), même si on essaye de les éviter par un bon choix de la fonction de hachage.

I Pour gérer les conits, les entrées du tableau ne sont pas des valeurs de DB, mais encore des fonctions partiellesDA DB. 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.

(45)

Table de hachage avec listes chaînées

Jorge Stol/Wikimedia, CC-Attribution-Share Alike

(46)

Le chier keys.flex I

import j a v a . u t i l . HashMap ;

c l a s s Keys extends HashMap<S t r i n g , Sym> { p u b l i c Keys ( ) {

super ( ) ;

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

%type Token

%c l a s s L e xe r

%u n i c o d e

(47)

Le chier keys.flex II

%{

p r i v a t e Keys keys = new Keys ( ) ;

p r i v a t e Token token (Sym sym , S t r i n g v a l u e ) { Sym s = keys . get ( 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 } {}