IFT313 Introduction aux langages formels

IFT313

Introduction aux langages formels

Froduald Kabanza

Département d’informatique Université de Sherbrooke

planiart.usherbrooke.ca/kabanza/cours/ift313

Automates à pile

IFT313 © Froduald Kabanza

2

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?

IFT313 © Froduald Kabanza

3

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

Références

[1] Sudkamp, T. A.. Languages and Machines. Third Edition Edition.

Addison-Wesley, 2005.

– Section 7.1

[3] Wolper, P. Introduction à la calculabilité, 3è édition. Dunod, 2006 – Sections 4.1 à 4.2, 4.4

IFT313 © Froduald Kabanza

5

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épart

Productions 1. Exp → num 2. Exp → ( Exp ) 3. Exp → Exp + Exp 4. 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

IFT313 © Froduald Kabanza

6

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-con- texte.

- 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”.

IFT313 © Froduald Kabanza

7

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 correspon- dent, respectivement aux analyseurs syntaxiques LL et LR, c-à-d., à des sous-en- sembles 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.

IFT313 © Froduald Kabanza

8

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 (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-con- texte.

- Il peut seulement analyser le langage généré par une grammaire régulière.

IFT313 © Froduald Kabanza

9

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/token) à 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).

IFT313 © Froduald Kabanza

10

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

$

$

IFT313 © Froduald Kabanza

11

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

$

$

IFT313 © Froduald Kabanza

12

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 la dérivation.

- Ceci deviendra clair avec des exemples.

Automate à pile entrée

pile

1 2

3 4

$

$

IFT313 © Froduald Kabanza

13

Automate à pile : définition formelle

- Un automate à pile non-déterministe (ou simplement automate à pile) est un tuple : M = (S,V,A,R,s₀,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 transition

 Autrement dit, la relation spécifie

 pour chaque état dans S, sous-chaîne lue de l’entrée (A^*) et sous- chaîne au sommet 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.

• s₀ (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. Il dénote aussi la fin de l’en- trée (fin de fichier).

IFT313 © Froduald Kabanza

14

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 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

IFT313 © Froduald Kabanza

15

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 con- figuration est de la forme (p, $, $), avec p un état accepteur.

 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.

IFT313 © Froduald Kabanza

16

Exemple 1

- M = (S, V U A, 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, ε)}

- 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) = {aⁿ bⁿ | n >= 0},

c-à-d., chaîne commençant par des a suivi d’autant de b.

- Automate à pile non-déterministe correspond à la grammaire

IFT313 © Froduald Kabanza

17

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) = {aⁿ bⁿ | n >= 0}

Représentation graphique de l’automate

s p

a, ε/A b, A/ε

b, A/ε

IFT313 © Froduald Kabanza

18

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, b, A) (p, ε), (p, b, A) (p, ε)}

- L(M) = {a

b

| 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 pas dans le langage.

IFT313 © Froduald Kabanza

19

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.

IFT313 © Froduald Kabanza

20

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 w

| w est dans A

}, c-à-d.,

un palindrome: chaîne concaténé avec

son inverse

IFT313 © Froduald Kabanza

21

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 w^R | w est dans T^*}

Input: abba (s, $, abba$) (s, A$, bba$) (s, BA$, ba$) (p, BA$, ba$)

(p, A$, a$) (p, $,$)

Input: abab

Accepte. Il y a des exécutions qui n’acceptent pas. Mais abba est dans le langage puisque au moins une exécution accepte.

Rejette. Aucune autre exécution n’accepte.

Donc abab n’est pas dans le langage.

(s, $, abab$) (s, A aab$) (s, BA$, ab$) (p, BA$, ab$) Pas de transition ! Rappel : configuration: (état, pile, reste-de-l’entrée)

IFT313 © Froduald Kabanza

22

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 w^R | 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 w^R | w est dans {a,b}*}, est non-déterministe hors-contexte.

Par contre, le langage similaire

L2 = {w c w^R | 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. Avec L1, on ne peut pas.

Exercice: Donner une grammaire hors-contexte et un automate à pile déterministe pour L2.

IFT313 © Froduald Kabanza

23

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) = {a

b

c

| n ≥0}

n’est pas hors-contexte.

- Toutefois, il existe des modèles théoriques de programmes qui acceptent

un tel langage. En particulier, les machines de Turing sont des généralisa-

tions des automates à piles, pouvant accepter n’importe quel langage.

IFT313 © Froduald Kabanza

24

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

25

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 }

s₀ a, A/AA

a, $/$A

b, B/BB b, $/$B

a, B/ε b, A/ ε a) Automate à pile correspondant

M = ({s

},{A,B},{a,b},R, s

,{s

},$) :

IFT313 © Froduald Kabanza

26

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 seront sur les parseurs LL.

- Nous verrons les parseurs LR vers la fin du cours.