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

IFT313© Froduald Kabanza2 Sujets Algorithme générique pour lanalyse LR (Driver LR) Table danalyse SLR(1).

IFT313© Froduald Kabanza3 Objectifs Pouvoir définir et simuler lalgorithme danalyse LR (Driver LR) Pouvoir générer une table danalyse SLR(1) pour une grammaire donnée. Pouvoir reconnaître les grammaires SLR(1).

IFT313© Froduald Kabanza4 Références [1] Sudkamp, T. A.. Languages and Machines. Third Edition Edition. Addison-Wesley, – Sections 20.1 à 20.4 [2] Appel, A. and Palsberg. J. Modern Compiler Implementation in Java. Second Edition. Cambridge, – Section 3.3 [4] Aho, A., Lam, M., Sethi R., Ullman J. Compilers: Principles, Techniques, and Tools, 2 nd Edition. Addison Wesley, – Section 4.6

IFT313 / 2009E(C) Froduald Kabanza & Éric Bea udry 5 Rappel : AFD LR(0) I0I1I6I9 I2I7I10 I8I11 I5 ET+ F ( T num ( F* E) +T F ( * to I7 to I2 to I6 to I3 to I4 to I5 to I4 to I5 to I3 num I4 ( I3 F I0 E. E. E+T E. T. T*F T. F F. (E) F. num I1 E. E E. +T I2 E. T T. *F I3 T F. I4 F (. E) E. E+T E. T. T*F T. F F. (E) F. num I5 F num. I6 E E+. T T. T*F T. F F. (E) F. num I7 T T*. F F. (E) F. num I8 F (E. ) E E. +T I9 E E+T. T T. *F I0 T T*F. I11 F (E).

IFT313© Froduald Kabanza6 Rappel : Analyseur LR(0) Un analyseur (syntaxique) LR(0) na pas besoin danticiper le prochain token (lookahead) pour prendre une décision shift ou reduce. Il décide de laction appropriée (shift ou reduce) seulement en fonction de létat courant de lAFD pour les préfixes viables. Ce comportement est reflété par la version suivante de lanalyseur LR(0). Algorithm LR0Parser. Entrée : flux de tokens Sortie : dérivation de lentrée ou erreur. Variables: stack (pile), a (prochain token), in (entrée : flux de tokens) AFD pour préfixes viables, avec état initial I0 et fonction de transition goto Initialement la pile contient I0

IFT313© Froduald Kabanza7 Rappel : Analyseur LR(0) while (true) { if (la pile contient I0S et lentrée est $ (vide)) return true; if (létat au sommet de la pile contient un élément A. reduce with the production A est une poignée et A la production correspondante c.-à-d. : Supprimer 2 | | symboles de la pile (| | états et | | symboles de grammaires). Soit I le nouvel état au sommet de la pile. Ajouter A au sommet de la pile. Ajouter létat retourné par goto(I,A) au sommet de la pile. print out the production A continue; if (létat au sommet de la pile contient un élément A. a tel que a est un token shift c.-à-d. : Soit I létat au sommet de la pile. Lire le prochain token a Ajouter a au sommet de la pile. Ajouter létat retourné par goto(I,a) au sommet de la pile. continue; error(); }

IFT313© Froduald Kabanza8 Rappel : Grammaires LR(0) Un élément shift (shift item) est un élément de la forme « A. a » tel que a est un terminal. Un élément reduce (reduce item) est un élément de la forme « A. » Si lAFD LR(0) a un état contenant à la fois un élément shift et un élément reduce, ou plus dun élément reduce, alors la grammaire correspondante nest pas LR(0). Par exemple, la grammaire précédente nest pas LR(0) parce que les états I1, I2 et I9 contiennent des conflits Shift/Reduce. Un analyseur LR(0) fonctionne correctement uniquement pour des grammaires LR(0).

IFT313© Froduald Kabanza9 Exemple de grammaire LR(0) S S (habituellement non numérotée; production interne) 1. S E; 2. E E + T 3. E T 4. T (E) 5. T num Terminaux : num, + et; La terminaison de lentrée ; fait partie des terminaux. Sans elle, la grammaire nest plus LR(0). Pour montrer que la grammaire est LR(0), on construit lAFD pour les préfixes viables et on vérifie quaucun état ne contient à la fois déléments shift et délément reduce, ou plus dun élément reduce. Ci-après on donne aussi une simulation de lanalyseur LR(0) pour lentrée 3 + 6;, ce qui correspond au flot de tokens num + num;

IFT313© Froduald Kabanza10 I0 I1 I6 I9 I2 I7 I8 I5 E T + T num ( E ) T ( I4 ( I3 + ; I10 S I0 S. S S. E. E+T E. T. (E) T. num I1 S. E E. +T I2 S E;. I6 T (. E) E. E+T E. T. (E) T. num I5 T num. I3 E E+. T T. (E) T. num I7 T (E. ) E E. +T I4 E E+T. I9 E T. I8 F (E). I10 S S. AFD LR(0)

IFT313© Froduald Kabanza11 AFD + simulation de lanalyseur LR(0) avec une entrée correcte 1. (I0, num+num;$) Shift 2. (I0numI5, +num;$) Reduce 3. (I0TI9, +num;$) Reduce 4. (I0EI1, +num;$) Shift 5. (I0EI1+I3, num;$) Shift 6. (I0EI1+I3numI5, ;$) Reduce 7. (I0EI1+I3TI4, ;$) Reduce 8. (I0EI1, ;$) Shift 9. (I0EI1;I2, $) Reduce 10. (I0SI10, $) Accept. Dérivation correspondante : num + num; <= num+ num; <= T + num; <= E + num <= E + num; <= E + num; <= E + T; <= E; <= E; <= E I5 T num. I0 S. S S. E. E+T E. T. (E) T. num I1 S. E E. +T I2 S E;. I6 T (. E) E. E+T E. T. (E) T. num I3 E E+. T T. (E) T. num I7 T (E. ) E E. +T I4 E E+T. I9 E T. I8 F (E). I10 S S. I0 I1 I6 I9 I2 I7 I8 I5 E T + T num ( E ) T ( I4 ( I3 + ; I10 S

IFT313© Froduald Kabanza12 AFD + simulation de lanalyseur LR(0) avec une entrée erronée 1. (I0, num++num;$) Shift 2. (I0numI5, ++num;$) Reduce 3. (I0TI9, ++num;$) Reduce 4. (I0EI1, ++num;$) Shift 5. (I0EI1+I3, +num;$) Shift 6. (I0EI1+I3+, ;$) Error during reduction : goto(I3,+) is not defined. I0 I1 I6 I9 I2 I7 I8 I5 E T + T num ( E ) T ( I4 ( I3 + ; I10 S I5 T num. I0 S. S S. E. E+T E. T. (E) T. num I1 S. E E. +T I2 S E;. I6 T (. E) E. E+T E. T. (E) T. num I3 E E+. T T. (E) T. num I7 T (E. ) E E. +T I4 E E+T. I9 E T. I8 F (E). I10 S S.

IFT313© Froduald Kabanza13 Vers un pilote pour Analyseur LR (1) Lexemple précédent montre que lorsquon a une entrée erronée : Lanalyseur LR(0) peut empiler (shift) le prochain token même sil est erroné. Mais il va se rendre compte que le token est erroné plus tard, durant la réduction. En fait, en général, lerreur peut être détectée après avoir empilé quelques tokens de plus au-delà du token fautif. Nous allons voir une variante de lanalyseur LR(0) qui fait shift uniquement si le prochain token a un élément shift correspondant dans létat courant de lAFD. Techniquement parlant, ceci nest pas un analyseur LR(0), puisquil consulte le prochain token avant de décider de faire shift. Cest un anaylseur LR(1). Néanmoins, cette version est équivalente à lanalyseur LR(0), mis à part le fait quelle permet de détecter des erreurs plus tôt. Avec lexemple précédent, lerreur serait détectée à létape 5 lorsquon essaie dempiler (shift) le +. Nous décrivons cette variante parce quelle permet une bonne transition vers lanalyseur LR(1) général qui nous intéresse le plus.

IFT313© Froduald Kabanza14 Analyseur LR(1) équivalent à lanalyseur LR(0) while (true) { // Version 2 if (la pile contient I0S et lentrée est $ (vide)) return true; if (létat au sommet de la pile contient un élément A. reduce with the production A est une poignée et A la production correspondante c.-à-d. : Supprimer 2 | | symboles de la pile (| | états et | | symboles de grammaires). Soit I le nouvel état au sommet de la pile. Ajouter A au sommet de la pile. Ajouter létat retourné par goto(I,A) au sommet de la pile. print out the production A continue; if (létat au sommet de la pile contient un élément A. a tel que a est le prochain token shift c.-à-d. : Soit I létat au sommet de la pile. Lire le prochain token a Ajouter a au sommet de la pile. Ajouter létat retourné par goto(I,a) au sommet de la pile. continue; error(); }

IFT313© Froduald Kabanza15 Exemple revisité avec le nouvel algorithme 1. (I0, num++num;$) Shift 2. (I0numI5, ++num;$) Reduce 3. (I0TI9, ++num;$) Reduce 4. (I0EI1, ++num;$) Shift 5. (I0EI1+I3, +num;$) Error during reduction : cannot shift + in state I3. I0 I1 I6 I9 I2 I7 I8 I5 E T + T num ( E ) T ( I4 ( I3 + ; I10 S I5 T num. I0 S. S S. E. E+T E. T. (E) T. num I1 S. E E. +T I2 S E;. I6 T (. E) E. E+T E. T. (E) T. num I3 E E+. T T. (E) T. num I7 T (E. ) E E. +T I4 E E+T. I9 E T. I8 F (E). I10 S S.

IFT313© Froduald Kabanza16 Tables danalyse LR(0) 1/2 –On peut améliorer les deux ébauches danalyseurs LR(0) précédents, en utilisant une table pour implémenter lAFD pour les préfixes viables. –Lidée est que laction shift aussi bien que laction reduce dépend seulement de létat de lAFD au sommet de la pile. Tout ce dont on a besoin de savoir pour cet état cest sil contient : (a) un élément de la forme A. et dans ce cas on fait reduce; (b) ou un élément de la forme A. a et dans ce cas on fait shift; –On peut mettre ces information dans une table annexée avec la fonction de transition de lAFD, goto. –De cette façon, on peut utiliser un algorithme danalyse LR universel, piloté par la table danalyse.

IFT313© Froduald Kabanza17 Tables danalyse LR(0) 2/2 –Nous considérer deux types de tables danalyse LR(0), chacune correspondant à lune des deux versions danalyseurs : avec lookahead ou sans lookahead. –Avec lookhead, la table va être indexée par létat de lAFD et le prochain token. –Sans lookahead, elle sera indexée seulement par létat de lAFD. –Dans les deux cas, lentrée est un symbole désignant laction shift ou reduce, et/ou létat successeur pour la fonction goto. –Nous utilisons les conventions suivantes pour la spécification des tables : s signifie Fait shift (utilisé seulement dans les tables sans lookahead); si signifie Fait shift ensuite empile létat i (c.-à-d., action shif et goto état i); ri signifie Fait reduce avec la production numéro i; acc signifie accepte lentrée; une entrée vide signifie que lanalyseur doit signaler une erreur.

IFT313© Froduald Kabanza18 Construire la table danalyse LR(0) sans lookahead 1/2 Algorithm construire la table danalyse LR(0) sans lookahead Entrée : Une grammaire augmentée G, avec le symbole de départ S; Sortie : Table danalyse LR(0) sans lookahead; Méthode : 1. Construire lAFD pour les préfixes viables de G; 2. Nous notons i, létat I i. Les actions danalyse pour létat i sont déterminées comme suit : a. Si un élément A a tel que a est un terminal, est dans I i et goto(I i, a) est défini, ajoute shift dans action[i]; b. Si un élément A est dans I i, avec A différent de S, ajoute reduce A dans action[i]; c. Si lélément S S. est dans I i, ajoute accept dans action[i].

IFT313© Froduald Kabanza19 Construire la table danalyse LR(0) sans lookahead) 2/2 3. Si goto(I i, A) = I j pour un non terminal A goto[i, A] devient j ; 4. Toutes les entrées vides sont considérées comme ayant la valeur erreur. 5. Létat initial, 0, est celui construit à partir de létat de lAFD contenant lélément S. S Si la table générée par cette algorithme contient des conflits, c.-à-d., des entrées avec des actions multiples, la grammaire correspondante nest pas LR(0). Sinon, elle est LR(0).

IFT313© Froduald Kabanza20 Exemple 1/2 I0 I1 I6 I9 I2 I7 I8 I5 E T + T num ( E ) T ( I4 ( I3 + ; I10 S I5 T num. I0 S. S S. E. E+T E. T. (E) T. num I1 S. E E. +T I2 S E;. I6 T (. E) E. E+T E. T. (E) T. num I3 E E+. T T. (E) T. num I7 T (E. ) E E. +T I4 E E+T. I9 E T. I8 T (E). I10 S S.

IFT313© Froduald Kabanza21 Exemple 2/2 goto State +)(ET s num action r2r2 s s s r1r1 6 r5r5 r4r4 r3r3 s 5 ; S 10 acc I0 I1 I6 I9 I2 I7 I8 I5 E T + T num ( E ) T ( I4 ( I3 + ; I10 S

IFT313© Froduald Kabanza22 Algorithme danalyse LR(0) avec table danalyse sans lookahead (1/2) Algorithm LR0ParserWithTable Entrée : flux de tokens Sortie : dérivation de lentrée si elle est dans L(G), sinon erreur. Variables : stack (pile), a (prochain token), in (entrée : flux de tokens) i (sommet de la pile) Table danalyse LR(0) sans lookahead. Méthode : Initialement la pile contient 0 (c-.à-d., état 0). Ensuite il exécute le code suivant.

IFT313© Froduald Kabanza23 Algorithme danalyse LR(0) avec table danalyse sans lookahead (2/2) while (true) { i = state on top of stack; if action[i] = shift { a = in.getNextToken(); // Ceci avance la tête de lecture. push a on top of the stack; push goto[i,a] on top of the stack; continue; } if action[I] = reduce A pop 2x| | symbols off the stack; i = the state now on top of the stack; push A on top of stack; push goto[i,A] on top of the stack; printout the production A continue; } if action[i] = accept and the input is empty return true; error(); }

IFT313© Froduald Kabanza24 Exemple (simulation de lanalyseur LR(0)) 1. (0, num+num;$) Shift 2. (0 num 5, +num;$) Reduce 5 3. (0 T 9, +num;$) Reduce 3 4. (0 E 1, +num;$) Shift 5. (0 E 1 + 3, num;$) Shift 6. (0 E num 5, ;$) Reduce 5 7. (0 E T 4, ;$) Reduce 2 8. (0 E 1, ;$) Shift 9. (0 E 1 ; 2, $) Reduce (0 S 10, $) Accept. Dérivation correspondante : num + num; <= num+ num; <= T + num; <= E + num <= E + num; <= E + num; <= E + T; <= E; <= E; <= S Grammar S S 1. S 2. E E+T 3. E 4. T (E) 5. T num State +)(ET s num action r2r2 s s s r1r1 6 r5r5 r4r4 r3r3 s 5 ; S 10 acc

IFT313© Froduald Kabanza25 Construire la table danalyse LR(0) avec lookahead 1/2 Algorithm construire la table danalyse LR(0) avec lookahead Entrée : Une grammaire augmentée G, avec le symbole de départ S; Sortie : Table danalyse LR(0) avec lookahead; Méthode : 1. Construire lAFD pour les préfixes viables de G; 2. Nous notons i, létat I i. Les actions danalyse pour létat i sont déterminées comme suit : a. Si un élément A a tel que a est un terminal, est dans I i, avec goto(I i, a) = j, ajoute shift j dans action[i, a]; b. Si un élément A est dans I i, avec A différent de S, ajoute reduce A dans action[i, a], pour chaque terminal a; c. Si lélément S S. est dans I i, ajoute accept dans action[i, $].

IFT313© Froduald Kabanza26 Construire la table danalyse LR(0) avec lookahead 2/2 3. Si goto(I i, A) = I j pour un non terminal A goto[i, A] devient j ; 4. Toutes les entrées vides sont considérées comme ayant la valeur erreur. 5. Létat initial, 0, est celui construit à partir de létat de lAFD contenant lélément S. S Si la table générée par cette algorithme contient des conflits, c.-à-d., des entrées avec actions multiples, la grammaire correspondante nest pas LR(0). Sinon, elle est LR(0).

IFT313© Froduald Kabanza27 Exemple 1/2 I0 I1 I6 I9 I2 I7 I8 I5 E T + T num ( E ) T ( I4 ( I3 + ; I10 S I5 T num. I0 S. S S. E. E+T E. T. (E) T. num I1 S. E E. +T I2 S E;. I6 T (. E) E. E+T E. T. (E) T. num I3 E E+. T T. (E) T. num I7 T (E. ) E E. +T I4 E E+T. I9 E T. I8 T (E). I10 S S.

IFT313© Froduald Kabanza28 Exemple 2/2 State action/goto +)(ETnum r2r2 s6s6 9 s3s3 s5s5 4 acc s6s6 r5r5 r4r4 r3r3 s5s5 ; s3s3 s2s2 7 s8s8 s6s6 s5s5 r2r2 r2r2 r2r2 r2r2 r2r2 r5r5 r5r5 r5r5 r5r5 r5r5 r4r4 r4r4r4 r4r4 r4r4 r3r3 r3r3 r3r3 r3r3 r3r3 $ goto 10 S r1r1 r1r1 r1r1 r1r1 r1r1 r1r1 I0 I1 I6 I9 I2 I7 I8 I5 E T + T num ( E ) T ( I4 ( I3 + ; I10 S

IFT313© Froduald Kabanza29 Algorithme danalyse LR (1) 1/2 Algorithm LR1Parser Entrée : flux de tokens Sortie : dérivation de lentrée si elle est dans L(G), sinon erreur. Variables : stack (pile), a (prochain token), in (entrée : flux de tokens) i (sommet de la pile) Table danalyse LR(0) avec lookahead, ou SLR(1), ou LALR(1). Méthode : Initialement la pile contient létat 0. Ensuite il exécute le code suivant.

IFT313© Froduald Kabanza30 Algorithme danalyse LR (1) 2/ 2 a = in.getNextToken(); while (true) { i = state on top of stack; if action[i,a] = shift j { push a on top of the stack; push j on top of the stack; a = get.NextToken(); continue; } if action[i,a] = reduce A pop 2 x | | symbols off the stack; i = the state now on top of the stack; push A on top of stack; push goto[i,A] on top of the stack; printout the production A continue; } if action[i,a] = accept return true; error(); }

IFT313© Froduald Kabanza31 Exemple (Simulation de lanalyseur LR(1)) 1. (0, num+num;$) Shift 2. (0 num 5, +num;$) Reduce 5 3. (0 T 9, +num;$) Reduce 3 4. (0 E 1, +num;$) Shift 5. (0 E 1 + 3, num;$) Shift 6. (0 E num 5, ;$) Reduce 5 7. (0 E T 4, ;$) Reduce 2 8. (0 E 1, ;$) Shift 9. (0 E 1 ; 2, $) Reduce (0 S 10, $) Accept. Corresponding derivation sequence: num + num; <= num+ num; <= T + num; <= E + num <= E + num; <= E + num; <= E + T; <= E; <= E; <= S State action/goto +)(ETnum r2r2 s6s6 9 s3s3 s5s5 4 acc s6s6 r5r5 r4r4 r3r3 s5s5 ; s3s3 s2s2 7 s8s8 s6s6 s5s5 r2r2 r2r2 r2r2 r2r2 r2r2 r5r5 r5r5 r5r5 r5r5 r5r5 r4r4 r4r4r4 r4r4 r4r4 r3r3 r3r3 r3r3 r3r3 r3r3 $ goto 10 S r1r1 r1r1 r1r1 r1r1 r1r1 r1r1 Grammar S S 1. S 2. E E+T 3. E 4. T (E) 5. T num

IFT313© Froduald Kabanza32 Forces et limites de lanalyse LR(0) –On peut montrer que si un langage hors-contexte a un symbole spécifique qui termine tous les mots du langage (comme le point virgule dans lexemple précédent), alors il existe une grammaire LR(0) équivalente. –Remarquez que les langages de programmation sont en pratique des langages hors-contexte et terminent par une fin de fichier. Donc, théoriquement, on pourrait les analyser par un analyseur LR(0). –Cependant, la grammaire LR(0) en question pourrait être très large, difficile à lire et peu efficace. Mais il en existe une. –En pratique on préfère des parsers LR qui utilise un lookahead, parce quils exigent des grammaires plus simples.

IFT313© Froduald Kabanza33 Comment ça se fait que lanalyseur LR(0) marche ? –Pour se convaincre que lanalyseur LR(0) fonctionne correctement, il faudrait prouver un théorème que si un langage est LR(0) alors il est analysé correctement : une entrée valide sera reconnue et une entrée invalide sera rejetée. –Une telle preuve existe (voir le manuel de référence de Sufkamp [1]); Elle elle est basée sur les observations suivantes. –Premièrement, lAFD pour les préfixes viables peut seulement lire des mots qui sont des préfixes viables de la grammaire quon veut analyser. Par conséquent, si un symbole erroné est rencontré durant lanalyse, il sera rejeté par le parser puisque ce symbole ne peut pas faire parti dun préfixe viable. LAFD a besoin de considérer seulement les préfixes viables pour sassurer que toute réduction légale sera considérée. Les préfixes non viables nont pas besoin dêtre reconnus par lAFD parce que si une chaîne de symbole nest pas un préfixe dune forme sententielle droite (c.à-d., un préfixe viable), alors elle ne peut pas non plus faire partie dune dérivation et donc na pas à être considérée par lAFD. –Deuxièmement, la partie action de la table danalyse indique laction appropriée à chaque étape : elle indique dempiler les token (shift) jusquà ce quune partie droite dune production est sur la pile et signale une réduction. Ceci découle de la façon dont la table est construite à partir de lAFD.

IFT313© Froduald Kabanza34 Exemple de grammaire non LR(0) Un grand nombre de grammaires intéressantes ne sont pas LR(0) même si elles ne sont pas ambiguës. Par exemple, la grammaire suivante pour les expressions arithmétiques nest pas LR(0): E E (non numéroté parce que cest une production interne) 1. E E+T 2. E T 3. T T*F 4. T F 5. F (E) 6. F num Pour montrer que la grammaire nest pas LR(0), on montre que lAFD correspondant pour les préfixes viables a au moins un état contenant à la fois un élément shift et un élément reduce ou plus dun élément reduce. Conséquemment la table danalyse correspondante aurait des entrées multiples.

IFT313© Froduald Kabanza35 AFD pour préfixes viables I0I1I6I9 I2I7I10 I8I11 I5 ET+ F ( T num ( F* E) +T F ( * to I7 to I2 to I6 to I3 to I4 to I5 to I4 to I5 to I3 num I4 ( I3 F I0 E. E. E+T E. T. T*F T. F F. (E) F. num I1 E. E E. +T I2 E. T T. *F I3 T F. I4 F (. E) E. E+T E. T. T*F T. F F. (E) F. num I5 F num. I6 E E+. T T. T*F T. F F. (E) F. num I7 T T*. F F. (E) F. num I8 F (E. ) E E. +T I9 E E+T. T T. *F I0 T T*F. I11 F (E).

IFT313© Froduald Kabanza36 Table danalyse LR(0) I0I1I6I9 I2I7I10 I8I11 I5 ET+ F ( T num ( F* E) +T F ( * to I7 to I2 to I6 to I3 to I4 to I5 to I4 to I5 to I3 num I4 ( I3 F

IFT313© Froduald Kabanza37 Analyse LR(1) –Puisque les analyseurs LR(0) nutilisent pas de lookahead, ils ne peuvent pas analyser efficacement les langages pratiques en programmation. –Les analyseurs LR(1) généralisent les analyseurs LR(0) en introduisant un lookahead dans les tables danalyse, un peu comme dans la version de lanalyseur LR(0) avec lookahead. –La différence est que dans le cas dun analyseur LR(1), le lookahead est non seulement impliqué dans la décision de faire laction shift, mais aussi dans la décision de faire laction reduce.

IFT313© Froduald Kabanza38 Analyse LR(1) –Les analyseurs LR(1) les plus populaires sont SLR(1) et LALR(1). –SLR(1) signifie simple LR(1). Techniquement, cest une simple modification de lanalyseur LR(0) avec lookahead. La modification est très simple mais significative : on obtient un analyseur presque aussi puissant quun analyseur LR(1) complet. –LALR(1) signifie Look Ahead LR(1). –Il est légèrement plus puissant que SLR(1). –Lappellation LALR peut paraître inappropriée vu que SLR(1), aussi bien que tout autre analyseur LR(1), utilise aussi un lookahead. –En fait, en disant Look Ahead LR(1), le Look Ahead réfère à lAFD pour les préfixes viables : dans un analyseur LALR(1), lAFD est composé des éléments qui sont associés avec un lookahead, alors que ce nest pas le cas ni dans lanalyse SLR(1) ni dans lanalyse LR(0) avec lookahead.

IFT313© Froduald Kabanza39 Construire la table danalyse SLR(1) 1/2 Algorithm construire la table danalyse SLR(1) Entrée : Une grammaire augmentée G, avec le symbole de départ S; Sortie : Table danalyse SLR(1); Méthode : 1. Construire lAFD pour les préfixes viables de G; 2. Nous notons i, létat I i. Les actions danalyse pour létat i sont déterminées comme suit : a. Si un élément A a tel que a est un terminal, est dans I i et goto(I i, a) est défini, ajoute shift dans action[i, a]; b. Si un élément A est dans I i, avec A différent de S, ajoute reduce A dans action[i, a], pour chaque terminal a dans Follow(A); c. Si lélément S S. est dans I i, ajoute accept dans action[i, $].

IFT313© Froduald Kabanza40 Construire la table danalyse SLR(1) 2/2 3. Si goto(I i, A) = I j pour un non terminal A goto[i, A] devient j ; 4. Toutes les entrées vides sont considérées comme ayant la valeur erreur. 5. Létat initial, 0, est celui construit à partir de létat de lAFD contenant lélément S. S Si la table générée par cette algorithme contient des conflits, c.-à-d., des entrées avec des actions multiples, la grammaire correspondante nest pas SLR(1). Lalgorithme danalyse demeure le même que le précédent (seule la table change). Un analyseur SLR(1) est un analyseur qui utilise une table SLR(1). Dans ce cas on omet en général le suffixe (1) puisquon ne sintéresse pratiquement pas à des analyseurs SLR(k) avec k>1.

IFT313© Froduald Kabanza41 Exemple I0I1I6I9 I2I7I10 I8I11 I5 ET+ F ( T num ( F* E) +T F ( * to I7 to I2 to I6 to I3 to I4 to I5 to I4 to I5 to I3 num I4 ( I3 F I0 E. E. E+T E. T. T*F T. F F. (E) F. num I1 E. E E. +T I2 E. T T. *F I3 T F. I4 F (. E) E. E+T E. T. T*F T. F F. (E) F. num I5 F num. I6 E E+. T T. T*F T. F F. (E) F. num I7 T T*. F F. (E) F. num I8 F (E. ) E E. +T I9 E E+T. T T. *F I0 T T*F. I11 F (E).

IFT313© Froduald Kabanza42 Table danalyse SLR(1) +*)($ETF s5s5 num s4s4 312 State actions / gotogoto s5s5 r6r6 r6r6 r6r6 r6r6 s5s5 s5s5 r1r1 r3r3 s 11 r1r1 r3r3 s7s7 r3r3 s6s6 r1r1 r3r3 r5r5 r5r5 r5r5 r5r5 s4s s4s4 r4r4 r4r4 r2r2 r2r2 r4r4 r4r4 s7s7 r2r2 s6s6 s4s4 acc I0I1I6I9 I2I7I10 I8I11 I5 ET+ F ( T num ( F* E) +T F ( * to I7 to I2 to I6 to I3 to I4 to I5 to I4 to I5 to I3 num I4 ( I3 F

IFT313© Froduald Kabanza43 Simulation Exemple dexécution : 1. ( 0, (num)$) s 4 2. ( 0 ( 4, num)$) s 5 3. ( 0 ( 4 num 5, )$) r 6: F num. 4. ( 0 ( 4 F 3, )$) r 4: T F. 5. ( 0 ( 4 T 2, )$) r 2: E T. 6. ( 0 ( 4 E 8, )$) s ( 0 ( 4 E 8 ) 11, $) r 5: F (E). 8. ( 0 F 3, $) r 4: T F. 9. ( 0 T 2, $) r 2: E T. 10. ( 0 E 1, $) accept Dérivation correspondante (num) <= (num) <= (num) <= (F) <= (T) <= (E) <= (E) <= F <= T <= E +*)($ETF s5s5 num s4s4 312 actions / gotogoto s5s5 r6r6 r6r6 r6r6 r6r6 s5s5 s5s5 r1r1 r3r3 s 11 r1r1 r3r3 s7s7 r3r3 s6s6 r1r1 r3r3 r5r5 r5r5 r5r5 r5r5 s4s s4s4 r4r4 r4r4 r2r2 r2r2 r4r4 r4r4 s7s7 r2r2 s6s6 s4s4 acc