IFT 313 Introduction aux langages formels ric Beaudry
IFT 313 – Introduction aux langages formels Éric Beaudry Département d’informatique Université de Sherbrooke Analyseurs LL(1) non récursifs
Sujets • Table d’analyse LL (1) • Générateurs d’analyseurs LL(1) non récursifs • Transformer les grammaires ambigües • Éliminer la récursivité à gauche (left recursion) • Factorisation à gauche (left factoring) IFT 313 / 2010 E (C) Éric Beaudry & Froduald Kabanza 2
Objectifs • Pouvoir générer une table d’analyse LL(1) pour une grammaire donnée. • Comprendre et pouvoir décrire et simuler l’algorithme d’analyse LL (1) non récursif. • Pouvoir transformer une grammaire non LL(1) en une grammaire LL (1) – Pouvoir transformer une grammaire ambigüe en une grammaire non ambigüe. – Pouvoir éliminer la récursivité à gauche (left recursion). – Pouvoir utiliser la factorisation à gauche (left factoring) IFT 313 / 2010 E (C) Éric Beaudry & Froduald Kabanza 3
Rappel : Algorithme Driver LL variables : stack (pile), x (symbole au sommet de la pile), a (symbole d’entrée courant), in (entrée) initialement la pile contient $S (le symbole départ S) et l’entrée contient w$ (chaîne de tokens w). while (true) { if (x = = $) && (a= = $) return true ; // on accepte la chaîne d’entrée comme étant correcte if (x = = a) && (a != $) // match transition { pop a from the stack; // dépiler le symbole de la pile a = in. read(); // lire le token (symbole) courant et avancer la tête de lecture continue; } if x is a nonterminal // predictive transition { find a production x y 1 … yk; // trouver une production dont la partie gauche est x // les essayer tous jusqu’à en trouver menant à l’acceptation (backtracking) exit with error if no such production exists; pop x from the stack; push yk on the stack; …; push y 1 on the stack; continue; } exit with error; } IFT 313 / 2010 E (C) Éric Beaudry & Froduald Kabanza 4
Rappel : Nullable, First et Follow - Nullable(X) est vrai si et seulement si X peut dériver la chaîne vide en zéro ou plusieurs étapes. - First(a) est l’ensemble de terminaux qui peuvent commencer une chaîne dérivée de a. - Follow(X) est l’ensemble de terminaux qui peuvent suivre X immédiatement, dans une forme propositionnelle. - En plus, si X peut être le dernier symbole dans une forme propositionnelle, on ajoute $ à Follow(X). - Étant donne une chaîne a, nullable(a) si et seulement si chaque symbole de a est annulable. - Étant donne un symbole X et une chaîne g : First(Xg)=First[X] if not nullable[X] First(Xg)=Union(First[X], First(g)) IFT 313 / 2010 E if nullable[X] (C) Éric Beaudry & Froduald Kabanza 5
Définitions formelles - Une définition plus formelle de Nullable, First and Follow est que ce sont les plus petits ensembles pour lesquels les propriétés suivantes sont valides : If S is the start symbol, then Follow[S] contains $; For each terminal symbol a, First(a) = { a }; For each production X Y 1 … Yk If Y 1 … Yk are all nullable or (if k = 0) nullable[X] = true; for each i from 1 to k, for each j from i + 1 to k if Y 1… Yi-1 are all nullable (or if i=1) First[X] = Union(First[X], First[Yi]); if Yi+1… Yk are all nullable (or if i=k) Follow[Yi] = Union(Follow[Yi], Follow[X]); if Yi+1… Yj-1 are all nullable (or if i+1=j) Follow[Yi] = Union(Follow[Yi], First[Yj]); - Pour obtenir les ensembles Nullable, First et Follow, on calcule le point fixe (ou la fermeture) de ces équations. IFT 313 / 2010 E (C) Éric Beaudry & Froduald Kabanza 6
Rappel: calculer Nullable, First et Follow Algorithme nullable. First. Follow initialize all entries of First and Follow to the empty set and those of nullable to false; set Follow[S] = {$}, where S is the start symbol and $ the end marker; for each terminal symbol a, First(a) = {a}; do { for each production X Y 1…Yk { if Y 1…Yk are all nullable or (if k = 0) nullable[X] = true; for (i = 1; i <= k; i++) for (j = i+1; j <= k; j++) { if Y 1…Yi-1 are all nullable (or if i=1) First[X] = Union(First[X], First[Yi]); if Yi+1…Yk are all nullable (or if i=k) Follow[Y 1] = Union(Follow[Yi], Follow[X]); if Yi+1…Yj-1 are all nullable (or if i+1=j) Follow[Y 1] = Union(Follow[Yi], First[Yj]); } } } while First, Follow or nullable is modified in the current iteration IFT 313 / 2010 E (C) Éric Beaudry & Froduald Kabanza 7
Rappel : comment prédire une production ? - Voici les règles pour prédire une production: Ø Si le sommet de la pile est A, et le prochain token est a, alors on prédit la production A a telle que a est dans First(a). v Ainsi le driver LL va appliquer A a , en remplaçant A par a au sommet de la pile Ø Lorsque a peut dériver la chaîne vide, on prédit la règle A a si a est dans Follow(A) ou si le prochain token est $ (EOF) et $ est dans Follow(A). - Avec ces règles, on peut générer une table d’analyse M, telle que M[A, a] contient la règle de production à appliquer lorsque A est au sommet de la pile et a est le prochain token. IFT 313 / 2010 E (C) Éric Beaudry & Froduald Kabanza 8
Génération de la table d’analyse LL (1) Algorithm generate. LL 1 Parsing. Table Entrée : grammaire G(V, T, P, S); Sortie : table d’analyse M[symbole non terminal, symbole terminal]; Pour toutes les règles de production A a dans P { Pour tous les terminaux a dans First(a) // a est élément de T Ajouter A a to M[A, a]; // A est élément de V Si nullable(a) // quand c’est annulable, il faut aller voir ce qui peut suivre Pour tous les terminaux a dans Follow(A) Ajouter A a to M[A, a]; } make each undefined entry of M be error; IFT 313 / 2010 E (C) Éric Beaudry & Froduald Kabanza 9
Exemple 1 - G = (V, A, R, S) : S X Y false true {a, b, c} {c} nullable V = {X, Y, S} First A = {a, b, c} Follow R = { 1. S a {$} {a, b, c} 2. S X Y S 3. X b 4. X Y 5. Y ε 6. Y c} Table d’analyse LL(1) a S X Y IFT 313 / 2010 E b S a S XYS X b X Y Y ε (C) Éric Beaudry & Froduald Kabanza c $ S XYS X Y Y ε Y c 10
Exemple 2 Nullable G = (V, A, R, E) : First V = {E, E’, T, T’, F} E’ T T’ F false true false {(, n} Follow A = {(, ), +, *, n} E {+} {), $} {(, n} {*} {(, n} {), $} {+, ), $}{+, *), $} Table d’analyse R = { E TE’ + TE’ | ε T FT’ T’ *FT’ | ε n E E TE’ E’ * T’ } F ( ) $ E’ ε T’ ε E TE’ E’ +TE’ T T FT’ F ( E ) | n IFT 313 / 2010 E + T FT’ T’ ε T’ *FT’ F n (C) Éric Beaudry & Froduald Kabanza F (E) 11
Algorithme d’analyse LL(1) non récursif - Nous pouvons maintenant mettre à jour l’algorithme LLDriver pour qu’il utilise une table d’analyse LL(1) pour prédire une production. - Si la table d’analyse générée à partir d’une grammaire contient des entrées avec des productions multiples, la grammaire est dite non LL(1). - Pour certaines grammaires qui ne sont pas LL(1), on peut définir des grammaires LL(1) équivalentes par de simples transformations. On en verra certaines plus loin : - Éliminer l’ambiguïté - Éliminer la récursivité à gauche - Factoriser les productions à gauche IFT 313 / 2010 E (C) Éric Beaudry & Froduald Kabanza 12
Algorithme d’analyse LL (1) non récursif Algorithm LL 1 Parser Entrée : - table d’analyse de la grammaire; - chaîne d’entrée terminée par $ (fin de fichier). Sortie : - une dérivation de la chaîne d’entrée si elle syntaxiquement correcte; - sinon erreur. IFT 313 / 2010 E (C) Éric Beaudry & Froduald Kabanza 13
Algorithme d’analyse LL(1) non récursif Algorithm LLDriver variables : stack (pile), x (symbole au sommet de la pile), a (symbole d’entrée courant), in (entrée, suite fini de symboles, lexèmes) initialement la pile contient $S (le symbole départ S) et l’entrée contient w$ (chaîne de tokens w). while (true) { if (x = = $) && (a= = $) return true ; // on accepte la chaîne d’entrée comme étant correcte if (x = = a) && (a != $) // match transition { pop a from the stack; // dépiler le symbole de la pile a = in. read(); // lire le token (symbole) courant et avancer la tête de lecture continue; } if x is a nonterminal // predictive transition { if M[x, a] is error exit with error; let x y 1 … yk the production in M[x, a] pop x from the stack; push yk on the stack; …; push y 1 on the stack; continue; } exit with error; } IFT 313 / 2010 E (C) Éric Beaudry & Froduald Kabanza 14
Exemple Table d’analyse G = (V, A, R, E) : V = {E, E’, T, T’, F} A = {(, ), +, *, n} R = { E TE’ n + * ( ) $ E TE’ E’ +TE’ E’ E’ ε T FT’ T’ T’ ε T’ *FT’ T’ ε F (E) F F n E’ + TE’ | ε T FT’ T’ *FT’ | ε F ( E ) | n } IFT 313 / 2010 E (C) Éric Beaudry & Froduald Kabanza 15
n Entrée : n+n*n + * E TE’ E ( E TE’ E’ +TE’ E’ E’ ε T FT’ T T’ *FT’ F n F Algorithm LLDriver 0. stack = ($S); a = in. read(); x=stack. top(); while (true) { 1. if (x = = $) && (a= = $) return true ; 2. if (x = = a) && (a != $) { pop a from stack; a = in. read(); continue; } 3. if x is a nonterminal { if M[x, a] is error exit with error; let x y 1 … yk in M[x, a] pop x from stack; push y on stack; E’ ε T FT’ T’ ε T’ $ ) T’ ε F (E) Étape Règle 0. 3. E TE’ 3. T FT’ 3. F n 2. 3. T’ ε 3. E’ +TE’ 2. 3. T FT’ 3. F n 2. 3. T’ *FT’ 2. 3. F n 2. 3. T’ ε 3. E’ ε 1. Pile $E $E’T’F $E’T’n $E’T’ $E’ T+ $E’ T $E’T’F $E’T’n $E’T’F* $E’T’F $E’T’n $E’T’ $E’ $ Entrée n+n*n$ +n*n$ n*n$ *n$ n$ n$ $ return true continue; } IFT 313 / 2010 E 4. exit with error; } (C) Éric Beaudry & Froduald Kabanza 16
Quelques considérations pratiques - L’algorithme LL 1 Driver produit une dérivation de l’entrée, plus précisément une séquence de règles de production qui dérivent la chaîne d’entrée. - Cet algorithme est essentiellement un automate à pile LL déterministe qui simule la dérivation la plus à gauche. - Pour obtenir un processeur de langage (interpréteur ou compilateur), on peut associer les règles de production avec des actions qui seront exécutées chaque fois qu’une production est appliquée. Ø Ces actions s’appellent des routines sémantiques ou des actions sémantiques. - Il faut ajouter aussi les gestions des erreurs. IFT 313 / 2010 E (C) Éric Beaudry & Froduald Kabanza 17
Quelques considérations pratiques - Un générateur d’analyseur LL(1) non récursif prend comme entrée une grammaire avec des actions sémantiques et génère un parseur pour cette grammaire. - Un tel générateur fonctionne comme suit. - Il a comme coquille le code du driver LL(1), qui est indépendant de la grammaire. - À partir de la grammaire, il génère une table d’analyse. - Il combine ensuite le code du driver LL(1) avec la table d’analyse pour obtenir le parseur. - Cela vous rappelle-t-il quelque chose ? Ø Les générateurs d’analyseurs lexicaux bien sûr. Un tel générateur emploie une approche similaire: un scanner est obtenu en combinant un DFA driver avec une table de transitions d’un DFA obtenue d’une spécification d’expressions régulières avec des actions associées. IFT 313 / 2010 E (C) Éric Beaudry & Froduald Kabanza 18
Quelques considérations pratiques - Il est possible de généraliser l’analyse LL(1) à l’analyse LL(k), pour un entier k fixé : un analyseur LL(k) prédit une production en se basant sur le symbole au sommet de la pile et les k prochains lexèmes (tokens). - Plus k est grand, plus l’analyseur a une grande puissance d’expressivité, mais aussi plus il est compliqué à coder et souvent il est moins rapide. De plus, la table d’analyse est beaucoup plus volumineuse. - Une grammaire est dite LL(k) si et seulement si le langage généré par la grammaire est analysable par un analyseur LL(k). - Pour beaucoup de langages de programmation, l’analyse LL(1) suffit moyennant quelques extensions, comme l’ajout de règles de priorité. IFT 313 / 2010 E (C) Éric Beaudry & Froduald Kabanza 19
Transformer une grammaire ambigüe - Nous avons vu que la grammaire suivante est ambigüe parce qu’elle produit deux arbres d’analyse différentes pour la même entrée. Donc on pourrait avoir deux dérivations les plus à gauche différentes pour la même entrée. Exp G = (V, A, R, Exp) : Exp V= {Exp} A = {(, ), +, *, num} + Exp num num R = { Exp num Exp ( Exp ) Exp + Exp * Exp } * Exp num + Exp num IFT 313 / 2010 E (C) Éric Beaudry & Froduald Kabanza Exp * Exp num 20
Transformer une grammaire ambigüe - La plupart des générateurs d’analyseurs syntaxiques permettent la spécification de règles de «suppression de l’ambiguïté» qui suppriment les dérivations non désirées afin de s’assurer que la chaîne d’entrée a une seule interprétation possible. - Toutefois, dans d’autres cas, on n’a pas d’autres choix que de réécrire la grammaire en une grammaire équivalente acceptable pour une analyse LL(1) (ou, pour plus tard, LR(1)). - Cependant, il n’existe pas de méthode systématique pour une telle opération de transformation de grammaire ambiguë en une grammaire non ambiguë. Il faut se servir de l’intuition et de l’expérience. IFT 313 / 2010 E (C) Éric Beaudry & Froduald Kabanza 21
Exemple - Pour obtenir une grammaire non ambigüe équivalente à la précédente, intuitivement on aimerait spécifier que l’opérateur de multiplication (*) a une priorité sur celui d’addition (+), de sorte que num + num * num soit interprété comme num + (num * num). - Deuxièmement, on voudrait spécifier que chaque opération est évaluée par l’associativité à gauche, de sorte que la seule interprétation possible pour num - num soit (num – num) – num (plutôt que num – (num – num)). - Nous pouvons faire cela en introduisant de nouveaux symboles non terminaux et de nouvelles productions. Traditionnellement, les facteurs (F) sont les nombres qu’on multiplie et les termes (T) les nombres qu’on additionne; on introduit donc les symboles F et T pour réécrire la grammaire. IFT 313 / 2010 E (C) Éric Beaudry & Froduald Kabanza 22
Exemple (suite) Grammaire ambigüe : G = (V, A, R, E) : V= {E} A = {(, ), +, *, n} R = { E E + E E E * E E ( E ) E n } Grammaire équivalente non ambigüe: G = (V, A, R, E) : V= {E, F, T} A = {(, ), +, *, n} R= { } IFT 313 / 2010 E E E T T F F E+T T T*F F ( E) n (C) Éric Beaudry & Froduald Kabanza 23
Récursivité à gauche (left recursion) - La nouvelle grammaire n’est pas ambigüe. Elle génère une seule dérivation la plus à gauche (ou une seule dérivation la plus à droite) pour une chaîne de lexèmes (tokens). - Toutefois, la nouvelle grammaire n’est pas pratique pour l’analyse LL(1). Les productions E E + T | T vont causer des entrées multiples dans la table d’analyse LL(1), vu que tout token dans First(E + T) sera aussi dans First(T). - Le problème est que E apparaît comme premier symbole de la partie droite d’une production commençant par E. Ça s’appelle la récursivité à gauche (left-recursion). - Plus précisément, une grammaire est dite récursive à gauche (leftrecursive) si elle a un non terminal A tel qu’il est possible d’avoir une dérivation A => Aa. - L’analyse descendante ne peut pas gérer la récursivité à gauche. Par conséquent, il nous faut une transformation permettant de passer d’une grammaire récursive à gauche à une grammaire non récursive à gauche. IFT 313 / 2010 E (C) Éric Beaudry & Froduald Kabanza 24
Éliminer la récursivité à gauche - Pour éliminer la récursivité à gauche pour les productions E E + T | T , on les réécrit avec une récursivité à droite. Plus précisément, on introduit un nouveau nonterminal E’ et on écrit : E TE’ E’ +TE’ E’ ε - De manière plus systématique, chaque fois qu’on a deux productions X Xg et X a, cela veut dire qu’elle génèrent le langage décrit par l’expression régulière ag*, c’est à dire, un a suivi par zéro ou plusieurs g. On peut réécrire cette expression régulière par des productions récursives à droite comme suit : X X g 1 X a 1 X X g 2 X a 2 IFT 313 / 2010 E devient X a 1 X a 2 X’ g 1 X’ g 2 X’ ε X’ X’ (C) Éric Beaudry & Froduald Kabanza 25
Exemple - Grammaire récursive à gauche : G = (V, A, R, E) : V= {E, F, T} A = {(, ), +, *, n} R = { E E + T E T T T * F T F F ( E) F n } IFT 313 / 2010 E Grammaire équivalente non récursive à gauche: G = (V, A, R, E) : V = {E, E’, T, T’, F} A = {(, ), +, *, n} R={ E TE’ E’ + TE’ | ε T FT’ T’ *FT’ | ε F ( E ) | n} (C) Éric Beaudry & Froduald Kabanza 26
Factorisation à gauche - Une situation un peu similaire à la récursivité à gauche est lorsque deux productions ayant la même partie gauche ont des parties droites ayant un préfixe commun. Cela conduit à des entrées multiples dans la table d’analyse LL(1). - Par exemple S if E then S else S | if E then S - Dans ce cas, on factorise la grammaire à gauche, c’est-à-dire, on introduit un nouveau non terminal pour représenter le suffixe sur lequel les deux productions diffèrent, comme suit : S if E then S X X else S | ε IFT 313 / 2010 E (C) Éric Beaudry & Froduald Kabanza 27
Stratégies de recouvrement d’erreurs - Une erreur apparaît lorsque la chaîne d’entrée n’est pas syntaxiquement correcte : - Soit on a un token au sommet de la pile, mais il diffère de celui à l’entrée - Soit on a un non terminal x au sommet de la pile et M[x, a] est vide. - En pratique, on ne veut pas arrêter l’analyse à la toute première erreur. Ø Aimeriez-vous un compilateur qui vous donne uniquement une seule erreur à la fois ? Ø On veut continuer l’analyse syntaxique jusqu’à un certain nombre d’erreurs ou jusqu’à un certain niveau de sévérité d’erreur. - Les stratégies de recouvrement typiques consistent à réparer la chaîne d’entrée pour que l’analyse continue. En particulier : - On peut insérer des tokens. - Supprimer des tokens. - Remplacer des tokens. IFT 313 / 2010 E (C) Éric Beaudry & Froduald Kabanza 28
Stratégies de recouvrement Algorithm LLDriver variables : stack (pile), x (symbole au sommet de la pile), a (symbole d’entrée courant), in (entrée) initialement la pile contient $S (le symbole départ S) et l’entrée contient w$ (chaîne de tokens w). while (true) { if (x = = $) && (a= = $) return true ; // on accepte la chaîne d’entrée comme étant correcte if (x = = a) && (a != $) // match transition { pop a from the stack; // dépiler le symbole de la pile a = in. read(); // lire le token (symbole) courant et avancer la tête de lecture continue; } if x is a nonterminal // predictive transition { if M[x, a] is empty error(x, a); // recouvrement d’erreur let x y 1 … yk the production in M[x, a] pop x from the stack; push yk on the stack; …; push y 1 on the stack; continue; } error(x, a); } // recouvrement d’erreur IFT 313 / 2010 E (C) Éric Beaudry & Froduald Kabanza 29
Recouvrement d’erreurs par insertion de tokens - Pour insérer un token manquant de l’input, on n’a pas besoin de l’ajouter explicitement à la chaîne d’entrée. - Il suffit de prétendre que le token est présent, imprimer un message approprié et continuer normalement. - Pour ce cas, la fonction error(x, a) va procéder comme suit : - Si x, le symbole au sommet de la pile, est un token, afficher le message “Expected ‘x’ on the input”. - Si x est un non terminal, afficher le message “Expected, ‘a 1’, …, ‘an’ on the input”, tel que ‘ai’ sont les tokens pour lesquels l’entrée M[x, ai] est définie (non vide). - Dépiler et lire le prochain token : - pop x from the stack; - a = in. read(); IFT 313 / 2010 E (C) Éric Beaudry & Froduald Kabanza 30
Recouvrement d’erreurs par insertion de tokens - Le recouvrement d’erreur par insertion de tokens est à utiliser avec précaution parce que une cascade d’erreurs risque de mener à une situation où les tokens sont insérés (plus exactement, sont supposés présents) indéfiniment, de sorte que la chaine d’entrée n’est jamais vidée, cà-d. , menant à une boucle sans fin. IFT 313 / 2010 E (C) Éric Beaudry & Froduald Kabanza 31
Recouvrement d’erreurs par suppression de tokens - Le recouvrement d’erreur par suppression de tokens est plus sécuritaire parce qu’il garantie toujours que la chaîne d’entrée va être vidée. - Étant donné x, le symbole au sommet de la pile, la stratégie est, en cas d’erreur, de sauter (supprimer) les prochains tokens jusqu’au premier token x, si x est un token, ou jusqu’au premier token dans Follow(x) si x est un non terminal. - Pour ce cas, la fonction error(x, a) va procéder comme suit : - Si x, le symbole au sommet de la pile, est un token, afficher le message “Expected ‘x’ on the input”. - Si x est un non terminal, afficher le message “Expected, ‘a 1’, …, ‘an’ on the input”, tel que ‘ai’ sont les tokens pour lesquels l’entrée M[x, ai] est définie (non vide). - Dépiler x; - Si x est un token, avancer la tête de lecture juste après le prochain token x (c-àd. , a devient ce token). - Si x est un non terminal, avancer la tête de lecture jusqu’au prochain token dans Follow(x) (c-à-d. , a devient ce token). IFT 313 / 2010 E (C) Éric Beaudry & Froduald Kabanza 32
Résumé - Nous avons vu un nouvel algorithme pour l’analyse syntaxique non récursive, LL 1 Driver. - Il utilise une table d’analyse, générée à partir de la grammaire. - Des transformations peuvent être nécessaires pour avoir grammaire est LL 1. - Au lieu du driver LL 1 et de la pile, on peut écrire un analyseur syntaxique en considérant chaque règle de production comme un appel de fonction qui implémente une étape de dérivation et en « matchant » les tokens chaque fois qu’ils apparaissent dans une dérivation. - Ceci donne lieu à un analyseur descendant récursif. - La table d’analyse LL 1 demeure nécessaire dans ce cas. - C’est l’approche utilisée par Java. CC. Nous la verrons à la leçon suivante. IFT 313 / 2010 E (C) Éric Beaudry & Froduald Kabanza 33
- Slides: 33