Rappel

Modèle analyse-synthèse de la compilation

code source
position = initial + rate * 60
table de symboles

Analyseur lexicale (scanner) position id1

initial id2
unités lexicales id1 = id2 + id3 * 60 rate id3
(token)

Analyseur syntaxique (parser)

arbre syntaxique

IFT313 © Froduald Kabanza 1

 Rappel
Modèle analyse-synthèse de la compilation
Chacun des éléments du
code source lexique est décrit par une
position = initial + rate * 60 expression régulière

Analyseur lexicale (scanner) L’analyseur lexical est un automate

à états fini déterministe
unités lexicales id1 = id2 + id3 * 60
(token)

Nous avons donc besoin de :

1. Convertir une expression régulière en un AFN

2. Convertir un AFN en AFD
3. Optimiser l’AFD

IFT313 © Froduald Kabanza 2

 Rappel
• Expressions régulières
• Automates à états finis
• Conversion d’une expression régulière en un automate à
états fini non déterministe

IFT313 © Froduald Kabanza 3

 Rappel
• Expressions régulières
• Automates à états finis
• Conversion d’une expression régulière en un automate à
états fini non déterministe

IFT313 © Froduald Kabanza 4

 Expression régulières

 ε (ou ‘’) : L’expression régulière ε représente le langage {ε} (ou {‘’})

 symbole (caractère) : Pour chaque symbole (caractère) a dans
l’alphabet, l’expression régulière a représente le langage {a}, c-à-d., le
langage contenant juste le mot a.

 Étant donnés les expressions régulières r et s représentant, respectivement,

les langages L(r) et L(s) :

 r|s (alternation) est une expression régulière représentant L(r) U L(s).

 rs (concaténation) est une expression régulière représentant L(r)L(s).
 r* (zéro ou plusieurs répétitions) représente (L(r))*.
 (r) est une expression régulière représentant L(r).

IFT313 © Froduald Kabanza 5

 Exemples expressions régulières

 ((a|b)a)*
spécifie le langage de mots de longueur paire terminés par un ‘a’

{ ‘’, aa, ba, aaaa, baaa, aaba, baba, aaaaaa, …}

 (0|1)*0

spécifies l’ensemble de nombres binaires qui sont des multiples de 2.

IFT313 © Froduald Kabanza 6

 Rappel
• Expressions régulières
• Automates à états finis
• Conversion d’une expression régulière en un automate à
états fini non déterministe

IFT313 © Froduald Kabanza 7

 Automates à états finis
Un automate à états finis, ou automate fini (AF) tout court, est un modèle très
simple de programme ayant :
 une entrée de chaîne de symboles (caractères),
 un ensemble fini d’états,
 des transitions entre les états en fonction des symboles lus, et
 un état initial
un ensemble d’états accepteurs (appelés aussi états finaux).

Entrée if (rate >= 0) ……

Tête de lecture

w h ...
2
1
3 4 IF
i f
AF

IFT313 © Froduald Kabanza 8

 Définition formelle

Un automate fini M est un tuple M = (S,A,R,s0, F) :

 A est un ensemble de symboles (l’alphabet)

 S est un ensemble fini d’états
 R est soit:
 Une relation de transition R : S × A*  2S
pour les automate fini non déterministe (AFN)
 Une fonction de transition R:S×A  S
pour les automates finis déterministes (AFD)
 s0 est l’état initial (appartenant dans S)
 F est un ensemble finaux d’états (appartenant dans S)

IFT313 © Froduald Kabanza 9

 Exemple

[0-9]
[0-9] .
2 [0-9]
1 NUM 3
. REAL
“” “” 4 [0-9]
5 SPACE

a..z 0..9 . “ ” other

1 0 2 4 5 0
2 0 2 3 0 0
3 0 3 0 0 0
4 0 3 0 0 0
5 0 0 0 5 0

IFT313 © Froduald Kabanza 10

 Simuler un AFD
Algorithme I : DFASimualtor (Simulateur d’AFD ou PiloteAFD)
 Entrée :
 Chaîne de symboles input terminée par EOF (fin de fichier).
 AFD D, avec la matrice de transitions trans, état initial s0
(initialState), et états accepteurs F
 Sortie : True if D accepts x; False otherwise.
 Approche :
 Suivre la fonction de transition trans.
 Utiliser input.nextChar() pour lire la prochaine caractère
dans input.

IFT313 © Froduald Kabanza 11

 Code de l’algorithme

currentState = D.initialState;
currentInputPosition = 0;
currentChar = input.nextChar();
currentInputPosition++;
while ((currentChar!=EOF) && (currentState !=0 ) )
{
currentState = D.trans[currentState][currentChar];
currentChar = input.nextChar();
currentInputPosition++;
}
if in(currentState, D.F) && (currentChar == EOF))
return TRUE;
else return FALSE;

IFT313 © Froduald Kabanza 12

 Exemple de trace

[0-9]
Entrée : 9 7 . 5 EOF .
[0-9]
2 [0-9]
current 1 NUM 3
Input current
. REAL
Position State “” “” 4
[0-9]
5
0 1 SPACE
1 2
2 2 ‘‘ [0-9] ‘.’
3 3 1 5 2 4

4 3 2 0 2 3
3 0 3 0
Retourne TRUE (accepte l’entrée)
parce qu’il termine dans un état 4 0 3 0
accepteur et toute l’entrée est lue. 5 5 0 0

IFT313 © Froduald Kabanza 13

 Reconnaître des tokens

 L’algorithme précédent accepte ou rejette un chaîne de caractères.

 La tâche d’un analyseur lexical n’est pas juste d’accepter ou rejeter des
chaînes de caractères.
 Il doit trouver la plus longue sous-chaîne de l’entrée correspondant à une
expression régulière (longest match).

 On peut étendre l’algorithme précédent pour garder une trace de la plus

longue sous-chaîne acceptée, en introduisant des variables additionnelles.

IFT313 © Froduald Kabanza 14

 Rappel
• Expressions régulières
• Automates à états finis
• Conversion d’une expression régulière en un automate à
états fini non déterministe

IFT313 © Froduald Kabanza 15

 Algorithme RegExpToNFA

 Entrée : Une expression régulière r sur un alphabet A

 Sortie : Un AFN acceptant L(r).
 Méthode :
 Pour chaque expression régulière r de base (c-à-d., ε ou un
élément de A), il existe un AFN très simple pour L(r).

 Pour chaque expression régulière plus complexe, u, (par

exemple: rs, r|s, r*, r+, [abc], [a-z],…), on obtient l’AFN
pour L(u) en combinant les AFNs pour L(r), L(s), L(a), L(b), …

 On peut ensuite optimiser l’AFN obtenu.

IFT313 © Froduald Kabanza 16

 Cas de base

1. Pour ε, construire l’AFN :

i
tel que i est un nouvel état initial et accepteur.

2. Pour chaque symbole a de l’alphabet, construire l’AFN :

a
i f

Là aussi i et f sont de nouveaux états.

IFT313 © Froduald Kabanza 17

 Cas récursifs
3. Pour l’expression régulière rs, construire l’AFN N(rs) :

r ε s
ε

C-à-d.: L’état initial de N(rs) est l’état initial de N(r) et les états finaux
de N(rs) sont les états finaux de N(s). Ensuite, il faut ajouter des
transitions ε partant des états finaux de N(r) vers l’état initial de N(s).

IFT313 © Froduald Kabanza 18

 Cas récursifs
4. Pour l’expression régulière r|s, construire l’AFN N(r|s) :

r
ε
i
s
ε

C-à-d.: on crée un nouvel état i, avec des transitions ε aux états initiaux
de N(r) et N(s). Les états finaux de N(rs) sont ceux de N(r) et N(s).

IFT313 © Froduald Kabanza 19

 Cas récursifs

5. Pour l’expression régulière r*, construire l’AFN N(r*) :

r ε
ε ε
i
ε

C-à-d: On crée un nouvel état initial i avec une transition ε à l’ancien

état initial de N(r), ainsi que des transitions des états finaux de N(r) à
l’ancien état initial de N(r).

IFT313 © Froduald Kabanza 20