IFT313 Introduction aux langages formels Froduald Kabanza Département dinformatique Université de...

IFT313Introduction aux langages formels

Froduald Kabanza

Département d’informatique

Université de Sherbrooke

Automates à pile LR

Notion de poignée

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

Objectifs

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

• Pouvoir définir la notion de poignée

(handle).

• Introduction aux défis fondamentaux de

l’analyse LR.

© Froduald Kabanza

4IFT313

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, 2nd Edition. Addison Wesley, 2007.– Section 4.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

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

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 produc-tions 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

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

bole 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

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 correspon-dant à 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, jus-qu’à 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) » (a-près avoir déplacé le token courant sur la pile) .

- C’est ça un automate LR …


10

Exemple

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

S ® aABe,

A ® Abc | b

B ® d

}


11

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 vR*

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

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 }


12

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) action1. ($, 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. ($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 }


13

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


14

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

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


15

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 γ à la quelle la chaîne b peut être trouvé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 => aAw => ab w, alors A ® b dans la position juste

après a est une poignée de ab wR R

*


16

Poignées (handles) 1/ 2

- Si S => aAw => 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 poi-

gné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*


17

Automate à pile LR : description formelle

- On peut maintenant expliquer formellement la méthode pour construire un auto-mate à 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’au-tomate 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).


18

Générer un automate LR pour une GHC

- Étant donné une grammaire G = (Nonterminaux, Terminaux, Productions, S), l’au-

tomate à 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, ε, Yk …Y1 ) → (p, A) pour chaque production A → Y1 … Yk (Reduce)

(Rappel : Yk 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.


19

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) }


20

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) 62. ($a, bbcde$) Transition (Shift) 73. ($ab, bcde$) Transition (Reduce) 44. ($aA, bcde$) Transition (Shift) 75. ($aAb, cde$) Transition (Shift) 86. ($aAbc, de$) Transition (Reduce) 37. ($aA, de$) Transition (Shift) 98. ($aAd, e$) Transition (Reduce) 59. ($aAB, e$) Transition (Shift) 10 10. ($aABe, $) Transition (Reduce) 211. ($S, $) Transition (Accept) 1 12. ($, $)

Dérivation correspondante:


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


21

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’accepta-tion 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.


22

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;

}

}


23

Exemple revisité

Trace d’exécution

1. ($, abbcde$) Shift2. ($a, bbcde$) Shift3. ($ab, bcde$) Reduce 44. ($aA, bcde$) Shift 5. ($aAb, cde$) Shift6. ($aAbc, de$) Reduce 37. ($aA, de$) Shift8. ($aAd, e$) Reduce 59. ($aAB, e$) Shift 10. ($aABe, $) Reduce 211. ($S, $) Accept12. ($S’, $)

Dérivation correspondante:


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

}


24

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


25

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) est n’est 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 rejète la chaîne d’entrée.


26

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


27

Récapitulation

- Le problème est donc de trouver une poignée sur la pile (partie droite d’une produc-

tion 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

LR (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 lan-

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

IFT313 Introduction aux langages formels Froduald Kabanza Département dinformatique Université de...

Documents

Transcript of IFT313 Introduction aux langages formels Froduald Kabanza Département dinformatique Université de...