IFT313Introduction aux langages formels

Froduald Kabanza

Département d’informatique

Université de Sherbrooke

Analyseurs LR(0)

© Froduald Kabanza

2IFT313

Sujets

• Préfixes viables.

• Éléments LR(0).

• AFD LR(0) pour reconnaître les préfixes viables.

• Analyseur LR(0).

© Froduald Kabanza

3IFT313

Objectifs

• Pouvoir calculer l’AFD qui reconnait les préfixes viables.

• Pouvoir générer une table d’analyse LR(0).

• Pouvoir décrire le driver LR(0) et le simuler.

© Froduald Kabanza

4IFT313

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

5

Rappel : Algorithme LRDriverAlgorithm LRDriver

variables : stack, handle (sous-chaîne au sommet de la pile), a (token), in (entrée)

initialement la pile est vide ($) et l’entrée est w$ (une chaîne w).

while (true) {

if (symbol on top of stack is S’ ) return (a = = $); //accepte

handle = stack.findHandle(); //trouver une poignée. Étape cruciale !

if handle != void { // void si la poignée n’est pas trouvée

soit ‘A → handle’ la règle correspondante // reduce (nondeterminisme si plusieurs règles)

pop handle from the stack;

push A on the stack;

print out the production ‘A → handle’; // pour imprimer la séquence de dérivation

}

else {

a = in.nextToken(); // shift

if a = $ exit with error(); // erreur si ni reduce ni shift ne sont possibles

push a on the stack;

continue;

}

}

© Froduald Kabanza

6IFT313

Exemple

Grammaire

G = (V, A, R, E), avecV= {E, F, T}A = {(, ), +, *, num}

R = { E ® E + T

E ® T T ® T * F T ® F

F ® ( E) F ® num}

Grammaire augmentée

G = (V, A, R, E) :V= {E’, E, F, T}A = {(, ), +, *, num}

R = {

E’ ® E E ® E +

T E ® T T ® T * F T ® F

F ® ( E) F ® num}

© Froduald Kabanza

7IFT313

Exemple, suite

Simulation du driver LR

1. ($, (num)$) Shift2. ($(, num)$) Shift3. ($(num, )$) Reduce 74. ($(F, )$) Reduce 5 5. ($(T, )$) Reduce 36. ($(E, )$) Shift7. ($(E), $) Reduce 68. ($F, $) Reduce 59. ($T, $) Reduce 310. ($E, $) Reduce 111. ($E’, $) Accepte

Dérivation correspondante :

(num) <= (num) <= (num) <= (F) <= (T) <= (E) <=

(E) <= F <= T <= E <= E’

Productions 1. E’ ® E 2. E ® E + T 3. E ® T 4. T ® T * F 5. T ® F 6. F ® ( E) 7. F ® num

Observation

Le contenu de la pile (g )

concaténé avec les tokens

restant à lire (w) est une

forme sententielle pour une

dérivation la plus à droite :

S => g w*R

IFT313 © Froduald Kabanza

8

Rappel : Contexte LR(0) 1/2

- On aurait pu formuler l’analyser LR(0) à l’aide du concept de «contexte

LR(0)» plutôt que celui « poignée » (Sudkamp [1] , page 596).

- Nous avons introduit la « poignée » comme suit: Si S => aAw => ab w,

alors A ® b dans la position juste après a est une poignée pout ab w

- Étant donné une grammaire (V, Σ, P, S), la chaîne ab est un contexte LR(0) pour la règle de production A ® b s’il existe une dérivation

S => aAw => ab w, avec a et b ϵ (V U Σ)* et w ϵ Σ*.

- Autrement dit, ab est un contexte LR(0) pour la règle de production A ® b ssi A ® b est un poignée pour ab w, avec a et b ϵ (V U Σ)* et w ϵ Σ* .

R*

R

R

*R

IFT313 © Froduald Kabanza

9

Rappel : Contexte LR(0) 2/2- Tout comme pour un poignée, un contextes LR(0) détermine quand faire

une réduction durant l’analyse LR, sinon quand faire « shift ».

1. Si A ® b est une poignée (c.-à-d., si le contenu de la pile (ab) est un contexte LR(0) de la règle A ® b) , on réduit avec A ® .b

2. S’il n’y a pas de poignée au sommet de la pile, mais le sommet de la pile contient un préfixe d’une poignée (c.-à-d., si le contenu de la pile (ab) est n’est pas un contexte LR(0) mais est un préfixe d’un con-texte LR(0)), on met (shit) le prochain token sur la pile.

3. Si le sommet de la pile n’est pas un préfixe pour une poignée quel-conque (c.à-d., le contenu de la pile n’est pas un préfixe pour un contexte LR(0) quelconque), on rejette la chaîne d’entrée.

© Froduald Kabanza

10IFT313

Le problème de trouver la poignée- Pour une version déterministe, le défi est de trouver la poignée (méthode ‘stack.-

findHandle()’).

- Pour certaines classes de GHC, on peut trouver la poignée sans examiner tout le

contenu la pile. Cela découle de la propriété suivante sur les automates à pile LR :

S’il est possible de reconnaître une poignée seulement à partir du contenu de la

pile, alors il existe un AFD, qui en lisant les symboles de la grammaire à partir

du sommet de la pile, détermine quel poignée, s’il y en a, est au sommet.

- On va démontrer cette propriété en montrant comment construire l’AFD.

- Ensuite on va voir comment utiliser l’AFD pour implémenter stack.findHandle().

- Ceci nous conduira à deux techniques d’analyse LR (SLR(1) et LALR(1)), résultant

d’une combinaison ingénieuse de l’automate à pile LR et de l’AFD pour reconnaître

les poignées.

© Froduald Kabanza

11IFT313

Que doit être l’alphabet de l’AFD pour reconnaître les poignées ?

- Pour répondre à cette question, il faut garder à l’esprit que l’objectif est d’avoir un AFD qui lit le contenu de la pile (à partir du sommet) pour indi-quer s’il y a une poignée au sommet de la pile.

- Étant donné que la pile contient des symboles de la grammaire (terminaux et non-terminaux), l’alphabet de l’AFD doit être les symboles de la gram-maire.

- En d’autre mots, les transitions de l’AFD seront étiquetées par les symboles de la grammaires (terminaux et non terminaux).

- La question qui reste est de savoir quels devraient être les états de l’AFD et quelles devraient être les transitions entre ces états.

© Froduald Kabanza

12IFT313

Préfixes viables

- Pour répondre à la question précédente, rappelons d’abord que le contenu de la pile (g) concaténé avec le reste des tokens (a) est une forme sententielle pour la dérivation la plus à droite.

- Par conséquent, le contenu de la pile est toujours un préfixe d’une forme sententielle pour la dérivation la plus à droite.

- De tels préfixes de formes sententielles de dérivation à droite, pouvant appa-raître sur la pile, sont appelées des préfixes viables.

- De façon équivalente, un préfixe viable est défini comme étant un préfixe d’un contexte LR(0).

- On va voir comment construire un AFD pour reconnaître des préfixes viables.

- Ensuite on va expliquer comment l’utiliser pour reconnaître des poignées.

© Froduald Kabanza

13IFT313

AFN pour reconnaître les préfixes viables

- Les transitions de l’AFN vont être étiquetées par des symboles dont la séquence forme un préfixe viable.

- En d’autres mots, on aura les transitions si XYZ est un préfixe viable.

- Un état de l’AFN sera une production de la grammaire avec un point (« . ») à une position particulière dans la partie droite.

- Ainsi, à partir de la production A ® XYZ, on va générer 4 états de l’AFN :• A ® . XYZ• A ® X . YZ• A ® XY . Z• A ® XYZ .

- Pour la production A ® , e on va générer un seul état : A ® .

X Y Z

© Froduald Kabanza

14IFT313

Que signifient les états de l’AFN?- Intuitivement, un état de l’AFN indique la portion de la partie droite d’une produc-

tion, reconnue au sommet de la pile, à un moment donnée durant l’analyse syn-taxique LR.

- Par exemple l’état A ® . XYZ indique qu’aucune portion n’est encore reconnue sur la pile, et on espère que le reste des tokens à lire commence par un préfixe dérivable de XYZ.

- L’état A ® X.YZ indique qu’on vient juste de lire une sous-chaîne de tokens déri-vable de X (c.-à-d., le préfixe viable X est au sommet de la pile) et on s’attend à lire ensuite une suite de tokens formant un sous-chaîne dérivable de YZ.

- Un état de l’AFN est appelé un élement LR(0) (item LR(0) en anglais; ou élément tout court) de la grammaire.

- On peut implémenter un élément LR(0) par une paire d’entiers, le premier indiquant le numéro de la production, le deuxième indiquant la position du point.

- On peut maintenant expliquer la technique pour obtenir l’AFN de la grammaire.

© Froduald Kabanza

15IFT313

AFN pour reconnaître les préfixes viables

1. L’état initial est S’ ® . S

2. Pour chaque paire d’états A ® a . X b et A ® aX . ,b ajouter une transition du premier état vers le deuxième, étiquetée par X.

Il faut garder à l’esprit que A ® a . X b signifie : à un moment donné durant l’ana-lyse syntaxique, on vient juste de scanner un sous-chaîne dérivable de a et on s’at-tend à scanner une sous-chaîne dérivable de X, ensuite une sous-chaîne déri-vable de b.

Ainsi, la transition de A ® a . X b à A ® aX . ,b étiquetée X, signifie qu’on vient juste de lire une sous-chaîne dérivable de X et on s’attend maintenant à en lire une dérivable de b.

3. Pour chaque paire d’états A ® a . X b et X ® . ,g ajouter une transition du premier vers le deuxième, étiquetée .e

Intuitivement, si on s’attend à scanner une sous-chaîne dérivable de X et si X peut dé-

river , g on peut s’attendre aussi bien à scanner une chaîne dérivable de . g

© Froduald Kabanza

16IFT313

Éléments kernels (de base) et l’opération closure (fermeture)

1. L’état initial est S’ ® . S2. Pour chaque paire d’états A ® a . X b et A ® aX . ,b ajouter une transition

du premier état vers le deuxième, étiquetée par X. 3. Pour chaque paire d’états A ® a . X b et X ® . ,g ajouter une transition du

premier vers le deuxième, étiquetée e.

- Les éléments impliqués dans les deux premières opérations sont appelés des élé-ments kernels (c-à-d., des éléments du noyau, ou des élments de base).

• Il s’agit de l’élément S’ ® . S et des éléments dont le point ne commence pas la partie droite de la production.

• Les éléments dont le point apparaît au début de la partie droite de la production sont dits non kernel.

- La troisième opération est une fermeture e.

© Froduald Kabanza

17IFT313

Exemple 1/3

Grammaire augmentée

G = (V, A, R, E) :V= {E’, E, F, T}A = {(, ), +, *, num}

R = {

E’ ® E E ® E + T

E ® T T ® T * F T ® F

F ® ( E) F ® num

}

Grammaire

G = (V, A, R, E) :V= {E, F, T}A = {(, ), +, *, num}

R = { E ® E + T

E ® T T ® T * F T ® F

F ® ( E) F ® num

}

© Froduald Kabanza

18IFT313

Exemple 2/3

Grammaire

E’® EE® E+T

E® T

T®T*F

T® F

F® (E)

F®num

E’®.E

F® .num

E®.T

T®.F

T®.T*F

E®.E+T

F®.(E)

E’®E.

E®E.+T E®E+.T

E®E+T. T®T.*F

T®T*.F T®T*F. F®(.E)

E® .T

F®num.F®(E.)

F®(E).

T®F.E

e

ee

e+E

Seulement quelques transitions sont présentes ! Compléter les autres comme exercice.

T

F

AFN pour les préfixes viables

ee

© Froduald Kabanza

19IFT313

Exemple 3/3

Grammaire

E’® EE® E+T

E® T

T®T*F

T® F

F® (E)

F®num

E’ E T (F ) + * num e

1. E’® .E2. E’® .E3. E® .E+T4. E® E.+T5. E® E+.T6. E® E+T.

8. E® .T9. T®.T*F10. T®T.*F11. T®T*.F

12. T®T*F.13. T® .F14. T® F.15. F® .(E)

16. F® (E)17. F® (E)

18. F®num19. F®num

2

7. E® .T

3,7Même AFN, avectable de transition.

Seulement deux entrées complétées.

Les autres sont laissées commeexercice.

© Froduald Kabanza

20IFT313

AFD pour reconnaître les préfixes viables - On obtient l’AFD pour les préfixes viables en déterminisant l’AFN (par la méthode

subset construction).

I0E’® .EE® .E+TE® .T T®.T*F T® .FF® .(E) F®.num

I1E’® E.E® E.+T

I2E® T.T®T.*F

I3

T® F.

I4F® (.E) E® .E+TE® .T T®.T*F T® .FF® .(E)F® .num

I5

F® num.

I6E® E+.TT® .T*F T® .FF® .(E) F®.num

I7T®T*.F F® .(E) F®.num

I8F® (E.)E® E.+T

I9E® E+T. T®T.*F

I0

T®T*F.

I11

F® (E).

I0 I1 I6 I9

I2 I7 I10

I8 I11

I5

E T+

F

(

T num

(

F*

E )

+T

F

num

(

num

*to I7

to I2to I6

to I3

to I4to I5

to I4

to I5

to I3

num

I4

(

I3

F

© Froduald Kabanza

21IFT313

AFD pour reconnaître les préfixes viables - L’AFD avec une table de transition.

E T (F ) + * num

I1

E’

I0

I1

I2

I4

I3

I7

I5

I9

I8

I10

I6

I1

I2 I3 I5I4

I6

I7

I4I8 I2 I3 I5

I10 I4 I5

I11

I9 I3 I4 I5

I7

I6

I0E’® .EE® .E+TE® .T T®.T*F T® .FF® .(E) F®.num

I1E’® E.E® E.+T

I2E® T.T®T.*F

I3

T® F.

I4F® (.E) E® .E+TE® .T T®.T*F T® .FF® .(E)F® .num

I5

F® num.

I6E® E+.TT® .T*F T® .FF® .(E) F®.num

I7T®T*.F F® .(E) F®.num

I8F® (E.)E® E.+T

I9E® E+T. T®T.*F

I0

T®T*F.

I11

F® (E).

© Froduald Kabanza

22IFT313

AFD LR(0) pour reconnaître les préfixes viables

- Les états de l’AFD sont donc des ensembles d’états de l’AFN, c’est-à-dire, des ensembles d’éléments LR(0).

- Les états de l’AFD sont aussi appelés des ensembles canoniques d’éléments LR(0).

- La fonction de transition de l’AFD est appelée la fonction goto de l’analy-seur syntaxique:

Étant donné un état I de l’AFD et un symbole de grammaire X, goto(I,X) est le successeur de I pour la transition étiqueté par X.

© Froduald Kabanza

23IFT313

Méthode efficace de construction de l’AFD pour les préfixes viables

- Une méthode efficace de construction de l’AFD pour les préfixes viables est d’appliquer la méthode de déterminisation (subset construction method), à la volée, sans construire l’AFN au préalable.

- Pour ce faire, nous avons d’abord besoin de définir deux fonctions auxi-liaires: closer(I) et goto(I,X).

- closure(I) implémente la fermeture , e sous-jacente à méthode déterminisa-tion, en éliminant notamment les transitions e.

- goto(I,X) implémente les transitions entre les éléments du kernel.

© Froduald Kabanza

24IFT313

Définition informelle de closure

- Soit I un ensemble d’éléments LR(0) d’une grammaire.

- closure(I) est l’ensemble obtenu de I en appliquant les opérations suivantes :

• Initialement, chaque élément de I est mis dans closure(I).

• Ensuite on applique l’opération suivante, jusqu’à ce qu’aucun nouvel

élément ne peut plus être ajouté :

Si A ® a . X b est dans closure(I) et X ® g est une production,

ajouter l’élément X ® . g à closure(I).

© Froduald Kabanza

25IFT313

Définition formelle de closure(I)

Algorithm closure(I)

variables : I (ensemble d’éléments LR(0) : donnée d’entrée)

G (grammaire : donnée comme variable globale)

J (ensemble d’éléments LR(0): contient le résultat)

J = I; // initialisation

do {

for (each item A ® a . X b in J and each production X ® g of G such that

X ® . g is not in J)

add X ® . g to J

} while (J is modified)

return J;

© Froduald Kabanza

26IFT313

Fonction goto- Soit

- I un état de l’AFD (c.-à-d., un ensemble d’items LR(0)) et - X un symbole de la grammaire.

- Soit I’ l’ensemble formé de tous les éléments A ® aX . b pour lesquels il existe un élément A ® a . X b dans I.

- goto(I,X) = closure(I’).

- En d’autre mots, goto(I,X) est défini comme étant la fermeture (closure) de l’en-semble formé de tous les éléments A ® aX . b pour lesquels il existe un élément A ® a . X b dans I.

- Rappelons que les états de l’AFD sont aussi appelés des éléments (items) cano-niques LR(0).

- Comme on connaît la fonction goto, pour définir l’AFD il nous reste à donner l’al-gorithme pour calculer ces éléments (items).

© Froduald Kabanza

27IFT313

Algorithme pour les états de l’AFD LR(0)

Algorithm Items(G)

variables : G (entrée : grammaire augmentée avec symbole de départ S) et

C (résultat : ensembles des états de l’AFD.)

Output : C et la fonction goto.

C = { closure({S’® . S}) }; // état initial

do {

for (each state I in C and each grammar symbol X such that

goto(I,X) is not empty and not in C)

add goto(I,X) to C

} while (C is modified)

return C;

© Froduald Kabanza

28IFT313

Éléments valides

- Un élément A ® b1 . b2 est dit valide pour un préfixe viable a b1 s’il existe une

dérivation la plus à droite telle que : S’ => aAw => a b1 b2 w .

- On peut démontrer que l’ensemble des éléments valides pour un préfixe viable g

est précisément l’ensemble des éléments atteignables à partir de l’état initial de

l’AFD des préfixes viables, en suivant un chemin étiqueté par g.

- La validité de A ® b1 . b2 pour un préfixe a b1 nous indique s’il faut faire shift

ou alors reduce dès que a b1 est au sommet de la pile.

- En d’autre mots, ça nous indique si ab1 est une poignée ou non.

* *RR

© Froduald Kabanza

29IFT313

Quand faire shift, quand faire reduce ?

- Supposons que a b1 est au sommet de la pile et que l’élément A ® b1 . b2 est va-

lide pour a b1. Alors :

• Si b2 = e , cela veut dire qu’au sommet de la pile nous avons la partie droite

de la production A ® b1. C.-à-d., b1 est une poignée, on peut donc réduire.

• Sinon, si b2 ≠ , e cela veut dire qu’on doit faire shift des tokens de la sous-

chaîne b2 avant d’obtenir b1 b2 . C-à-d., on n’a pas encore une poignée sur la

pile, on doit continuer de faire shift.

- De ces observations, on déduit que si on simule l’AFD pour les préfixes viables en

parallèle avec le driver LR (automate à pile LR), on sera capable de déterminer

quand faire shift et quand faire reduce.

© Froduald Kabanza

30IFT313

Idée de base- L’idée de base pour simuler en parallèle l’automate à pile LR et l’AFD pour les pré-

fixes viables est la suivante.

- Initialement, l’automate est vide et l’AFD est dans son état initial.

- Chaque fois qu’on shift un token sur la pile, l’AFD change son état en suivant la transition étiquetée par le token.

- Ainsi, lorsque le sommet de la pile va contenir b1 l’AFD sera dans un état conte-

nant l’élément A ® b1 . , ce qui indique que nous devons faire une réduction avec la production A ® b1.

- En même temps que nous appliquons la réduction (en remplaçant b1 par A sur la pile), on doit revenir en arrière dans l’AFD (backtracking) le long du chemin éti-queté b1 jusqu’à l’état I qui est la racine du chemin étiqueté b1 .

- Puisque A est le nouveau symbole au sommet de la pile, on doit faire une transition correspondante dans l’AFD; c-à-d., l’état courant de l’AFD doit devenir l’état re-tourné par goto(I,A) (c.-à-d., le successeur de I sous la transition A dans l’AFD).

© Froduald Kabanza

31IFT313

De l’idée à l’implémentation- Pour implémenter cette idée, on met les états de l’AFD sur la pile de sorte à garder

une trace de l’exécution de l’AFD.

- Plus précisément, sur la pile on va alterner un état de l’AFD avec un symbole de la grammaire (terminal ou non-terminal), en commençant avec l’état initial de l’AFD.

- Donc une configuration du driver LR est dorénavant de la forme

(I0X1I1 … XmIm , ti … tn$),

tel que Ij sont des états de l’AFD, Xj des symboles de la grammaire, et ti … tn le reste des tokens à lire.

- Nous n’avons plus besoin de mettre le $ pour reconnaître le fond de la pile.

- L’état initial de l’AFD va remplir ce rôle.

© Froduald Kabanza

32IFT313

De l’idée à l’implémentation- Une configuration (I0X1I1 … XmIm, ti … tn$) signifie que:

- l’AFD est actuellement dans l’état Im , - le long d’un chemin (trace) étiqueté X1 … Xm à partir de l’état initial I0, - et le reste de l’entrée à scanner est ti… tn.

- Ainsi, si Xj … Xm, est une poignée, pour un j quelconque :

- Il doit y avoir un élément « A® Xj … Xm . » dans l’état Im.

- Dans ce cas, on fait une réduction en remplaçant Xj … Xm par A sur la pile.

- Plus précisément, on enlève Xj Ij … XmIm de la pile, et on ajoute AI’ tel que I’ est l’état retourné par goto(Ij-1, A).

- La suppression de XjIj … XmIm de la pile revient à un retour arrière (backtracking) dans l’AFD, le long du chemin Xj … Xm.

© Froduald Kabanza

33IFT313

Analyseur LR(0) (1/2)

- Un analyseur (syntaxique) LR(0) n’a pas besoin d’anticiper le prochain token (loo-kahead) 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

Input: stream of tokens

Output: a derivation sequence

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

© Froduald Kabanza

34IFT313

Analyseur LR(0) (2/2)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 correspon-

dante 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 . a b 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(); }

© Froduald Kabanza

35IFT313

Exemple

I0 I1 I6 I9

I2 I7 I10

I8 I11

I5

E T+

F

(

T num

(

F*

E )

+T

F

num

(

num

*to I7

to I2to I6

to I3

to I4to I5

to I4

to I5

to I3

num

I4

(

I3

F

I0E’® .EE® .E+TE® .T T®.T*F T® .FF® .(E) F®.num

I1E’® E.E® E.+T

I2E® T.T® T.*F

I3

T® F.

I4F® (.E) E® .E+TE® .T T®.T*F T® .FF® .(E)F® .num

I5

F® num.

I6E® E+.TT® .T*F T® .FF® .(E) F®.num

I7T®T*.F F® .(E) F®.num

I8F® (E.)E® E.+T

I9E® E+T. T®T.*F

I0

T®T*F.

I11

F® (E).

© Froduald Kabanza

36IFT313

Exemple 1

Trace

1. (I0, (num)$) Shift T® .(E)

2. (I0(I4, num)$) Shift T® .num

3. (I0(I4numI5, )$) Reduce F® num.

4. (I0(I4FI3, )$) Reduce T® F.

5. (I0(I4TI2, )$) Reduce E® T.

6. (I0(I4EI8, )$) Shift F® (E.)

7. (I0(I4EI8)I11, $) Reduce F® (E).

8. (I0FI3, $) Reduce T® F. 9. (I0TI2, $) Reduce E® T.

10. (I0EI1, $) Reduce E’® E. 11. (I0E’, $) Accept

Dérivation correspondante :

(num) <= (num) <= (num) <= (F) <= (T) <=

(E) <= (E) <= F <= T <= E <= E’

I0 I1 I6 I9

I2 I7 I10

I8 I11

I5

E T+

F

(

T num

(

F*

E )

+T

F

num

(

num

*to I7

to I2to I6

to I3

to I4to I5

to I4

to I5

to I3

num

I4

(

I3

F

© Froduald Kabanza

37IFT313

Exemple 2

Trace

1. (I0, (num)$) Shift T® .(E)

2. (I0(I4, num)$) Shift T® .num

3. (I0(I4numI5, )$) Reduce F® num.

4. (I0(I4FI3, )$) Reduce T® F.

5. (I0(I4TI2, )$) Shift T® T.*F

6. (I0(I4TI2), $) Error goto(I2, ‘)’) non défini.

I0 I1 I6 I9

I2 I7 I10

I8 I11

I5

E T+

F

(

T num

(

F*

E )

+T

F

num

(

num

*to I7

to I2to I6

to I3

to I4to I5

to I4

to I5

to I3

num

I4

(

I3

F

Même entrée, mais à l’étape 9, on résoud le conflit en faveur de Shift

© Froduald Kabanza

38IFT313

Exemple 3

Trace :

1. (I0, (num*num)$) Shift T® .(E)2. (I0(I4, num*num)$) Shift T® .num3. (I0(I4numI5, *num)$) Reduce F®num.4. (I0(I4FI3, *num)$) Reduce T® F.5. (I0(I4TI2, *num)$) …

Poursuivre comme exercice …

Remarquer le conflit Shift/Reduce à l’étape 5. L’état I2 contient élément Shift (T ® T.*F) et un élément Reduce (E ® T.).

Contrairement à l’exemple précédent, cette fois-ci le conflit devrait être réglé en faveur de Shift. Pourquoi?

I0 I1 I6 I9

I2 I7 I10

I8 I11

I5

E T+

F

(

T num

(

F*

E )

+T

F

num

(

num

*to I7

to I2to I6

to I3

to I4to I5

to I4

to I5

to I3

num

I4

(

I3

F

Une entrée différente