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
