La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

IFT313 Introduction aux langages formels Froduald Kabanza Département dinformatique Université de Sherbrooke planiart.usherbrooke.ca/kabanza/cours/ift313.

Présentations similaires


Présentation au sujet: "IFT313 Introduction aux langages formels Froduald Kabanza Département dinformatique Université de Sherbrooke planiart.usherbrooke.ca/kabanza/cours/ift313."— Transcription de la présentation:

1 IFT313 Introduction aux langages formels Froduald Kabanza Département dinformatique Université de Sherbrooke planiart.usherbrooke.ca/kabanza/cours/ift313 Automates à pile

2 IFT313© Froduald Kabanza2 Sujets Cest quoi un automate à pile ? Quel est le langage accepté par un automate à pile? Quelle est la correspondance entre un automate à pile et une grammaire hors-contexte? Quelle est la correspondance entre un automate à pile et un automate fini?

3 IFT313© Froduald Kabanza3 Objectifs Savoir décrire un automate à pile acceptant un langage donné ? Savoir simuler lexécution dun automate à pile ? Exprimer le pouvoir dexpressivité dun automate à pile ?

4 IFT313© Froduald Kabanza4 Rappel Le problème danalyse 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 danalyse (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 * num Exp() + GrammaireDérivationArbre danalyse

5 IFT313© Froduald Kabanza5 Automate à pile Lapproche pour analyser la syntaxe du code source dun programme est de scanner le programme de gauche à droite, en cherchant une dérivation qui génère ce programme. Le modèle de base dun programme qui fait une telle analyse est un automate à pile (en anglais: pushdown automaton ou stack automaton). Cest une généralisation de la notion dautomate fini à des grammaires hors- contexte. Comme expliqué auparavant, les automates finis peuvent analyser seulement la syntaxe dune grammaire régulière. Pour analyser la syntaxe dune 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.

6 IFT313© Froduald Kabanza6 Modèle général Dans cette leçon on voit une modèle générale dautomate à pile, valide pour les grammaires hors-contexte en général. Par la suite nous verrons des modèles dautomates à pile LL et LR, qui correspondent, 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 dautres que des automates à piles implémentés efficacement. Nous verrons aussi comment ces parseurs peuvent être générés automatiquement à partir dune grammaire. Dici là, nous utiliserons des exemples artificiels très simples.

7 IFT313© Froduald Kabanza7 Limite des automates finis Nous avons vu quun automate fini est un modèle de programme avec un nombre fini détats. Par conséquent, il a nombre fini dactions ou transitions quil 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.

8 IFT313© Froduald Kabanza8 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 quun 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) dun automate. Donc un automate à pile a potentiellement un nombre infini de configurations (~ détats).

9 IFT313© Froduald Kabanza9 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 dentrée (terminaux dune grammaire); Un alphabet de la pile (terminaux et non terminaux dune grammaire) Automate à pile entrée pile $ $

10 IFT313© Froduald Kabanza10 Automate à pile Lentrée est une chaîne de tokens scanné à partir du code source du programme à analyser. La pile contient une chaîne de symboles de lalphabet 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 $ $

11 IFT313© Froduald Kabanza11 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 lentrée lue jusque là et dutiliser cette information dune 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 $ $

12 IFT313© Froduald Kabanza12 Automate à pile : définition formelle Un automate à pile non-déterministe (ou simplement automate à pile) est un tuple : M = (S,V,A,R,s 0,F,$), tel que : S est une ensemble fini détats. V est lalphabet de la pile A est lalphabet dentré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 lentré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 lantécédent de la relation. s 0 (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 lentrée (fin de fichier).

13 IFT313© Froduald Kabanza13Transitions Une transition de la forme (p, u, q, signifie que lautomate peut passer de létat p à létat q, pourvu que la chaîne dentrée commence par le préfixe u et le la chaîne est au sommet de la pile. Après la transition, u est lu et consommé du mot dentrée, est enlevé de la pile et remplacé par et le nouvel état devient q. La chaîne est lue de gauche à droite : son premier caractère doit donc être au sommet de la pile. La chaîne est écrite de telle façon que son premier caractère soit au sommet de la pile. entrée pile pq $ $ entrée pile pq $ $ uu

14 IFT313© Froduald Kabanza14 Configurations, trace, acceptation La configuration dun automate est un triplet (S, V * A * ), indiquant, respectivement, son état courant, le contenu de la pile, et la partie de lentrée qui reste à lire. Une trace (ou exécution) dun automate sur une entrée est la séquence de configurations quil produit en lisant son entrée et en suivant ses transitions. Une exécution accepte une chaîne dentrée si la dernière configuration est de la forme (p, $, $), avec p un état accepteur. En dautre mot, dans la dernière configuration, la pile est vide, on est à la fin de lentrée et létat est accepteur.

15 IFT313© Froduald Kabanza15 Automates à pile déterministe Un automate à pile est déterministe sil a une seule exécution possible pour toute entrée donnée. Sinon, il est non-déterministe. Contrairement aux automates finis, il nest pas toujours possible davoir 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.

16 IFT313© Froduald Kabanza16 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 automate déterministe équivalent. G = (V,A,R,S), tel que : V = {S} A = {a,b} R = {S ε, S aSb} L(G) = {a n b n | n >= 0}, c-à-d., chaîne commençant par des a suivi dautant de b. Automate à pile non-déterministe correspond à la grammaire

17 IFT313© Froduald Kabanza17 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 n b n | n >= 0} Représentation graphique de lautomate sp a, ε/A b, A/ε

18 IFT313© Froduald Kabanza18 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) = {a n b n | n 0} Rappel : configuration: (état, pile, reste-de-lentré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 naccepte. Donc, aabbb nest pas dans le langage.

19 IFT313© Froduald Kabanza19 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) = { R est dans A * }, c-à-d., un palindrome: chaîne concaténé avec son inverse

20 IFT313© Froduald Kabanza20 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) = { R 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écutions qui nacceptent pas. Mais abba est dans le langage puisque au moins une exécution accepte. Rejette. Aucune autre exécution naccepte. Donc abab nest pas dans le langage. (s, $, abab $ ) (s, $ A, aab $ ) (s, $ AB, ab $ ) (p, $ AB, ab $) Pas de transition ! Rappel : configuration: (état, pile, reste-de-lentrée)

21 IFT313© Froduald Kabanza21 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) = { R 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 = { R est dans {a,b}*}, est non-déterministe hors-contexte. Par contre, le langage similaire L2 = { c R 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.

22 IFT313© Froduald Kabanza22 Au delà des langages hors-contexte Bien quun automate à pile peut avoir un nombre infini détats (configurations), 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 n b n c n | n 0} nest 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 nimporte quel langage.

23 IFT313© Froduald Kabanza23 Exercice 1.Étant donné lalphabet {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 lordre dans lequel ces deux symboles apparaissent dans le mot. (b) Un automate à pile (non-déterministe) acceptant le même langage.

24 IFT313© Froduald Kabanza24 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 } s0s0 a, A/AA a, $/$A b, B/BB b, $/$B a, B/ε b, A/ ε a)Automate à pile correspondant M = ({s 0 },{A,B},{a,b},R, s 0,{s 0 },$) :

25 IFT313© Froduald Kabanza25 Résumé Un automate à pile est un modèle de programme simple pour lanalyse 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.


Télécharger ppt "IFT313 Introduction aux langages formels Froduald Kabanza Département dinformatique Université de Sherbrooke planiart.usherbrooke.ca/kabanza/cours/ift313."

Présentations similaires


Annonces Google