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.