poignée Automates à pile LRNotion de IFT313Introduction aux langages formels

(1)

IFT313

Introduction aux langages formels

Froduald Kabanza

Département d’informatique Université de Sherbrooke

Automates à pile LR

Notion de poignée

(2)

IFT313 © Froduald Kabanza

2

Sujets

• Automate à pile LR

– Définition – Simulation

• Notion de poignée (handle)

– Définition

• Ébauche d’un pilote (driver) LR

– Définition

– Simulation

(3)

3

Objectifs

• Pouvoir définir et simuler un automate à pile LR.

• Pouvoir définir la notion de poignée (han- dle).

• Introduction aux défis fondamentaux de

l’analyse LR.

(4)

4

Références

[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, 2^nd Edition. Addison Wesley, 2007.

– Section 4.5

(5)

5

Rappel

- Un générateur d’analyseurs syntaxiques LL(1) fonctionne comme suit :

• Son entrée est une grammaire.

• Le générateur LL(1) a accès à un driver LL(1).

• À partir de la grammaire, le générateur calcule une table d’analyse capable de déterminer (prédire) la production à appliquer, en fonction du non-terminal (partie gauche de la règle de production) au sommet de la pile et du prochain token.

• La sortie est juste une combinaison du driver LL(1) et de la table d’analyse.

• La sortie est équivalente à un automate à pile LL(1).

(6)

6

Rappel

- Un analyseur LL(1) effectue la dérivation la plus à gauche, dans ce sens que: à chaque instant, la chaîne restant à lire est dérivable du contenu de la pile par une dérivation la plus à gauche.

- Par conséquent les étapes d’un analyseur LL(1) consistent à :

• Développer le non terminal au sommet de la pile en le remplaçant par la partie droite d’une règle de production commençant par ce non terminal (prédiction d’une étape de dérivation à gauche).

• Enlever le terminal au sommet de la pile lorsqu’il correspond au prochain to- ken (reconnaître le préfixe de la chaîne dérivée jusqu’à cet étape par une déri- vation à gauche)

(7)

7

Rappel

- L’analyse LL(1) détermine la production à appliquer au non-terminal au sommet de la pile juste en lisant le prochain token sur l’entrée.

- Toutefois, ceci est faisable seulement si la grammaire ne contient pas des productions récursives à gauche, partageant un préfixe, ou ambigües.

- Si une grammaire ne remplit pas ces conditions, nous devons la transformer en une grammaire équivalente les satisfaisant.

- Très souvent, cela donne lieu à une grammaire moins intuitive, ne reflétant pas na- turellement la grammaire de notre langage de programmation.

- Une telle grammaire peut être difficile à déboguer et à mettre à jour.

- La méthode d’analyse LR évite ces problèmes.

(8)

8

LL vs LR

- Un analyseur LL

- Commence avec une chaîne de tokens et un symbole de départ de la grammaire.

- Répétitivement, il détermine la production à utiliser pour dériver le reste de la chaîne de tokens : on remplace le symbole au sommet de la pile correspondant à la la par- tie gauche d’une règle de production, par la partie droite.

- C’est une approche de haut en bas (du symbole de départ vers la chaîne des tokens).

- Cela donne une dérivation la plus à gauche de la chaîne de tokens à partir du symbole de départ.

- Un analyseur LR

- Commence aussi par la chaîne de tokens, mais le symbole de départ de la grammaire n’est pas impliqué dès le départ.

- Répétitivement, on met autant de tokens que possible sur la pile, jusqu’à avoir une sous- chaîne au sommet de la pile correspond à la partie droite d’une production; on peut alors remplacer la sous-chaîne sur la pile par la partie gauche de la production.

- C’est une approche de bas en haut (de la chaîne de tokens vers le symbole de départ).

- Cela donne la dérivation la plus à droite à partir du symbole de départ.

(9)

9

Exemple – Automate à pile LL

Grammaire

G = (V,A,R,S), avec V = {S, A, B}

A = {a, b, c, d , e}

R = {

S ® aABe, A ® Abc | b B ® d

}

ε, S/aABe – Prédire

S ® aABe

ε, A/Abc -

Prédire A ® Abc

ε, A/b -

Prédire A ® b

ε, B/d -

Prédire B ® d

a , a/ ε -

reconnaître ‘a’

b , b/ ε -

reconnaître ‘b

’ c , c/ ε -

reconnaître ‘c’

d , d/ ε -

reconnaître ‘d’

e , e/ ε -

reconnaître ‘e’

p ε, ε/S q

(10)

10

Exemple – Automate à pile LL

Grammaire

G = (V,A,R,S), avec V = {S, A, B}

A = {a, b, c, d , e}

R = {

}

ε, S/aABe ε, A/Abc ε, A/b ε, B/d

a, a/ε b, b/ε c, c/ε d, d/ε e, e/ε

p ε, ε/S q

(11)

11

Exemple – Automate à pile LL

Entrée: abbcde

(pile, entrée) Action

0. Symbole de départ sur pile 1. ( S$, abbcde$) Prédire S ® aABe 2. ( aABe$, abbcde$) Reconnaître ‘a’

3. ( ABe$, bbcde$) Prédire A ® Abc 4. ( AbcBe$, bbcde$) Prédire A ® b 5. ( bbcBe$, bbcde$) Reconnaître ‘b’

6. ( bcBe$, bcde$) Reconnaître ‘b’

7. ( cBe$, cde$) Reconnaître ‘c’

8. ( Be$, de$) Prédire B ® d 9. ( de$, de$) Reconnaître ‘d’

10. ( e$, e$) Reconnaître ‘e’

11. ( $, $) Accept Règles de la grammaire

S ® aABe, A ® Abc | b B ® d

ε, S/aABe ε, A/Abc ε, A/b ε, B/d

a, a/ε b, b/ε c, c/ε d, d/ε e, e/ε

p ε, ε/S q

(12)

12

Automate à pile LR : description informelle

- La technique utilisée par les analyseurs LR est appelée “shift-reduce” (avance-ré- duit) par opposition à “predict-match” des analyseurs LL.

- L’idée est de lire les tokens, un à un, en les mettant sur la pile. À chaque étape, on analyse la pile pour vérifier si elle contient une sous-chaîne au sommet correspondant à une partie droite d’une production.

• Si oui, on remplace la sous-chaîne par la partie gauche. Ceci équivaut à une étape de dérivation. Cette étape est appelée “reduire (la pile)”.

• Sinon, on continue à lire les tokens, en les déplaçant au sommet de la pile, jusqu’à avoir une sous-chaîne correspondant à la partie droite d’une production. Cette étape est appelée « shifting (avancer) (la tête de lecture des

tokens) » (après avoir déplacé le token courant sur la pile) . - C’est ça un automate à pile LR …

(13)

13

Exemple

Entrée: abbcde

(pile, entrée) action Initialization 1. ( $, abbcde$) Shift ‘a’

2. ( a$, bbcde$) Shift ‘b’

3. ( ba$, bcde$) Reduce ‘b’ (A ® b)

4. ( Aa$, bcde$) Shift ‘b’

5. ( bAa$, cde$) Shift ‘c’

6. ( cbAa$, de$) Reduce ‘Abc’ (A ® Abc)

7. ( Aa$, de$) Shift ‘d’

8. ( dAa$, e$) Reduce ‘d’ (B ® d)

9. ( BAa$, e$) Shift ‘e’

10. ( eBAa$, $) Reduce ‘aABe’ (S ® aABe) 11. ( S$, $) Finish : Accept

12. ( $, $) Grammaire

G = (V,A,R,S), avec V = {S, A, B}

A = {a, b, c, d , e}

R = {

}

(14)

14

Vu de l’automate pile avec le fond à gauche

Entrée: abbcde

(pile, entrée) action

1. ($, abbcde$) Initialization 2. ($a, bbcde$) Shift ‘a’

3. ($ab, bcde$) Shift ‘b’

4. ($aA, bcde$) Reduce ‘b’ (A ® b)

5. ($aAb, cde$) Shift ‘b’

6. ($aAbc, de$) Shift ‘c’

7. ($aA, de$) Reduce ‘Abc’ (A ® Abc)

8. ($aAd, e$) Shift ‘d’

9. ($aAB, e$) Reduce ‘d’ (B ® d)

10. ($aABe, $) Shift ‘e’

11. ($S, $) Reduce ‘aABe’ (S ® aABe)

12. ($, $) Finish : Accept Grammaire

G = (V,A,R,S), avec V = {S, A, B}

A = {a, b, c, d , e}

R = {

}

(15)

15

Observation importante

- A chaque étape, le contenu de la pile (a) concaténé avec le reste de l’entrée (v), est une forme sententielle pour une dérivation la plus à droite : c.-à-d., S => a v

R

*

1. ($, abbcde$) Initialization

2. ($a, bbcde$) Shift ‘a’

4. ($aA, bcde$) Reduce ‘b’ (A ® b)

5. ($aAb, cde$) ^{Shift ‘b’}

6. ($aAbc, de$) ^{Shift ‘c’}

7. ($aA, de$) Reduce ‘Abc’ (A ® Abc)

8. ($aAd, e$) Shift ‘d’

9. ($aAB, e$) Reduce ‘d’ (B ® d)

10. ($aABe, $) Shift ‘e’

11. ($S, $) Reduce ‘aABe’ (S ® aABe)

12. ($, $) Finish : Accept

abbcde <= abbcde <= abbcde <= aAbcde <=

aAbcde <=

aAbcde <= aAde <= aAde <= aABe <= aABe <= S

G = (V,A,R,S), avec V = {S, A, B}

A = {a, b, c, d , e}

R = {S ® aABe, A ® Abc | b B ® d }

(16)

16

Conflits shift-reduce et reduce-reduce

- L’automate LR est non déterministe parce qu’on peut avoir des conflits shift-reduce et reduce-reduce. Par exemple, à l’étape 6 on a la possibilité de déplacer (shift) ‘c’

et de réduire ‘b’ (avec A ® b).

- Dans l’exemple précédent, on a choisi shift. Un choix de reduce aurait donné lieu à une exécution différente.

Entrée: abbcde

(pile, entrée) action

1. ($, abbcde$) Initialization 2. ($a, bbcde$) Shift ‘a’

4. ($aA, bcde$) Reduce ‘b’ (A ® b)

5. ($aAb, cde$) Shift ‘b’

6. ($aAA, cde$) Reduce ‘b’ (A ® b)

. . .

Rejet

Grammaire

G = (V,A,R,S), avec V = {S, A, B}

A = {a, b, b, c, d , e}

R = { S ® aABe, A ® Abc | b B ® d }

(17)

17

Analyseurs LR déterministes

- Les questions fondamentales dans l’analyse LR sont :

• Quand faire shift, quand faire reduce ?

• S’il y a plusieurs productions dont les parties droites correspondent à des chaînes au sommet de la pile, quelle production utiliser pour faire reduce.

- Pour une exécution déterministe, on ne devrait avoir aucun conflit entre les choix d’actions possibles (shift ou reduce).

- En fait, plus tard nous allons imposer des restrictions sur les grammaires acceptable pour une approche LR, afin d’éviter de tels conflits.

- Différentes restrictions nous donnerons différentes versions d’analyseurs LR déter- ministes: SLR(1), LR(1) and LALR(1).

(18)

18

D’où viennent les termes “Shift” et “Reduce”?

- L’action de lire un token est de le déplacer au sommet de la pile est communément connu sous le vocable « shift » (on avance la tête de lecture des tokens, après avoir déplacé le token actuel sur la pile).

- L’action de remplacer une chaînes de symboles au sommet de la pile par un non terminal (partie gauche d’une règle de production) est appelée “reduce” (on réduit la longueur de la pile puisque la partie droite d’une règle a toujours plus de sym- boles que la partie gauche pour une GHC; la seule exception est le cas des productions avec une partie droite qui est la chaîne vide).

- Par conséquent, l’automate à pile LR est aussi connu sous le nom d’automate à pile shift-reduce.

(19)

19

Poignées (handles) 1/ 2

- Une sous-chaîne au sommet de la pile qui correspond à une partie droite d’une production est appelée poignée (handle), pourvu qu’elle mène à une exécution qui accepte.

- En effet, nous avons déjà vu une situation où il y avait une sous-chaîne au

sommet de la pile, correspondant à une partie droite d’une règle de production, mais ne menant pas à l’acceptation de l’entrée. La sous-chaîne n’était pas une poignée.

- Plus précisément, une poignée d’une forme sententielle droite γ est une règle de production

A ® b

et une position dans γ à la quelle la chaîne b peut être trou- vée et remplacée par A afin de générer la forme sententielle précédente dans une dérivation de droite de γ.

- Autrement dit, si S =>

aA

w =>

ab

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

^R

ab w

^R

*

(20)

20

Poignées (handles) 1/ 2

- Si S =>

aA

w =>

ab

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

- Par abus de langage, si A ® b dans la position juste après a est une

poignée de ab w, nous allons aussi dire que b est une poignée pour en fait dire la partie droite d’une poignée A ® b .

- Lorsque

ab

est le contenu de la pile et w le restant de l’entrée, si b est une poignée, on va réduire b par la production correspondante A ® b .

- Vous remarquerez que jusque là l’on parle d’une poignée et non de la

poignée. C’est parce, si la grammaire est ambiguë, il peut y avoir plusieurs poignées pour une dérivation la plus droite.

- Si la grammaire est non ambigüe, on a toujours une seule dérivation la plus à droite, donc, une seule poignée à chaque étape.

R* R

(21)

21

Automate à pile LR : description formelle

- On peut maintenant expliquer formellement la méthode pour construire un automate à pile LR (non déterministe) pour une GHC.

- Il faut se rappeler que selon notre convention, une transition de l’automate a la forme :

(état, prochain-token, sommet-de-pile) → (nouvel-état, nouveau-sommet)

- On aura une transition pour enlever le symbole de départ S de la pile lorsque l’automate a fini de lire toute l’entrée.

- Nous aurons aussi des transitions pour réduire la pile (reduce); c.-à-d., remplacer une partie droite d’une règle de production par la partie gauche, sur la pile.

- Finalement, nous aurons des transitions pour déplacer les tokens sur la pile (shift).

(22)

22

Générer un automate LR pour une GHC

- Étant donné une grammaire G = (Nonterminaux, Terminaux, Productions, S), l’automate à pile LR correspondant est

M=({p,q}, Nonterminaux U Terminaux, Terminaux, R, p, {q}, $), tel que la relation des transitions R est définie comme suit :

(p, $, S$) → (q, ε) (Accept)

(p, ε, Y_k …Y₁ ) → (p, A) pour chaque production A → Y₁ … Y_k (Reduce) (Rappel : Y_k va être au sommet de la pile).

(p, a, ε) → (p, a) pour chaque terminal a (Shift)

- Toutes les configurations vont avoir l’état p, sauf éventuellement la dernière qui aura l’état q.

(23)

23

Exemple

Grammaire:

G = (V,A,R,S), avec V = {S, A, B}

A = {a, b, c, d , e}

R = {S ® aABe, A ® Abc | b B ® d }

Automate à pile

M = ({p,q}, {S,A,B}, {a, b, c, d, e}, R, p,{q},$) R = { 1. (p, $, S$) → (q, ε)

2. (p, ε, eBAa) → (p, S) 3. (p, ε, cbA) → (p, A) 4. (p, ε, b) → (p, A) 5. (p, ε, d) → (p, B) 6. (p, a, ε) → (p, a) 7. (p, b, ε) → (p, b) 8. (p, c, ε) → (p, c) 9. (p, d, ε) → (p, d) 10. (p, e, ε) → (p, e) }

(24)

24

Exemple, suite

Transitions 1. (p, $, S$) → (q, ε) 2. (p, ε, eBAa) → (p, S) 3. (p, ε, cbA) → (p, A) 4. (p, ε, b) → (p, A) 5. (p, ε, d) → (p, B) 6. (p, a, ε) → (p, a) 7. (p, b, ε) → (p, b) 8. (p, c, ε) → (p, c) 9. (p, d, ε) → (p, d) 10. (p, e, ε) → (p, e) }

Trace s’exécution.

Je montre seulement (pile, entrée). Toutes les configurations sont dans l’état p, sauf la dernière qui est dans l’état q.

1. ($, abbcde$) Transition (Shift) 6

2. ($a, bbcde$) Transition (Shift) 7

3. ($ab, bcde$) Transition (Reduce) 4

4. ($aA, bcde$) Transition (Shift) 7

5. ($aAb, cde$) Transition (Shift) 8

6. ($aAbc, de$) Transition (Reduce) 3

7. ($aA, de$) Transition (Shift) 9

8. ($aAd, e$) Transition (Reduce) 5

9. ($aAB, e$) Transition (Shift) 10

10. ($aABe, $) Transition (Reduce) 2

11. ($S, $) Transition (Accept) 1

12. ($, $) Dérivation correspondante:

aAbcde <=

aAde <= aAde <= aABe <= aABe <= S

(25)

25

Grammaire augmentée

- Pour définir un driver LR, nous avons besoin du concept de « grammaire augmen- tée ».

- Étant donné une grammaire G, la grammaire augmentée correspondante est obtenue en ajoutant :

 un nouveau symbole de départ S’ et

 une production S’ ® S.

- Ceci permet d’indiquer au driver LR quand arrêter l’analyse et annoncer l’acceptation de l’entrée.

 Lorsque la pile contient seulement S et que l’entrée est vide, la production précédente provoque un remplacement de S par S’ sur la pile.

 Contrairement à notre automate à pile, le driver LR n’accepte pas quand la pile et l’entrée sont vides. Au contraire, il accepte quand la pile contient S’.

 Il est possible de définir une version de driver LR qui accepte sur une pile vide, mais la formulation présente est la plus fréquente dans les manuels

académiques.

(26)

26

Algorithme LRDriver

Algorithm 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;

} }

(27)

27

Exemple revisité

Trace d’exécution

1. ($, abbcde$) Shift 2. ($a, bbcde$) Shift

3. ($ab, bcde$) Reduce 4

4. ($aA, bcde$) Shift

5. ($aAb, cde$) ^Shift 6. ($aAbc, de$) ^{Reduce 3} 7. ($aA, de$) Shift

8. ($aAd, e$) Reduce 5

9. ($aAB, e$) Shift

10. ($aABe, $) Reduce 2

11. ($S, $) Accept

12. ($S’, $) Dérivation correspondante:

aAbcde <=

aAbcde <= aAde <= aAde <= aABe <= aABe <= S

<= S’

Grammaire

G = (V,A,R,S’), avec V = {S, S’, A, B}

A = {a, b, c, d , e}

R = {

1.

S’ ® S,

2. S ® aABe, 3. A ® Abc | 4. b 5. B ® d

}

(28)

28

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 =>

aA

w =>

ab

w, alors A ® b dans la position juste après a est une poignée de 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 => aA w => 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

(29)

29

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’un poignée (c.-à-d., si le contenu de la pile ( ab ) n’est pas un contexte LR(0) mais est un préfixe d’un contexte LR(0)) , on met (shit) le prochain token sur la pile.

3. Si le sommet de la pile n’est un préfixe pour une poignée quelconque

(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.

(30)

30

Récapitulation

- Le défi majeur pour implémenter un driver LR efficace est de trouver la poignée, c-à-d., l’étape ‘handle = stack.findHandle()’.

- Une approche naïve pour implémenter stack.findHandle() serait de comparer le contenu de la pile avec les parties droites des règles de production pour trouver une rè- gle dont la partie droite est au sommet de la pile.

 Par contre, il faudra faire backtracking si on se trompe est que cette partie droite ne mène pas à l’acceptation (c.-à-d., ne s’avère pas être une poignée).

- Pour des sous-classes intéressantes des GHC, on peut éviter de scanner la pile et de faire backtracking pour trouver une poignée.

- Dans ce cours, on verra les grammaires SLR(1), LR(1) et LALR(1).

(31)

31

Récapitulation

- Le problème est donc de trouver une poignée sur la pile (partie droite d’une production menant à l’acceptation) et de déterminer avec quel non terminal la remplacer (avec quelle production réduire).

- Cette décision est plus difficile à faire que la décision correspondante dans l’analyse LL (prédire une production). Par conséquent, elle plus difficile à implémenter.

- Néanmoins, cette approche nous permet de mettre moins de restrictions sur les langages (et leurs grammaires) pouvant être analysés.

- Plus précisément, on a plus de chance d’avoir à spécifier une grammaire simple avec une approche LR qu’avec une approche LL, pour le même langage.