Date post: | 03-Apr-2015 |
Category: |
Documents |
Upload: | dieudonne-vaillant |
View: | 103 times |
Download: | 0 times |
IFT313Introduction aux langages formels
Froduald Kabanza
Département d’informatique
Université de Sherbrookeplaniart.usherbrooke.ca/kabanza/cours/ift313
Automates à pile
© Froduald Kabanza
2IFT313
Sujets
• C’est quoi un automate à pile ?
• Quel est le langage accepté par un automate à pile?
• Quelle est la correspondance entre un automate à pile et une gram-maire hors-contexte?
• Quelle est la correspondance entre un automate à pile et un automate fini?
© Froduald Kabanza
3IFT313
Objectifs
• Savoir décrire un automate à pile acceptant un langage donné ?
• Savoir simuler l’exécution d’un automate à pile ?
• Exprimer le pouvoir d’expressivité d’un automate à pile ?
IFT313 © Froduald Kabanza
4
Rappel- Le problème d’analyse syntaxique (parsing) est :
- étant donné une chaîne de lexèmes (tokens) et une grammaire- déterminer si oui ou non la chaîne est dérivable de la grammaire - et si oui, donner la séquence de dérivation ou un arbre d’analyse (ou un
arbre syntaxique). - Exemple : est-ce que (num + num) * num est syntaxiquement correcte?
Exp
Symbole de départProductions1. Exp → num2. Exp → ( Exp ) 3. Exp → Exp + Exp4. Exp → Exp * Exp
Exp * Exp
Exp * num
(Exp + Exp) * num
(Exp + num) * num
(num + num) * num
(Exp) * num
Þ
Þ
Þ
ÞÞ
Þ
Exp
Exp * Exp
num
num
num
Exp( )
Exp + Exp
Grammaire Dérivation Arbre d’analyse
© Froduald Kabanza
5IFT313
Automate à pile
- L’approche pour analyser la syntaxe du code source d’un programme est de scan-ner le programme de gauche à droite, en cherchant une dérivation qui génère ce programme.
- Le modèle de base d’un programme qui fait une telle analyse est un automate à pile (en anglais: pushdown automaton ou stack automaton).
- C’est une généralisation de la notion d’automate fini à des grammaires hors-contexte.
- Comme expliqué auparavant, les automates finis peuvent analyser seulement la syntaxe d’une grammaire régulière.
- Pour analyser la syntaxe d’une grammaire hors-contexte, nous ajoutons une pile à un automate fini pour obtenir un modèle de programmes plus puissant connu sous le nom de “automate à pile”.
© Froduald Kabanza
6IFT313
Modèle général- Dans cette leçon on voit une modèle générale d’automate à pile, valide pour les
grammaires hors-contexte en général.
- Par la suite nous verrons des modèles d’automates à pile LL et LR, qui corres-pondent, respectivement aux analyseurs syntaxiques LL et LR, c-à-d., à des sous-ensembles de grammaires hors-contexte pouvant être analysés efficacement.
- En fait nous verrons que des parseurs LL et LR ne sont rien d’autres que des auto-mates à piles implémentés efficacement.
- Nous verrons aussi comment ces parseurs peuvent être générés automatiquement à partir d’une grammaire.
- D’ici là, nous utiliserons des exemples artificiels très simples.
© Froduald Kabanza
7IFT313
Limite des automates finis
- Nous avons vu qu’un automate fini est un modèle de programme avec un nombre fini d’états.
- Par conséquent, il a nombre fini d’actions ou transitions qu’il peut effectuer.
- Comme il a un nombre fini d’états et de transitions, il est très simple à programmer et même à visualiser graphiquement.
- Par contre il ne peut pas analyser le langage généré par une grammaire hors-contexte.
- Il peut seulement analyser le langage généré par une grammaire régulière.
© Froduald Kabanza
8IFT313
Automate à pile- Un automate à pile ressemble à un automate fini. Il a :
- un flux (stream) de lecture et un pointeur vers le prochain symbole (lexème/to-ken) à lire;
- un nombre fini d’états, y compris un état initial et des états accepteurs;- une relation de transition.
- La différence est qu’un automate à pile a en plus une pile, initialement vide, mais pouvant croître arbitrairement.
- Le contenu de la pile fait partie de la configuration (~ état) d’un automate.
- Donc un automate à pile a potentiellement un nombre infini de configura-tions (~ d’états).
© Froduald Kabanza
9IFT313
Automate à pile
- Un automate à pile a : - Une entrée et une tête de lecture.- Un nombre fini d’états dont un état initial et des états accepteurs. - Une relation de transition.- Une pile pouvant croître arbitrairement.- Un alphabet d’entrée (terminaux d’une grammaire);- Un alphabet de la pile (terminaux et non terminaux d’une grammaire)
Automate à pile
entrée
pile
$
$
© Froduald Kabanza
10IFT313
Automate à pile
- L’entrée est une chaîne de tokens scanné à partir du code source du programme à analyser.
- La pile contient une chaîne de symboles de l’alphabet de la pile (terminaux et non-terminaux de la grammaire)
- Les transitions indiquent comment mettre à jour le contenu de la pile en fonction du token courant.
Automate à pile
entrée
pile
1
2
3
4
$
$
© Froduald Kabanza
11IFT313
Automate à pile- Comment définir un automate à pile correspondant à une grammaire?
- Le principe de base est de mettre sur la pile des symboles de la grammaire qui correspondent (match) au préfixe de l’entrée lue jusque là et d’utiliser cette in-formation d’une certaine façon pour déterminer la production à appliquer à la prochaine étape de dérivation.
- Ceci deviendra clair avec des exemples.
Automate à pile
entrée
pile
1
2
3
4
$
$
© Froduald Kabanza
12IFT313
Automate à pile : définition formelle- Un automate à pile non-déterministe (ou simplement automate à pile) est un tuple :
M = (S,V,A,R,s0,F,$), tel que :
• S est une ensemble fini d’états.• V est l’alphabet de la pile • A est l’alphabet d’entrée • R: (S × A*× V*) (S × V*) est la relation de transitions
Autrement dit, la relation spécifie pour chaque état dans S, sous-chaîne lue de l’entrée (A*) et sous-
chaîne en haut de la pile (V*), le prochain état (dans S) et la sous-chaîne à mettre au sommet de la
pile à la place de celle dans l’antécédent de la relation.
• s0 (dans S) est l’état initial.
• F (inclus dans S) est un ensemble d’états accepteurs.• $ est le symbole initialement au fond de la pile et dénote aussi la fin de l’en-
trée (fin de fichier).
© Froduald Kabanza
13IFT313
Transitions- Une transition de la forme (p, u, ) (b q, )g signifie que l’automate peut passer de
l’état p à l’état q, pourvu que la chaîne d’entrée commence par le préfixe u et le la chaîne b est au sommet de la pile. Après la transition, u est lu et consommé du mot d’entrée, b est enlevé de la
pile et remplacé par g, et le nouvel état devient q. La chaîne b est lue de gauche à droite : son premier caractère doit donc être au
sommet de la pile. La chaîne g est écrite de telle façon que son premier caractère soit au sommet
de la pile.
entrée
pile
p q
$
$
entrée
pile
p q
$
$
u u
b g
© Froduald Kabanza
14IFT313
Configurations, trace, acceptation
- La configuration d’un automate est un triplet (S, V*, A*), indi-quant, respectivement, son état courant, le contenu de la pile, et la partie de l’entrée qui reste à lire.
- Une trace (ou exécution) d’un automate sur une entrée est la séquence de configurations qu’il produit en lisant son entrée et en suivant ses transitions.
- Une exécution accepte une chaîne d’entrée si la dernière configuration est de la forme (p, $, $), avec p un état accep-teur.
En d’autre mot, dans la dernière configuration, la pile est vide, on est à la fin de l’entrée et l’état est accepteur.
© Froduald Kabanza
15IFT313
Automates à pile déterministe
- Un automate à pile est déterministe s’il a une seule exécution possible pour toute entrée donnée.
- Sinon, il est non-déterministe.
- Contrairement aux automates finis, il n’est pas toujours possible d’avoir un automate à pile déterministe correspondant à un automate à pile non-dé-terministe.
- Les analyseurs lexicaux pratiques (inclus ceux que nous allons étudier) sont basés sur des automates à pile déterministes.
- Pour toute grammaire hors-contexte, il existe un automate à pile non-dé-terministe acceptant le langage généré par la grammaire.
© Froduald Kabanza
16IFT313
Exemple 1
- M = (S,V,T,R,s,S,$), tel que:• S = {s,p}• V = {A}• T = {a,b}• R = { (s, a, ε) (s, A),
(s, ε, $) (p, ε),
(s, b, A) (p, ε),
(p, b, A) (p, ε)}
- La deuxième transition est inutile.- En la supprimant on obtient un au-
tomate déterministe équivalent.
G = (V,A,R,S), tel que :
V = {S}
A = {a,b}
R = {S ® ε, S ® aSb}
- L(G) = {an bn | n >= 0},
c-à-d., chaîne commençant par des a suivi d’autant de b.
- Automate à pile non-déterministe correspond à la grammaire
© Froduald Kabanza
17IFT313
Exemple 1 (représentation graphique)
- M = (S,V,T,R,s,S,$), tel que:• S = {s,p}• V = {A}• T = {a,b}• R = { (s, a, ε) (s, A),
(s, b, A) (p, ε),
(p, b, A) (p, ε)}
- L(M) = {an bn | n >= 0}
Représentation graphique de l’automate
s p
a, ε/A b, A/ε
b, A/ε
© Froduald Kabanza
18IFT313
Exemple 1 (Exécutions)
- M = (S,V,T,R,s,S,$) :• S = {s,p}• V = {A}• T = {a,b}• R = { (s, a, ε) (s, A),
(s, ε, $) (p, ε),
(s, b, A) (p, ε),
(p, b, A) (p, ε)}
- L(M) = {an bn | n ≥ 0}
Rappel : configuration: (état, pile, reste-de-l’entrée)
Entrée: aabb
(s, $, aabb$)(s, $A, abb$)(s, $AA, bb$)(p, $A, b$)(p, $, $)
Entrée: aabbb
(s, $, aabbb$)(s, $A, abbb$)(s, $AA, bbb$)(p, $A, bb$)(p, $, b$)
Accepte
Rejette. Aucune autre exécution n’accepte.Donc, aabbb n’est pasdans le langage.
© Froduald Kabanza
19IFT313
Exemple 2
- M = (S,V,T,R,s,S,$) :• S = {s,p}• V = {A,B}• T = {a,b}• R = { (s, a, ε) (s, A), (s, b, ε) (s, B), (s, ε, ε) (p, ε), (p, a, A) (p, ε), (p, b, B) (p, ε)}
G = (V,A,R,S), tel que:
V = {S}
A = {a,b}
R = {S ® ε, S ® aSa, S ® bSb}
• Automate non-déterministe correspondant à la grammaire :
• L(G) = {w wR | w est dans A*}, c-à-d., un palindrome: chaîne concaténé avec son inverse
© Froduald Kabanza
20IFT313
Exemple 2 (Exécutions)
- M = (S,V,T,R,s,S,$) :• S = {s,p}• V = {A,B}• T = {a,b}• R = { (s, a, ε) -> (s, A), (s, b, ε) ->(s,B), (s, ε, ε) ->(p,ε), (p, a, A) ->(p,ε), (p, b, B) ->(p,ε)}
- L(M) = {w wR | w est dans T*}
Input: abba
(s, $, abba$)(s, $A, bba$)(s, $AB, ba$)(p, $AB, ba$)(p, $A, a$)(p, $,$)
Input: abab
Accepte. Il y a des exécutionsqui n’acceptent pas. Mais abba est dans le langage puisqueau moins une exécution accepte.
Rejette. Aucune autreexécution n’accepte.Donc abab n’est pas dans le langage.
(s, $, abab$)(s, $A, aab$)(s, $AB, ab$)(p, $AB, ab$)
Pas de transition !
Rappel : configuration: (état, pile, reste-de-l’entrée)
© Froduald Kabanza
21IFT313
Discussion
- M = (S,V,T,R,s,S,$) :• S = {s,p}• V = {A,B}• T = {a,b}• R = { (s, a, ε) -> (s, A),
(s, b, ε) ->(s, B),
(s, ε, ε) ->(p, ε),
(p, a, A) ->(p, ε),
(p, b, B) ->(p, ε)}
- L(M) = {w wR | w est dans T*}
Cet automate à pile est non-déterministe. Une question intéressante est « y-a-t-il un automate à pile déterministe équivalent? »
La réponse est «non». Donc le langage L1 = {w wR | w est dans {a,b}*}, est non-déterministe hors-contexte.
Par contre, le langage similaire L2 = {w c wR | w est dans {a,b}*} est déterministe hors-contexte.
Intuitivement, avec L2 on peut de manière déterministe vérifier le milieu de la chaîne. AvecL1, on ne peut pas.
Exercice: Donner une grammaire hors-contexte et un automate à pile déterministe pour L2.
© Froduald Kabanza
22IFT313
Au delà des langages hors-contexte
- Bien qu’un automate à pile peut avoir un nombre infini d’états (configura-tions), il existe des langages qui ne sont pas acceptés par un automate à pile, c-à-d., des langages qui ne sont pas hors-contextes.
- Exemple:
L(M) = {an bn cn | n ≥0}
n’est pas hors-contexte.
- Toutefois, il existe des modèles théoriques de programmes qui accepte un
tel langage. En particulier, les machines de Turing sont des généralisations
des automates à piles, pouvant accepter n’importe quel langage.
© Froduald Kabanza
23IFT313
Exercice
1. Étant donné l’alphabet {a,b}, donnez :
(a) Une grammaire générant le langage composé de mots ayant le même nombre de a et de b, peu importe l’ordre dans lequel ces deux sym-boles apparaissent dans le mot.
(b) Un automate à pile (non-déterministe) acceptant le même langage.
IFT313 © Froduald Kabanza
24
Solution
a) Grammaire générant le langage composé de mots ayant le même nombre de a et de b
G = (V,A,R,S), tel que:
V = {S}
A = {a,b}
R = { S ε
S aSbS S bSaS }
s0
a, A/AAa, $/$A
b, B/BBb, $/$B
a, B/ε
b, A/ ε
a) Automate à pile correspondant
M = ({s0},{A,B},{a,b},R, s0,{s0},$) :
© Froduald Kabanza
25IFT313
Résumé
- Un automate à pile est un modèle de programme simple pour l’analyse syntaxique.
- Les parsers LL et LR sont fondamentalement des automates à pile déterministes.
- On les obtient en imposant des restrictions sur les grammaires hors-contexte.
- En général ces restrictions sont acceptables pour les langages de programmation courants.
- Les quelques prochaines leçons sera sur les parsers LL.
- Nous verrons les parsers LR vers la fin.