IFT313 Introduction aux langages formels Froduald Kabanza Département d’informatique Université de Sherbrooke planiart.usherbrooke.ca/kabanza/cours/ift313 Automates finis

Sujets couverts Automates finis. Reconnaître des tokens avec un automate fini. IFT313 © Froduald Kabanza

Objectifs Être capable d’écrire une automate fini acceptant un langage donné. Être capable de programmer un automate fini reconnaissant les tokens d’un langage donné. IFT313 © Froduald Kabanza

Références [1] Sudkamp, T. A.. Languages and Machines. Third Edition Edition. Addison-Wesley, 2005. Sections 5.1 à 5.5. [2] Appel, A. and Palsberg. J. Modern Compiler Implementation in Java. Second Edition. Cambridge, 2004. Sections 2.3 [3] Wolper, P. Introduction à la calculabilité, 3è édition. Dunod, 2006 Sections 2.1 à 2.5 [4] Aho, A., Lam, M., Sethi R., Ullman J. Compilers: Principles, Techniques, and Tools, 2nd Edition. Addison Wesley, 2007. Sections 3.6 IFT313 © Froduald Kabanza

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 i f IF 1 3 4 ... 2 w h AF IFT313 © Froduald Kabanza

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

Langage accepté par un automate La trace d’exécution d’un automate est la séquence d’états qu’il traverse en lisant son entrée. Un automate accepte son entrée s’il existe une exécution telle que l’automate génère une trace terminant par un état accepteur et toute l’entrée est lu. Pour un automate non déterministe il y a plusieurs exécution potentielles: Un tel automate accepte son entrée si une telle exécutions terminant par un état accepteur et toute l’entrée est lu. Le langage accepté par un automate est l’ensemble des mots acceptés par l’automates. IFT313 © Froduald Kabanza

Exemples 1 2 [a-z] [0-9] ID : REAL : 1 3 4 2 [0-9] . NUM : 1 2 [0-9] IFT313 © Froduald Kabanza

Exemples Commentaires, espaces, \n, \t : “ “, \n, \t 1 4 / \n 2 3 [a-z] 5 “ “, \n, \t IFT313 © Froduald Kabanza

Exemple : automate combiné [a-hj-z] [a-eg-z0-9] [0-9a-z] ID IF f i 2 3 4 [0-9a-z] ID 1 . [0-9] “ “, \n, \t / 5 6 [0-9] Error REAL other 9 Error [0-9] [0-9] 7 “ “, \n, \t / [a-z] 10 NUM 12 . [0-9] 13 white space Comments \n 8 Error 11 REAL IFT313 © Froduald Kabanza

Implémenter un AFD AFD = Automate fini déterministe La composante principale d’un AFD est sa fonction de transition. Elle est facilement implémentée par un tableau à deux dimensions indexé par les états (des nombres) et l’alphabet. Par exemple si on met les états en lignes et l’alphabet en colonne trans[s][a] est l’état successeur de s sous la transition a IFT313 © Froduald Kabanza

. Exemple . a..z 1 3 4 2 5 “ ” 0..9 “ ” 1 2 3 4 5 [0-9] NUM REAL SPACE “ ” other 1 2 3 4 5 IFT313 © Froduald Kabanza

Implémenter un AFD En pratique l’AFD sera calculé par un générateur d’analyseur lexical tel que JFLEX, à partir d’un ensemble d’expressions régulières, du genre : (“ ”)+ { /* ignore */} [0-9]+ {return new Token(…);} ([0-9]+ “.”[0-9]*) | (“.”[0-9]+) {return new Token(…);} IFT313 © Froduald Kabanza

Implémenter un AFD (“ ”)+ L’automate global est une combinaison des automates individuels 2 1 SPACE “ ” (“ ”)+ 2 1 NUM [0-9] [0-9]+ 1 3 4 2 [0-9] . REAL ([0-9]+ “.”[0-9]*) | (“.”[0-9]+) IFT313 © Froduald Kabanza

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

Code de l’algorithme currentState = D.initialState; currentInputPosition = 0; currentChar = input.nextChar(); currentInputPosition++; while ((currentChar!=EOF) && (currentState !=0 ) ) { currentState = D.trans[currentState][currentChar]; } if in(currentState, D.F) && (currentChar == EOF)) return TRUE; else return FALSE; IFT313 © Froduald Kabanza

Exemple de trace Entrée : 9 7 . 5 EOF 1 1 2 2 2 3 3 4 3 current Input [0-9] . REAL NUM 5 “ ” SPACE current Input Position current State 1 1 2 2 2 ‘ ‘ [0-9] ‘.’ 1 5 2 4 3 3 3 4 3 Retourne TRUE (accepte l’entrée) parce qu’il termine dans un état accepteur et toute l’entrée est lue. IFT313 © Froduald Kabanza

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

Reconnaître des tokens Garder une trace de la plus longue sous-chaîne acceptée revient à mémoriser la dernier état accepteur visité par l’AFD. Cela est fait en introduisant les variables suivantes : initialInputPosition : position initiale de la tête de lecture; LastFinal : Plus récent état accepteur visité; inputPositionAtLastFinal : position dans la chaîne d’entrée lorsque l’AFD était dans cet état. text : sous-chaîne entre initialInputPosition (left) et inputPositionAtLastFinal (right). C’est le texte du token. La plus longue sous-chaîne acceptée (longuest match), c-à-d., le token est reconnu, lorsque l’AFD atteint un cul-de-sac (c-à-d., état 0) IFT313 © Froduald Kabanza

Reconnaître des tokens Chaque fois qu’un token est reconnu, l’AFD recommence dans son état initial pour reconnaître le prochain token. En général, lorsqu’un token est reconnu, currentInputPosition peut être au-delà de inputPositionAtLastFinal. Il faut donc réinitialiser currentInputPosition En plus, il faut spécifier une table d’actions à effectuer dans les états accepteurs lorsqu’un token est reconnu. Ces actions sont du code Java. Action[d] donne le code pour l’état d. IFT313 © Froduald Kabanza

Exemple 1 3 4 2 [0-9] . REAL NUM 5 “ ” SPACE a..z 0..9 . “ ” other 1 2 4 5 2 2 3 3 3 4 3 5 5 IFT313 © Froduald Kabanza

Reconnaître des tokens 1 3 4 2 [0-9] . REAL NUM 5 “ ” SPACE - Actions A[1] = {/* ignore */} A[2] = {return new Token(Token.NUM, text, left, right);} A[3] = {return new Token (Token.REAL, text, left, right);} IFT313 © Froduald Kabanza

Reconnaître des tokens Token est une classe Java. Son constructeur accepte comme arguments : type NUM or REAL String text : texte du texte d’entrée correspondant au token. int left : position de début (initialInputPosition) int right : position de fin (inputPositionAtLastFinal) IFT313 © Froduald Kabanza

1 3 4 2 [0-9] . REAL NUM 5 “ ” SPACE Exemple Input : 9 7 . 5 7 EOF inputPosition AtLastFinal State (right) current Input Position lastFinal State Action A[3] current State initialInput Position (left) 1 1 2 2 1 2 2 2 2 3 3 3 3 4 3 3 4 5 3 4 text = substring(0,4) = 97.5 ungetChar() => initialInputPosition = 4 IFT313 © Froduald Kabanza

Exemple (suite) . Input : 9 7 . 5 7 EOF 1 3 4 2 [0-9] . REAL NUM 5 “ ” SPACE Input : 9 7 . 5 7 EOF inputPosition AtLastFinal State (right) current Input Position lastFinal State Action A[5] current State initialInput Position (left) 4 1 4 4 5 5 5 5 4 6 5 5 4 text = substring(start,end) = substring(4,5) = “ ” ungetChar() => InitialInputPosition = 5 IFT313 © Froduald Kabanza

Exemple (suite) . Input : 9 7 . 5 7 EOF [0-9] 5 1 5 5 6 2 2 6 5 6 2 6 3 4 2 [0-9] . REAL NUM 5 “ ” SPACE Input : 9 7 . 5 7 EOF inputPosition AtLastFinal State (right) current Input Position lastFinal State Action A[2] current State initialInput Position (left) 5 1 5 5 6 2 2 6 5 6 2 6 5 text = substring(start,end) = substring(5,6) = 7 IFT313 © Froduald Kabanza

Résumé Un AFD est un outil opérationnel pour reconnaître des tokens. Pour cela, il faut reconnaître la plus longue sous-chaîne de l’entrée, acceptée par l’automate. Une partie du devoir 1 consiste à implémenter l’algorithme de reconnaissance de tokens par un AFD. Mais les AFD peuvent être complexes à spécifier. Les expressions régulières sont plus simples. Il nous faut une méthode pour traduire une expression régulière en un automate fini. La suite du cours explique comment : Convertir une expression en un AFN Convertir un AFN en un AFD. Simuler un AFN pour reconnaître des tokens. IFT313 © Froduald Kabanza