ift313 introduction aux langages formels froduald kabanza département dinformatique université de...
Post on 04-Apr-2015
103 Views
Preview:
TRANSCRIPT
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
top related