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

Sujets Algorithme générique pour l’analyse LR (Driver LR) Table d’analyse SLR(1). IFT313 © Froduald Kabanza

Objectifs Pouvoir définir et simuler l’algorithme d’analyse LR (Driver LR) Pouvoir générer une table d’analyse SLR(1) pour une grammaire donnée. Pouvoir reconnaître les grammaires SLR(1). IFT313 © Froduald Kabanza

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

(C) Froduald Kabanza & Éric Beaudry Rappel : AFD LR(0) I0 I1 I6 I9 I2 I7 I10 I8 I11 I5 E T + F ( num * ) to I7 to I2 to I6 to I3 to I4 to I5 I4 I3 I0 E’ .E E .E+T E .T T.T*F T .F F .(E) F.num I1 E’ E. E E.+T I2 E T. TT.*F I3 T F. I4 F (.E) F .num I5 F num. I6 E E+.T T .T*F I7 TT*.F I8 F (E.) I9 E E+T. TT*F. I11 F (E). IFT313 / 2009E (C) Froduald Kabanza & Éric Beaudry

Rappel : Analyseur LR(0) Un analyseur (syntaxique) LR(0) n’a pas besoin d’anticiper le prochain token (lookahead) pour prendre une décision shift ou reduce. Il décide de l’action appropriée (shift ou reduce) seulement en fonction de l’état courant de l’AFD pour les préfixes viables. Ce comportement est reflété par la version suivante de l’analyseur LR(0). Algorithm LR0Parser. Entrée : flux de tokens Sortie : dérivation de l’entré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 Kabanza

Rappel : Analyseur LR(0) while (true) { if (la pile contient I0S’ et l’entrée est $ (vide)) return true; if (l’état au sommet de la pile contient un élément A ® a . ) { reduce with the production A ® a; // a est une poignée et A ® a la production correspondante c.-à-d. : Supprimer 2×|a| symboles de la pile (|a| états et |a| 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 ® a; continue; } if (l’état au sommet de la pile contient un élément A ® a . ab 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. error(); IFT313 © Froduald Kabanza

Rappel : Grammaires LR(0) Un élément shift (shift item) est un élément de la forme « A ® a . ab »  tel que a est un terminal. Un élément reduce (reduce item) est un élément de la forme « A ® a . » Si l’AFD LR(0) a un état contenant à la fois un élément shift et un élément reduce, ou plus d’un élément reduce, alors la grammaire correspondante n’est pas LR(0). Par exemple, la grammaire précédente n’est 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 Kabanza

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 l’entrée ‘;’ fait partie des terminaux. Sans elle, la grammaire n’est plus LR(0). Pour montrer que la grammaire est LR(0), on construit l’AFD pour les préfixes viables et on vérifie qu’aucun état ne contient à la fois d’éléments shift et d’élément reduce, ou plus d’un élément reduce. Ci-après on donne aussi une simulation de l’analyseur LR(0) pour l’entrée ‘3 + 6;’, ce qui correspond au flot de tokens ‘num + num;’ IFT313 © Froduald Kabanza

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

AFD + simulation de l’analyseur LR(0) avec une entrée correcte T® num. I0 S’® . S S® .E; E® .E+T E® .T T® .(E) T® .num I1 S® E .; E® E .+T I2 S® E;. I6 T® (.E) I3 E® E+.T I7 T® (E .) I4 E® E+T. I9 E®T. I8 F® (E). I10 S’® S. 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’ I0 I1 I6 I9 I2 I7 I8 I5 E T + num ( ) I4 I3 ; I10 S IFT313 © Froduald Kabanza

AFD + simulation de l’analyseur LR(0) avec une entrée erronée T® num. I0 S’® . S S® .E; E® .E+T E® .T T® .(E) T® .num I1 S® E .; E® E .+T I2 S® E;. I6 T® (.E) I3 E® E+.T I7 T® (E .) I4 E® E+T. I9 E®T. I8 F® (E). I10 S’® S. 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 + num ( ) I4 I3 ; I10 S IFT313 © Froduald Kabanza

Vers un pilote pour Analyseur LR (1) L’exemple précédent montre que lorsqu’on a une entrée erronée : L’analyseur LR(0) peut empiler (shift) le prochain token même s’il 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, l’erreur peut être détectée après avoir empilé quelques tokens de plus au-delà du token fautif. Nous allons voir une variante de l’analyseur LR(0) qui fait shift uniquement si le prochain token a un élément shift correspondant dans l’état courant de l’AFD. Techniquement parlant, ceci n’est pas un analyseur LR(0), puisqu’il consulte le prochain token avant de décider de faire shift. C’est un anaylseur LR(1). Néanmoins, cette version est équivalente à l’analyseur LR(0), mis à part le fait qu’elle permet de détecter des erreurs plus tôt. Avec l’exemple précédent, l’erreur serait détectée à l’étape 5 lorsqu’on essaie d’empiler (shift) le ‘+’. Nous décrivons cette variante parce qu’elle permet une bonne transition vers l’analyseur LR(1) général qui nous intéresse le plus. IFT313 © Froduald Kabanza

Analyseur LR(1) équivalent à l’analyseur LR(0) while (true) { // Version 2 if (la pile contient I0S’ et l’entrée est $ (vide)) return true; if (l’état au sommet de la pile contient un élément A ® a . ) { reduce with the production A ® a; // a est une poignée et A ® a la production correspondante c.-à-d. : Supprimer 2×|a| symboles de la pile (|a| états et |a| 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 ® a; continue; } if (l’état au sommet de la pile contient un élément A ® a . ab 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. error(); IFT313 © Froduald Kabanza

Exemple revisité avec le nouvel algorithme T® num. I0 S’® . S S® .E; E® .E+T E® .T T® .(E) T® .num I1 S® E .; E® E .+T I2 S® E;. I6 T® (.E) I3 E® E+.T I7 T® (E .) I4 E® E+T. I9 E®T. I8 F® (E). I10 S’® S. 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 + num ( ) I4 I3 ; I10 S IFT313 © Froduald Kabanza

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

Tables d’analyse LR(0) avec lookahead Avec lookhead, la table est indexée par l’état de l’AFD et le prochain token. L’entrée dans la table est un symbole désignant l’action (shift ou reduce) et/ou l’état successeur pour la fonction goto. Nous utilisons les conventions suivantes pour la spécification des tables : 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 l’entrée; une entrée vide signifie que l’analyseur doit signaler une erreur. Comme expliqué précédement, en principe on n’a pas besoin de lookahead pour l’analyse LR(0). Je montre quand même l’algorithme d’analyse avec lookahead comme introduction à l’analyse LR(1). Je montrerai l’algorithme sans lookahead (optionnel) plus tard si j’ai le temps. IFT313 © Froduald Kabanza

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

Construire la table d’analyse LR(0) avec lookahead 2/2 3. Si goto(Ii, A) = Ij 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 l’AFD 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 n’est pas LR(0). Sinon, elle est LR(0). IFT313 © Froduald Kabanza

Exemple 1/2 IFT313 © Froduald Kabanza 1 2 3 4 5 I5 T® num. I0 S’® . S S® .E; E® .E+T E® .T T® .(E) T® .num I1 S® E .; E® E .+T I2 S® E;. I6 T® (.E) I3 E® E+.T I7 T® (E .) I4 E® E+T. I9 E®T. I8 T® (E). I10 S’® S. I0 I1 I6 I9 I2 I7 I8 I5 E T + num ( ) I4 I3 ; I10 S IFT313 © Froduald Kabanza

Exemple 2/2 State action/goto r2 acc r5 r4 r3 goto r1 + ) ( E T num s6 1 2 4 3 7 5 9 8 6 r2 s6 s3 s5 acc r5 r4 r3 ; s2 s8 $ goto 10 S r1 I0 I1 I6 I9 I2 I7 I8 I5 E T + num ( ) I4 I3 ; I10 S IFT313 © Froduald Kabanza

Algorithme d’analyse LR (1) 1/2 Algorithm LR1Parser Entrée : flux de tokens Sortie : dérivation de l’entré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 d’analyse 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 Kabanza

Algorithme d’analyse 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®a { pop 2x|a| 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®a ; if action[i,a] = accept return true; error(); IFT313 © Froduald Kabanza

Exemple (Simulation de l’analyseur LR(1)) State action/goto + ) ( E T num 1 2 4 3 7 5 9 8 6 r2 s6 s3 s5 acc r5 r4 r3 ; s2 s8 $ goto 10 S r1 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 1 + 3 num 5, ;$) Reduce 5 7. (0 E 1 + 3 T 4, ;$) Reduce 2 8. (0 E 1, ;$) Shift 9. (0 E 1 ; 2, $) Reduce 1 10. (0 S 10, $) Accept. Corresponding derivation sequence: num + num; <= num+ num; <= T + num; <= E + num <= E + num; <= E + num; <= E + T; <= E; <= E; <= S Grammar S’® S 1. S ® E; 2. E ® E+T 3. E ® T 4. T ® (E) 5. T ® num IFT313 © Froduald Kabanza

Forces et limites de l’analyse 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 l’exemple 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 qu’ils exigent des grammaires plus simples. IFT313 © Froduald Kabanza

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 n’est pas LR(0): E’ ® E (non numéroté parce que c’est 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 n’est pas LR(0), on montre que l’AFD 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 d’un élément reduce. Conséquemment la table d’analyse correspondante aurait des entrées multiples. IFT313 © Froduald Kabanza

AFD pour préfixes viables T + F ( num * ) to I7 to I2 to I6 to I3 to I4 to I5 I4 I3 1 2 3 4 5 6 I0 E’® .E E® .E+T E® .T T®.T*F T® .F F® .(E) F®.num I1 E’® E. E® E.+T I2 E® T. T®T.*F I3 T® F. I4 F® (.E) F® .num I5 F® num. I6 E® E+.T T® .T*F I7 T®T*.F I8 F® (E.) I9 E® E+T. T®T*F. I11 F® (E). IFT313 © Froduald Kabanza

Table d’analyse LR(0) s5 s4 State actions / goto goto r6 r1 r3 s11 s7 + * ) ( $ E T F s5 num 1 2 4 3 7 5 9 8 10 6 11 s4 State actions / goto goto r6 r1 r3 s11 s7 s6 r5 r4 r2 acc I0 I1 I6 I9 I2 I7 I10 I8 I11 I5 E T + F ( num * ) to I7 to I2 to I6 to I3 to I4 to I5 I4 I3 IFT313 © Froduald Kabanza

Analyse LR(1) Puisque les analyseurs LR(0) n’utilisent 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 d’analyse, un peu comme dans la version de l’analyseur LR(0) avec lookahead. La différence est que dans le cas d’un analyseur LR(1), le lookahead est non seulement impliqué dans la décision de faire l’action shift, mais aussi dans la décision de faire l’action reduce. IFT313 © Froduald Kabanza

Analyse LR(1) Les analyseurs LR(1) les plus populaires sont SLR(1) et LALR(1). SLR(1) signifie “simple” LR(1). Techniquement, c’est une simple modification de l’analyseur LR(0) avec lookahead. La modification est très simple mais significative : on obtient un analyseur presque aussi puissant qu’un analyseur LR(1) complet. LALR(1) signifie “Look Ahead LR(1)”. Il est légèrement plus puissant que SLR(1). L’appellation “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 à l’AFD pour les préfixes viables : dans un analyseur LALR(1), l’AFD est composé des éléments qui sont associés avec un lookahead, alors que ce n’est pas le cas ni dans l’analyse SLR(1) ni dans l’analyse LR(0) avec lookahead. IFT313 © Froduald Kabanza

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

Construire la table d’analyse SLR(1) 2/2 3. Si goto(Ii, A) = Ij 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 l’AFD 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 n’est pas SLR(1). L’algorithme d’analyse 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) puisqu’on ne s’intéresse pratiquement pas à des analyseurs SLR(k) avec k>1. IFT313 © Froduald Kabanza

Exemple to I7 to I2 to I6 to I3 to I4 to I5 IFT313 © Froduald Kabanza + F ( num * ) to I7 to I2 to I6 to I3 to I4 to I5 I4 I3 1 2 3 4 5 6 I0 E’® .E E® .E+T E® .T T®.T*F T® .F F® .(E) F®.num I1 E’® E. E® E.+T I2 E® T. T®T.*F I3 T® F. I4 F® (.E) F® .num I5 F® num. I6 E® E+.T T® .T*F I7 T®T*.F I8 F® (E.) I9 E® E+T. T®T*F. I11 F® (E). IFT313 © Froduald Kabanza

Table d’analyse SLR(1) s5 s4 State actions / goto goto r6 r1 r3 s11 s7 + F ( num * ) to I7 to I2 to I6 to I3 to I4 to I5 I4 I3 + * ) ( $ E T F s5 num 1 2 4 3 7 5 9 8 10 6 11 s4 State actions / goto goto r6 r1 r3 s11 s7 s6 r5 r4 r2 acc E’ -> E (non numéroté parce que c’est une production interne) 1. E -> E+T 2. E -> T 3. T -> T*F 4. T -> F 5. F -> (E) 6. F ->num IFT313 © Froduald Kabanza

Simulation s5 s4 actions / goto goto r6 r1 r3 s11 s7 s6 r5 r4 r2 acc + * ) ( $ E T F s5 num 1 2 4 3 7 5 9 8 10 6 11 s4 actions / goto goto r6 r1 r3 s11 s7 s6 r5 r4 r2 acc Exemple d’exécution : 1. (0, (num)$) s4 2. (0 ( 4, num)$) s5 3. (0 ( 4 num 5, )$) r6: F® num. 4. (0 ( 4 F 3, )$) r4: T® F. 5. (0 ( 4 T 2, )$) r2: E® T. 6. (0 ( 4 E 8, )$) s11 7. (0 ( 4 E 8 ) 11, $) r5: F® (E). 8. (0 F 3, $) r4: T® F. 9. (0 T 2, $) r2: E® T. 10. (0 E 1, $) accept Dérivation correspondante (num) <= (num) <= (num) <= (F) <= (T) <= (E) <= (E) <= F <= T <= E IFT313 © Froduald Kabanza

Algorithme d’analyse LR(0) sans lookahead Optionnel Algorithme d’analyse LR(0) sans lookahead IFT313 © Froduald Kabanza

Tables d’analyse LR(0) sans Lookahead En principle, pour l’analyse LR(0), on a pas besoin de lookahead. On aurait pu donc formule l’analyse LR(0) sans lookahead. Sans lookahead, la table d’analyse est indexée seulement par l’état de l’AFD. Nous utilisons les conventions suivantes pour la spécification des tables : s signifie ‘Fait shift’ (utilisé seulement dans les tables sans lookahead); On n’a plus besoin de si c.à`d. ‘Fait shift ensuite empile l’état i’ (c.-à-d., action shif et goto état i); ri signifie encore ‘Fait reduce avec la production numéro i’; acc signifie accepte l’entrée; une entrée vide signifie que l’analyseur doit signaler une erreur. IFT313 © Froduald Kabanza

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

Construire la table d’analyse LR(0) sans lookahead) 2/2 3. Si goto(Ii, A) = Ij 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 l’AFD 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 n’est pas LR(0). Sinon, elle est LR(0). IFT313 © Froduald Kabanza

Exemple 1/2 IFT313 © Froduald Kabanza 1 2 3 4 5 I5 T® num. I0 S’® . S S® .E; E® .E+T E® .T T® .(E) T® .num I1 S® E .; E® E .+T I2 S® E;. I6 T® (.E) I3 E® E+.T I7 T® (E .) I4 E® E+T. I9 E®T. I8 T® (E). I10 S’® S. I0 I1 I6 I9 I2 I7 I8 I5 E T + num ( ) I4 I3 ; I10 S IFT313 © Froduald Kabanza

Exemple 2/2 goto action s State r1 r2 r5 r4 r3 acc + ) ( E T num ; S 1 2 4 3 7 5 9 8 6 action r2 r1 r5 r4 r3 ; S 10 acc IFT313 © Froduald Kabanza

Algorithme d’analyse LR(0) avec table d’analyse sans lookahead (1/2) Algorithm LR0ParserWithTable Entrée : flux de tokens Sortie : dérivation de l’entré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 d’analyse LR(0) sans lookahead. Méthode : Initialement la pile contient 0 (c-.à-d., état 0). Ensuite il exécute le code suivant. IFT313 © Froduald Kabanza

Algorithme d’analyse LR(0) avec table d’analyse 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®a { pop 2x|a | 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®a ; if action[i] = accept and the input is empty return true; error(); IFT313 © Froduald Kabanza

Exemple (simulation de l’analyseur LR(0)) State + ) ( E T s num 1 2 4 3 7 5 9 8 6 action r2 r1 r5 r4 r3 ; S 10 acc 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 1 + 3 num 5, ;$) Reduce 5 7. (0 E 1 + 3 T 4, ;$) Reduce 2 8. (0 E 1, ;$) Shift 9. (0 E 1 ; 2, $) Reduce 1 10. (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 ® E; 2. E ® E+T 3. E ® T 4. T ® (E) 5. T ® num IFT313 © Froduald Kabanza