Analyse lexicale

Généralités

Expressions rationnelles

Automates finis

Analyseurs lexicaux

Rôle d'un analyseur lexical

code source

lexèmes

...analyseurlexical

analyseursyntaxique

table dessymboles

Séparer l'analyse lexicale de l'analyse syntaxique

Réduire la complexité du compilateur et la complexité de conception de ces deux modules

Augmenter la flexibilité du compilateur : portabilité, maintenabilité

Augmenter l'efficacité du compilateur

Méthodes de construction

Utiliser un générateur d'analyseurs lexicaux (Flex)

Ecrire l'analyseur lexical dans un langage évolué

Lecture du code source (1/2)

On utilise un tampon de lecture cyclique en deux moitiés

Anticiper = lire quelques caractères d'avance pour décider la valeur du lexème en cours

... a = 4 * i + 1 ...

debut

fin

Une anticipation de quelques caractères suffit

Un langage où il n'y avait pas de limite à la taille de l'anticipation : PL/1

DECLARE ( ARG1, ARG2, ... , ARGn )

Il faut attendre la fin de l'expression pour savoir si DECLARE est un mot-clé ou un nom de tableau

Lecture du code source (2/2)... a = 4 * i + 1 ...

debut

fin

si fin atteint la fin de la première moitié

alors { charger la deuxième moitié

fin := fin + 1 }

sinon si fin atteint la fin de la deuxième moitié

alors { charger la première moitié

fin := 0 }

sinon fin := fin + 1

Mots et langages formelsUn mot sur un alphabet A est une suite finie de

symboles pris dans A

A peut être l'ensemble des caractères, dans ce cas les lexèmes sont des mots

alphabet mots

code ASCII { 0, 1 } caractères

analyse lexicale caractères lexèmes

analyse syntaxique lexèmes programmes

Le mot vide est noté ε, sa longueur est 0

Un langage formel est un ensemble de mots

Expressions rationnellesOn forme des expressions à partir des symboles (éléments de l'alphabet)

et de ε en utilisant

- l'union notée | (ou +)

- la concaténation (pas de symbole)

- l'itération notée *

On utilise souvent des opérations supplémentaires (abréviations) :+ pour l'itération au moins une fois

? pour l'option

. pour tout l'alphabet

[...] pour une union de symboles

Priorités entre opérateurs : itération, concaténation, union

Expressions rationnelles

Identificateurs en C

lettre = A | B | ... | Z | a | b | ... | z

chiffre = 0 | 1 | ... | 9

id = (lettre | _) (lettre | _ | chiffre)*

Nombres sans signe en C

chiffre = 0 | 1 | ... | 9

chiffres = chiffre chiffre*

frac = . chiffres

exp = (E | e) (+ | - | ε) chiffres | ε

num = (chiffres (frac | . | ε) | frac) exp

Les mêmes avec les abréviations

chiffre = 0 | 1 | ... | 9

chiffres = chiffre+

frac = . chiffres

exp = ((E | e) (+ | -) ? chiffres)?

num = (chiffres (frac | .)? | frac) exp

LexèmesDéfinition des espaces blancs

delim = \b | \t | \n

ws = delim*

On dit habituellement lexème pour "catégorie de lexèmes" :

expression

lexème attribut

ws - -

if if -

else else -

id id pointeur

num num valeur

etc.

expression lexème attribut

< relop lt

<= relop le

== relop eq

!= relop ne

> relop gt

>= relop ge

Automates finis

Les analyseurs lexicaux utilisent des graphes appelés automates finis

- les sommets sont appelés états

- les transitions sont orientées et étiquetées

- certains états sont finaux et comportent une action

11 12 13 return(gettoken(), install)lettre_

autre

lettre | _ | chiffre

Identificateurs en C

Automates finis0 1 2 return(relop, lt)

<autre

Opérateurs de comparaison

5

6

8

3

10

return(relop, le)

return(relop, gt)

return(relop, ge)

return(relop, eq)

return(relop, ne)

4

7

9

=

>

==

=

!

=

autre

Automates finis

14

15

19chiffre autre

Nombres sans signe en C

2120

.

chiffre

16 17 18

E | e+ | - chiffre

chiffre

chiffreE | e

chiffre.

chiffre

22

23

24chiffre

autre

2625

.

chiffre

chiffre.

chiffreautre

Implémentation en C

Un programme C qui reconnaît dans le début d'une chaîne de caractères un des lexèmes définis par les automates

/* Recherche de l'état initial du prochain automate */

int state = 0, start = 0 ;

int lexical_value ;

int fail() {

forward = token_debut ;

switch(start) {

case 0 : start = 11 ; break ;

case 11 : start = 14 ; break ;

case 14 : start = 22 ; break ;

case 22 : recover() ; break ;

default : /* erreur */ }

return start ; }

token nexttoken() {

while (1) {

switch(state) {

case 0 : c = nextchar() ;

if (c==blank||c==tab||c==newline) {

state = 0 ; debut ++ ; }

else if (c == '<') state = 1 ;

else if (c == '>') state = 4 ;

else if (c == '=') state = 7 ;

else if (c == '!') state = 9 ;

else state = fail() ;

break ;

/* ... cas 1 - 10 ... */

case 11 : c = nextchar() ;

if (isletter(c)||c=='_') state = 12 ;

else state = fail() ;

break ;

case 12 : c = nextchar() ;

if (isletter(c)||c=='_') state = 12 ;

else if (isdigit(c)) state = 12 ;

else state = 13 ;

break ;

case 13 : retract(1) ; install_id() ;

return(gettoken()) ;

/* ... cas 14-26 ... */

}

}

}

Automates déterministes

Un automate fini est déterministe si :

- il possède au plus un état initial

- de chaque état part au plus une flèche étiquetée par un symbole donné

Exemple d'automate non déterministe :

1 2a

a

Exemple d'automate déterministe :

a | b

1 2a

ab

b

Automates déterministes

Un automate déterministe représentant un ensemble de mots peut être utilisé commodément pour reconnaître l'un des mots dans une chaîne de caractères : il suffit de partir de l'état initial, de suivre les flèches et de voir si l'état dans lequel on arrive est final.

Tout automate fini est équivalent à un automate fini déterministe : il existe un automate fini déterministe qui reconnaît le même langage.

DéterminisationAlgorithme : on part d'un automate fini A = (Q, I, F, ). On

construit l'automate déterministe D ayant

1. comme états les parties de Q

2. comme état initial I

3. comme états finaux les parties de Q contenant au moins un élément de F

4. comme transitions les (U, a, V) si V est l'ensemble des états atteignables depuis U par une transition étiquetée a

Complexité : si A a n états, D a au plus 2n états.

Exemple

1 1 2 1 3a b

a

Le résultat de l'algorithme

ab

b

1 2 3a b

Un automate non déterministe

a | b

Généralisation

On peut admettre des transitions d'étiquette (transitions spontanées).

Pour être déterministe, un automate ne doit pas contenir de transitions spontanées.

Pour déterminiser, on adapte l'algorithme précédent :

- à l'étape 2 on prend l'ensemble des états atteignables depuis I par un chemin de transitions spontanées ;

- à l'étape 3, V est l'ensemble des états atteignables depuis U par un chemin étiqueté a

La construction récursive

On peut construire un automate fini équivalent à une expression rationnelle : il reconnaît le même langage.

L'automate construit est tel que :

- il a un seul état initial i

- il a un seul état final f i

- aucune transition n'entre dans i

- aucune transition ne sort de f.

Pour et a, on prend:

a

union

itération

concaténation

Utilisation de Flex

spécificationFlex

lex.yy.c

lexèmes

flex compilateur C

a.out

4 étapes :

- créer sous éditeur une spécification Flex (expressions rationnelles)

- traiter cette spécification par la commande flex

- compiler le programme source C obtenu

- exécuter le programme exécutable obtenu

caractères(code source)

...

Spécifications FlexUn programme Flex est fait de trois parties :

déclarations

%%

règles de traduction

%%

fonctions auxiliaires en C

Les règles de traduction sont de la forme

p1 { action1 }

p2 { action2 }

...

pn { actionn }

où chaque pi est une expression rationnelle et chaque action une suite d'instructions en C.

Exemple%{

/* Partie en langage C : définitions de constantes,

déclarations de variables globales, commentaires... */

%}

delim [ \t\n]

letter [a-zA-Z]

%%

{delim}* { /* pas d'action */ }

if { return IF ; }

then { return THEN ; }

else { return ELSE ; }

{letter}({letter}|[0-9])* { yyval = install_id() ;

return ID ; }

([0-9]+(\.[0-9]*)?|\.[0-9]+)((E|e)(\+|-)?[0-9]+)?{

yyval = install_num() ; return NUMBER ; }

Exemple"<" { yyval = LT ; return RELOP ; }

"<=" { yyval = LE ; return RELOP ; }

%%

install_id() {

/* fonction installant dans la table des symboles le lexème vers lequel pointe yytext et dont la longueur est yylength. Renvoie un pointeur sur l'entrée dans la table */

}

install_num() {

/* fonction calculant la valeur du lexème */

}

Spécifications FlexLes commentaires /* ... */ ne peuvent être insérés que dans une portion

en C :

- dans la partie déclaration, seulement entre %{ et %} ;

- dans la partie règles, seulement dans les actions ;

- dans la partie fonctions auxiliaires, n'importe où.

Dans les règles

pi { actioni }

les expressions rationnelles pi ne peuvent pas contenir d'espaces blancs (ou alors dé-spécialisés).

Dans la partie règles, si une règle commence par un espace blanc, elle est interprétée comme du langage C et est insérée dans lex.yy.c au début de la fonction qui renvoie le prochain lexème (utilisable pour déclarer des variables locales).

Segmentation du code sourcepar l'analyseur lexical (1/3)

L'analyseur lexical produit par Flex

- commence à chercher les lexèmes au début du code source ;

- après chaque lexème reconnu, recommence à chercher les lexèmes juste après

Exemple : si piraté est reconnu, raté n'est pas reconnu

Si aucun lexème n'est reconnu à partir d'un point du code source

l'analyseur affiche le premier caractère sur la sortie standard et recommence à chercher à partir du caractère suivant

Segmentation du code sourcepar l'analyseur lexical (2/3)

Si plusieurs lexèmes sont reconnus à partir d'un point du code source (conflit)

1. Deux lexèmes de longueurs différentes

C'est le plus long qui gagne

Exemple : [a-zA-Z_] [a-zA-Z_0-9]*

Segmentation du code sourcepar l'analyseur lexical (3/3)

2. Deux lexèmes de même longueur

Ils commencent au même point et terminent au même point : s'il y a conflit, c'est qu'ils sont issus de deux règles différentes. C'est la règle qui apparaît la première dans la spécification Flex qui gagne

Exemple : conflit entre [a-zA-Z_] [a-zA-Z_0-9]* et while

Mettre l'exception avant la règle

En dehors de ce cas, l'ordre des règles ne joue pas