9 octobre 2007Cours de compilation 5 - Intranet1 Cours de compilation Techniques danalyse ascendantes.

Présentation au sujet: "9 octobre 2007Cours de compilation 5 - Intranet1 Cours de compilation Techniques danalyse ascendantes."— Transcription de la présentation:

1 9 octobre 2007Cours de compilation 5 - Intranet1 Cours de compilation Techniques danalyse ascendantes

2 9 octobre 2007Cours de compilation 5 - Intranet2 Les grandes lignes du cours Définitions de base Définitions de base Composition de compilateurs Composition de compilateurs Lenvironnement dun compilateur Lenvironnement dun compilateur Evaluation partielle et compilation Evaluation partielle et compilation Analyses lexicales et syntaxiques Analyses lexicales et syntaxiques Techniques danalyse descendantes Techniques danalyse descendantes Techniques danalyse ascendantes Techniques danalyse ascendantes YACC YACC Analyse sémantique Analyse sémantique Environnement dexécution Environnement dexécution Génération de code Génération de code Optimisation de code Optimisation de code

3 9 octobre 2007Cours de compilation 5 - Intranet3 U N E G R A M M A I R E N O N L L ( K )

4 9 octobre 2007Cours de compilation 5 - Intranet4 Une grammaire non LL ( k ) ---------------------------------------------------------------- En TD, nous avons démontré que la grammaire des expressions arithmétiques ci-dessous à gauche est LL ( 1 ) :En TD, nous avons démontré que la grammaire des expressions arithmétiques ci-dessous à gauche est LL ( 1 ) : A ::= T E E ::= + T E | E ::= + T E | T ::= F T T ::= * F T | T ::= * F T | F ::= id | ( A )

5 9 octobre 2007Cours de compilation 5 - Intranet5 Une grammaire non LL ( k ) ---------------------------------------------------------------- En TD, nous avons démontré que la grammaire des expressions arithmétiques ci-dessous à gauche est LL ( 1 ) :En TD, nous avons démontré que la grammaire des expressions arithmétiques ci-dessous à gauche est LL ( 1 ) : Il en est de même pour la grammaire ci-dessous à droite qui est celles des expressions logiques :Il en est de même pour la grammaire ci-dessous à droite qui est celles des expressions logiques : A ::= T E L ::= D H E ::= + T E | H ::= v D H | E ::= + T E | H ::= v D H | T ::= F T D ::= C I T ::= * F T | I ::= C I | T ::= * F T | I ::= C I | F ::= id | ( A ) C ::= id | ( E ) v

6 9 octobre 2007Cours de compilation 5 - Intranet6 Une grammaire non LL ( k ) ---------------------------------------------------------------- En TD, nous avons démontré que la grammaire des expressions arithmétiques ci-dessous à gauche est LL ( 1 ) :En TD, nous avons démontré que la grammaire des expressions arithmétiques ci-dessous à gauche est LL ( 1 ) : Il en est de même pour la grammaire ci-dessous à droite qui est celles des expressions logiques :Il en est de même pour la grammaire ci-dessous à droite qui est celles des expressions logiques : En combinant les expressions arithmétiques et logiques, nous ne sommes plus LL ( k ) pour aucun k :En combinant les expressions arithmétiques et logiques, nous ne sommes plus LL ( k ) pour aucun k : A ::= T E L ::= D H E ::= + T E | H ::= v D H | E ::= + T E | H ::= v D H | T ::= F T D ::= C I T ::= * F T | I ::= C I | T ::= * F T | I ::= C I | F ::= id | ( A ) C ::= id | ( E ) v | A = A

7 9 octobre 2007Cours de compilation 5 - Intranet7 Une grammaire non LL ( k ) ---------------------------------------------------------------- En TD, nous avons démontré que la grammaire des expressions arithmétiques ci-dessous à gauche est LL ( 1 ) :En TD, nous avons démontré que la grammaire des expressions arithmétiques ci-dessous à gauche est LL ( 1 ) : Il en est de même pour la grammaire ci-dessous à droite qui est celles des expressions logiques :Il en est de même pour la grammaire ci-dessous à droite qui est celles des expressions logiques : En combinant les expressions arithmétiques et logiques, nous ne sommes plus LL ( k ) pour aucun k :En combinant les expressions arithmétiques et logiques, nous ne sommes plus LL ( k ) pour aucun k : A ::= T E L ::= D H E ::= + T E | H ::= v D H | E ::= + T E | H ::= v D H | T ::= F T D ::= C I T ::= * F T | I ::= C I | T ::= * F T | I ::= C I | F ::= id | ( A ) C ::= id | ( E ) v | A = A

8 9 octobre 2007Cours de compilation 5 - Intranet8 Une grammaire non LL ( k ) ---------------------------------------------------------------- Il y a problème pour la règleIl y a problème pour la règle C ::= id | ( E ) | A = A C ::= id | ( E ) | A = A

9 9 octobre 2007Cours de compilation 5 - Intranet9 Une grammaire non LL ( k ) ---------------------------------------------------------------- Il y a problème pour la règleIl y a problème pour la règle C ::= id | ( E ) | A = A C ::= id | ( E ) | A = A car ( Prem ( ( E ) ) v Prem ( A = A ) car ( Prem ( ( E ) ) v Prem ( A = A )

10 9 octobre 2007Cours de compilation 5 - Intranet10 Une grammaire non LL ( k ) ---------------------------------------------------------------- Il y a problème pour la règleIl y a problème pour la règle C ::= id | ( E ) | A = A C ::= id | ( E ) | A = A car ( Prem ( ( E ) ) v Prem ( A = A ) car ( Prem ( ( E ) ) v Prem ( A = A ) Il y a des parenthèses arithmétiques et des parenthèses logiques :Il y a des parenthèses arithmétiques et des parenthèses logiques : ( ( A + B ) = C v... ) ( ( A + B ) = C v... )

11 9 octobre 2007Cours de compilation 5 - Intranet11 Une grammaire non LL ( k ) ---------------------------------------------------------------- Il y a problème pour la règleIl y a problème pour la règle C ::= id | ( E ) | A = A C ::= id | ( E ) | A = A car ( Prem ( ( E ) ) v Prem ( A = A ) car ( Prem ( ( E ) ) v Prem ( A = A ) Il y a des parenthèses arithmétiques et des parenthèses logiques :Il y a des parenthèses arithmétiques et des parenthèses logiques : ( ( A + B ) = C v... ) ( ( A + B ) = C v... )

12 9 octobre 2007Cours de compilation 5 - Intranet12 Une grammaire non LL ( k ) ---------------------------------------------------------------- Il y a problème pour la règleIl y a problème pour la règle C ::= id | ( E ) | A = A C ::= id | ( E ) | A = A car ( Prem ( ( E ) ) v Prem ( A = A ) car ( Prem ( ( E ) ) v Prem ( A = A ) Il y a des parenthèses arithmétiques et des parenthèses logiques :Il y a des parenthèses arithmétiques et des parenthèses logiques : ( ( A + B ) = C v... ) ( ( A + B ) = C v... )

13 9 octobre 2007Cours de compilation 5 - Intranet13 Une grammaire non LL ( k ) ---------------------------------------------------------------- Il y a problème pour la règleIl y a problème pour la règle C ::= id | ( E ) | A = A C ::= id | ( E ) | A = A car ( Prem ( ( E ) ) v Prem ( A = A ) car ( Prem ( ( E ) ) v Prem ( A = A ) Il y a des parenthèses arithmétiques et des parenthèses logiques :Il y a des parenthèses arithmétiques et des parenthèses logiques : ( ( A + B ) = C v... ) ( ( A + B ) = C v... ) Il peut y avoir plus que k parenthèses ouvrantes, quelle que soit la valeur de k !Il peut y avoir plus que k parenthèses ouvrantes, quelle que soit la valeur de k !

14 9 octobre 2007Cours de compilation 5 - Intranet14 Une grammaire non LL ( k ) ---------------------------------------------------------------- Il y a problème pour la règleIl y a problème pour la règle C ::= id | ( E ) | A = A C ::= id | ( E ) | A = A car ( Prem ( ( E ) ) v Prem ( A = A ) car ( Prem ( ( E ) ) v Prem ( A = A ) Il y a des parenthèses arithmétiques et des parenthèses logiques :Il y a des parenthèses arithmétiques et des parenthèses logiques : ( ( A + B ) = C v... ) ( ( A + B ) = C v... ) Il peut y avoir plus que k parenthèses ouvrantes, quelle que soit la valeur de k !Il peut y avoir plus que k parenthèses ouvrantes, quelle que soit la valeur de k !

15 9 octobre 2007Cours de compilation 5 - Intranet15 R E C U P E R A T I O N S U R E R R E U R

16 9 octobre 2007Cours de compilation 5 - Intranet16 Récupération sur erreur ---------------------------------------------------------------- Soit :Soit : Inst M_gauche=Expr

17 9 octobre 2007Cours de compilation 5 - Intranet17 Récupération sur erreur ---------------------------------------------------------------- Soit :Soit : Inst M_gauche=Expr

18 9 octobre 2007Cours de compilation 5 - Intranet18 Récupération sur erreur ---------------------------------------------------------------- Soit :Soit : Ou reprendre ? Ou reprendre ? Comment interpréter ? Comment interpréter ? Inst M_gauche=Expr

19 9 octobre 2007Cours de compilation 5 - Intranet19 Récupération sur erreur ---------------------------------------------------------------- Soit :Soit : Ou reprendre ? Ou reprendre ? Comment interpréter ? Comment interpréter ?... [... ( 5 + -...... [... ( 5 + -... Inst M_gauche=Expr

20 9 octobre 2007Cours de compilation 5 - Intranet20 Récupération sur erreur ---------------------------------------------------------------- Soit :Soit : Ou reprendre ? Ou reprendre ? Comment interpréter ? Comment interpréter ?... [... ( 5 + -... )...... [... ( 5 + -... )... Inst M_gauche=Expr Cherchez la parenthèse fermante ! Si elle existe ! ! !

21 9 octobre 2007Cours de compilation 5 - Intranet21 Récupération sur erreur ---------------------------------------------------------------- Soit :Soit : Ou reprendre ? Ou reprendre ? Comment interpréter ? Comment interpréter ?... [... ( 5 + -...... ]...... [... ( 5 + -...... ]... Inst M_gauche=Expr Cherchez le crochet fermant ! Sil existe ! ! !

22 9 octobre 2007Cours de compilation 5 - Intranet22 Récupération sur erreur ---------------------------------------------------------------- Soit :Soit : Ou reprendre ? Ou reprendre ? Comment interpréter ? Comment interpréter ?... [... ( 5 + -......... ;... [... ( 5 + -......... ; Inst M_gauche=Expr Cherchez le point virgule ! Sil existe ! ! !

23 9 octobre 2007Cours de compilation 5 - Intranet23 Récupération sur erreur ---------------------------------------------------------------- Le principe de la récupération sur erreur consisteLe principe de la récupération sur erreur consiste –à considérer les différentes constructions démarrées, mais non terminées ( par exemple : une expression dans un indexage dune instruction, dune fonction ),

24 9 octobre 2007Cours de compilation 5 - Intranet24 Récupération sur erreur ---------------------------------------------------------------- Le principe de la récupération sur erreur consisteLe principe de la récupération sur erreur consiste –à considérer les différentes constructions démarrées, mais non terminées ( par exemple : une expression dans un indexage dune instruction, dune fonction ), –à déterminer les « lexèmes suivants » de ces différentes constructions et

25 9 octobre 2007Cours de compilation 5 - Intranet25 Récupération sur erreur ---------------------------------------------------------------- Le principe de la récupération sur erreur consisteLe principe de la récupération sur erreur consiste –à considérer les différentes constructions démarrées, mais non terminées ( par exemple : une expression dans un indexage dune instruction, dune fonction ), –à déterminer les « lexèmes suivants » de ces différentes constructions et –à reprendre lanalyse après le premier tel lexème que nous rencontrons !

26 9 octobre 2007Cours de compilation 5 - Intranet26 Récupération sur erreur ---------------------------------------------------------------- Le principe de la récupération sur erreur consisteLe principe de la récupération sur erreur consiste –à considérer les différentes constructions démarrées, mais non terminées ( par exemple : une expression dans un indexage dune instruction, dune fonction ), –à déterminer les « lexèmes suivants » de ces différentes constructions et –à reprendre lanalyse après le premier tel lexème que nous rencontrons ! Dans la table danalyse nous pouvons indiquer les « suivants » souhaités en cas de problème !Dans la table danalyse nous pouvons indiquer les « suivants » souhaités en cas de problème !

27 9 octobre 2007Cours de compilation 5 - Intranet27 S T R U C T U R E D U N A N A L Y S E U R A S C E N D A N T

28 9 octobre 2007Cours de compilation 5 - Intranet28 Lanalyseur ascendant ---------------------------------------------------------------- Une vue densemble :Une vue densemble : ProgrammeLR

29 9 octobre 2007Cours de compilation 5 - Intranet29 Lanalyseur ascendant ---------------------------------------------------------------- Une vue densemble :Une vue densemble : ProgrammeLR w = a i #...

30 9 octobre 2007Cours de compilation 5 - Intranet30 Lanalyseur ascendant ---------------------------------------------------------------- Une vue densemble :Une vue densemble : ProgrammeLR w = a i #... s 0 x 1 s 1 x m s m

31 9 octobre 2007Cours de compilation 5 - Intranet31 Lanalyseur ascendant ---------------------------------------------------------------- Une vue densemble :Une vue densemble : ProgrammeLR w = a i #... s 0 x 1 s 1 x m s m x N v V s ETATS i i

32 9 octobre 2007Cours de compilation 5 - Intranet32 Lanalyseur ascendant ---------------------------------------------------------------- Une vue densemble :Une vue densemble : ProgrammeLR w = a i #... s 0 x 1 s 1 x m s m x N v V s ETATS i i ACTIONS SUCC

33 9 octobre 2007Cours de compilation 5 - Intranet33 Lanalyseur ascendant ---------------------------------------------------------------- Une vue densemble :Une vue densemble : ProgrammeLR w = a i #... s 0 x 1 s 1 x m s m x N v V s ETATS i i ACTIONS SUCC ACTIONS ( s, a ) SUCC ( s, A ) mi j

34 9 octobre 2007Cours de compilation 5 - Intranet34 Lanalyseur ascendant ---------------------------------------------------------------- Une autre vue de létat de la machine :Une autre vue de létat de la machine : ( s x s... x s, a... # ) 0 11mmi La pile ! Le mot !

35 9 octobre 2007Cours de compilation 5 - Intranet35 Lanalyseur ascendant ---------------------------------------------------------------- Une autre vue de létat de la machine :Une autre vue de létat de la machine : Il y a quatre types dactions :Il y a quatre types dactions : –Décaler ( SHIFT ) avec un état s ! –Réduire ( REDUCE ) avec une règle B ::= ! –Accepter ( ACCEPT ) ! –Erreur ( ERROR ) ! ( s x s... x s, a... # ) 0 11mmi

36 9 octobre 2007Cours de compilation 5 - Intranet36 Lanalyseur ascendant ---------------------------------------------------------------- Une autre vue de létat de la machine :Une autre vue de létat de la machine : Il y a quatre types dactions :Il y a quatre types dactions : –Décaler ( SHIFT ) avec un état s ! –Réduire ( REDUCE ) avec une règle B ::= ! –Accepter ( ACCEPT ) ! –Erreur ( ERROR ) ! ( s x s... x s, a... # ) Evidentes ! 0 11mmi

37 9 octobre 2007Cours de compilation 5 - Intranet37 Lanalyseur ascendant ---------------------------------------------------------------- Une autre vue de létat de la machine :Une autre vue de létat de la machine : Il y a quatre types dactions :Il y a quatre types dactions : –Décaler ( SHIFT ) avec un état s ! –Réduire ( REDUCE ) avec une règle B ::= ! –Accepter ( ACCEPT ) ! –Erreur ( ERROR ) ! Regardons en détail le SHIFT et le REDUCE !Regardons en détail le SHIFT et le REDUCE ! ( s x s... x s, a... # ) 0 11mmi

38 9 octobre 2007Cours de compilation 5 - Intranet38 Lanalyseur ascendant ---------------------------------------------------------------- Une autre vue de létat de la machine :Une autre vue de létat de la machine : Le SHIFT :Le SHIFT : –Si ACTIONS ( s, a ) = SHIFT s : ( s x s... x s, a... # ) 0 11mmi mi

39 9 octobre 2007Cours de compilation 5 - Intranet39 Lanalyseur ascendant ---------------------------------------------------------------- Une autre vue de létat de la machine :Une autre vue de létat de la machine : Le SHIFT :Le SHIFT : –Si ACTIONS ( s, a ) = SHIFT s : –alors nous engrangeons le lexème a et –nous empilons aussi létat s qui est caractéristique de toute la séquence x... x a ! ( s x s... x s, a... # ) 0 11mmi mi i i1m

40 9 octobre 2007Cours de compilation 5 - Intranet40 Lanalyseur ascendant ---------------------------------------------------------------- Une autre vue de létat de la machine :Une autre vue de létat de la machine : Le SHIFT :Le SHIFT : –Si ACTIONS ( s, a ) = SHIFT s : –alors nous engrangeons le lexème a et –nous empilons aussi létat s qui est caractéristique de toute la séquence x... x a ! ( s x s... x s, a... # ) ( s x s... x s a s, a... # ) 0 11mmi mi i i1m 01 1mmii+1

41 9 octobre 2007Cours de compilation 5 - Intranet41 Lanalyseur ascendant ---------------------------------------------------------------- Une autre vue de létat de la machine :Une autre vue de létat de la machine : Le SHIFT :Le SHIFT : –Si ACTIONS ( s, a ) = SHIFT s : –alors nous engrangeons le lexème a et –nous empilons aussi létat s qui est caractéristique de toute la séquence x... x a ! ( s x s... x s, a... # ) mi i i1m ( s x s... x s a s, a... # ) 01 1mmii+1 0 11mmi

42 9 octobre 2007Cours de compilation 5 - Intranet42 Lanalyseur ascendant ---------------------------------------------------------------- Une autre vue de létat de la machine :Une autre vue de létat de la machine : Le REDUCE :Le REDUCE : –Si ACTIONS ( s, a ) = REDUCE par A ::=... : ( s x s... x s, a... # ) 0 11mmi mi 1r

43 9 octobre 2007Cours de compilation 5 - Intranet43 Lanalyseur ascendant ---------------------------------------------------------------- Une autre vue de létat de la machine :Une autre vue de létat de la machine : Le REDUCE :Le REDUCE : –Si ACTIONS ( s, a ) = REDUCE par A ::=... : –alors nous avons x... x =... ! ( s x s... x s, a... # ) 0 11mmi mi 1r mm-r+11r

44 9 octobre 2007Cours de compilation 5 - Intranet44 Lanalyseur ascendant ---------------------------------------------------------------- Une autre vue de létat de la machine :Une autre vue de létat de la machine : Le REDUCE :Le REDUCE : –Si ACTIONS ( s, a ) = REDUCE par A ::=... : –alors nous avons x... x =... ! –Nous dépilons ces et leurs états correspondants et nous les remplaçons par le membre gauche A ! nous les remplaçons par le membre gauche A ! ( s x s... x s, a... # ) ( s x s... x s A, a... # ) 0 11mmi mi 01 1m-ri 1r mm-r+11r i m-r

45 9 octobre 2007Cours de compilation 5 - Intranet45 Lanalyseur ascendant ---------------------------------------------------------------- Une autre vue de létat de la machine :Une autre vue de létat de la machine : Le REDUCE :Le REDUCE : –Si ACTIONS ( s, a ) = REDUCE par A ::=... : –alors nous avons x... x =... ! –Nous dépilons ces et leurs états correspondants et nous les remplaçons par le membre gauche A ! nous les remplaçons par le membre gauche A ! –Le nouvel état est s obtenu grâce à SUCC ( s, A ) ! ( s x s... x s, a... # ) mi ( s x s... x s A s, a... # ) 01 1m-ri 1r mm-r+11r i m-r m-r 0 11mmi

46 9 octobre 2007Cours de compilation 5 - Intranet46 C O N F L I T S D A N S L A N A L Y S E A S C E N D A N T E

47 9 octobre 2007Cours de compilation 5 - Intranet47 Les conflits de lanalyse ascendante ---------------------------------------------------------------- Toutes les grammaires ne conviennent pas à une analyse ascendante, comme pour lanalyse descendante.Toutes les grammaires ne conviennent pas à une analyse ascendante, comme pour lanalyse descendante.

48 9 octobre 2007Cours de compilation 5 - Intranet48 Les conflits de lanalyse ascendante ---------------------------------------------------------------- Toutes les grammaires ne conviennent pas à une analyse ascendante, comme pour lanalyse descendante.Toutes les grammaires ne conviennent pas à une analyse ascendante, comme pour lanalyse descendante. Un état correspond « en gros » au fait quune règle soit analysée jusquà un certain point ( matérialisé par un. ) :Un état correspond « en gros » au fait quune règle soit analysée jusquà un certain point ( matérialisé par un. ) : A ::= A ::= 12345

49 9 octobre 2007Cours de compilation 5 - Intranet49 Les conflits de lanalyse ascendante ---------------------------------------------------------------- Toutes les grammaires ne conviennent pas à une analyse ascendante, comme pour lanalyse descendante.Toutes les grammaires ne conviennent pas à une analyse ascendante, comme pour lanalyse descendante. Un état correspond « en gros » au fait quune règle soit analysée jusquà un certain point ( matérialisé par un. ) :Un état correspond « en gros » au fait quune règle soit analysée jusquà un certain point ( matérialisé par un. ) : A ::= A ::= Le premier conflit est de type SHIFT – REDUCE.Le premier conflit est de type SHIFT – REDUCE. 12345

50 9 octobre 2007Cours de compilation 5 - Intranet50 Les conflits de lanalyse ascendante ---------------------------------------------------------------- Toutes les grammaires ne conviennent pas à une analyse ascendante, comme pour lanalyse descendante.Toutes les grammaires ne conviennent pas à une analyse ascendante, comme pour lanalyse descendante. Un état correspond « en gros » au fait quune règle soit analysée jusquà un certain point ( matérialisé par un. ) :Un état correspond « en gros » au fait quune règle soit analysée jusquà un certain point ( matérialisé par un. ) : A ::= A ::= Le premier conflit est de type SHIFT – REDUCE.Le premier conflit est de type SHIFT – REDUCE. Létat courant correspond aux deux règles suivantes :Létat courant correspond aux deux règles suivantes : A ::= X --- X. et B ::= X --- X. X --- X A ::= X --- X. et B ::= X --- X. X --- X 12345 1k1kk+1n

51 9 octobre 2007Cours de compilation 5 - Intranet51 Les conflits de lanalyse ascendante ---------------------------------------------------------------- Toutes les grammaires ne conviennent pas à une analyse ascendante, comme pour lanalyse descendante.Toutes les grammaires ne conviennent pas à une analyse ascendante, comme pour lanalyse descendante. Un état correspond « en gros » au fait quune règle soit analysée jusquà un certain point ( matérialisé par un. ) :Un état correspond « en gros » au fait quune règle soit analysée jusquà un certain point ( matérialisé par un. ) : A ::= A ::= Le premier conflit est de type SHIFT – REDUCE.Le premier conflit est de type SHIFT – REDUCE. Létat courant correspond aux deux règles suivantes :Létat courant correspond aux deux règles suivantes : A ::= X --- X. et B ::= X --- X. X --- X A ::= X --- X. et B ::= X --- X. X --- X 12345 1k1kk+1n

52 9 octobre 2007Cours de compilation 5 - Intranet52 Les conflits de lanalyse ascendante ---------------------------------------------------------------- Toutes les grammaires ne conviennent pas à une analyse ascendante, comme pour lanalyse descendante.Toutes les grammaires ne conviennent pas à une analyse ascendante, comme pour lanalyse descendante. Un état correspond « en gros » au fait quune règle soit analysée jusquà un certain point ( matérialisé par un. ) :Un état correspond « en gros » au fait quune règle soit analysée jusquà un certain point ( matérialisé par un. ) : A ::= A ::= Le premier conflit est de type SHIFT – REDUCE.Le premier conflit est de type SHIFT – REDUCE. Létat courant correspond aux deux règles suivantes :Létat courant correspond aux deux règles suivantes : A ::= X --- X. et B ::= X --- X. X --- X A ::= X --- X. et B ::= X --- X. X --- X 12345 1k1kk+1n

53 9 octobre 2007Cours de compilation 5 - Intranet53 Les conflits de lanalyse ascendante ---------------------------------------------------------------- Toutes les grammaires ne conviennent pas à une analyse ascendante, comme pour lanalyse descendante.Toutes les grammaires ne conviennent pas à une analyse ascendante, comme pour lanalyse descendante. Un état correspond « en gros » au fait quune règle soit analysée jusquà un certain point ( matérialisé par un. ) :Un état correspond « en gros » au fait quune règle soit analysée jusquà un certain point ( matérialisé par un. ) : A ::= A ::= Le second conflit est de type REDUCE – REDUCE.Le second conflit est de type REDUCE – REDUCE. 12345

54 9 octobre 2007Cours de compilation 5 - Intranet54 Les conflits de lanalyse ascendante ---------------------------------------------------------------- Toutes les grammaires ne conviennent pas à une analyse ascendante, comme pour lanalyse descendante.Toutes les grammaires ne conviennent pas à une analyse ascendante, comme pour lanalyse descendante. Un état correspond « en gros » au fait quune règle soit analysée jusquà un certain point ( matérialisé par un. ) :Un état correspond « en gros » au fait quune règle soit analysée jusquà un certain point ( matérialisé par un. ) : A ::= A ::= Le second conflit est de type REDUCE – REDUCE.Le second conflit est de type REDUCE – REDUCE. Létat courant correspond aux deux règles suivantes :Létat courant correspond aux deux règles suivantes : A ::= X --- X. et B ::= X --- X. A ::= X --- X. et B ::= X --- X. 12345 1 k 1 k

55 9 octobre 2007Cours de compilation 5 - Intranet55 Les conflits de lanalyse ascendante ---------------------------------------------------------------- Toutes les grammaires ne conviennent pas à une analyse ascendante, comme pour lanalyse descendante.Toutes les grammaires ne conviennent pas à une analyse ascendante, comme pour lanalyse descendante. Un état correspond « en gros » au fait quune règle soit analysée jusquà un certain point ( matérialisé par un. ) :Un état correspond « en gros » au fait quune règle soit analysée jusquà un certain point ( matérialisé par un. ) : A ::= A ::= Le second conflit est de type REDUCE – REDUCE.Le second conflit est de type REDUCE – REDUCE. Létat courant correspond aux deux règles suivantes :Létat courant correspond aux deux règles suivantes : A ::= X --- X. et B ::= X --- X. A ::= X --- X. et B ::= X --- X. 12345 1 k 1 k

56 9 octobre 2007Cours de compilation 5 - Intranet56 Les conflits de lanalyse ascendante ---------------------------------------------------------------- Toutes les grammaires ne conviennent pas à une analyse ascendante, comme pour lanalyse descendante.Toutes les grammaires ne conviennent pas à une analyse ascendante, comme pour lanalyse descendante. Un état correspond « en gros » au fait quune règle soit analysée jusquà un certain point ( matérialisé par un. ) :Un état correspond « en gros » au fait quune règle soit analysée jusquà un certain point ( matérialisé par un. ) : A ::= A ::= Le second conflit est de type REDUCE – REDUCE.Le second conflit est de type REDUCE – REDUCE. Létat courant correspond aux deux règles suivantes :Létat courant correspond aux deux règles suivantes : A ::= X --- X. et B ::= X --- X. A ::= X --- X. et B ::= X --- X. 1 k 1 k 12345

57 9 octobre 2007Cours de compilation 5 - Intranet57 V A R I A N T E S D A N A L Y S E S A S C E N D A N T E S

58 9 octobre 2007Cours de compilation 5 - Intranet58 Les différentes analyses ascendantes ---------------------------------------------------------------- Lanalyse classique est lanalyse LR ( 1 ) qui utilise un caractère de look-ahead !Lanalyse classique est lanalyse LR ( 1 ) qui utilise un caractère de look-ahead !

59 9 octobre 2007Cours de compilation 5 - Intranet59 Les différentes analyses ascendantes ---------------------------------------------------------------- Lanalyse classique est lanalyse LR ( 1 ) qui utilise un caractère de look-ahead !Lanalyse classique est lanalyse LR ( 1 ) qui utilise un caractère de look-ahead ! Nous pouvons définir des analyses LR ( k ) avec k > 1 !Nous pouvons définir des analyses LR ( k ) avec k > 1 !

60 9 octobre 2007Cours de compilation 5 - Intranet60 Les différentes analyses ascendantes ---------------------------------------------------------------- Lanalyse classique est lanalyse LR ( 1 ) qui utilise un caractère de look-ahead !Lanalyse classique est lanalyse LR ( 1 ) qui utilise un caractère de look-ahead ! Nous pouvons définir des analyses LR ( k ) avec k > 1 !Nous pouvons définir des analyses LR ( k ) avec k > 1 ! Théorème : Pour toute grammaire G qui est analysable par LR ( k ) avec k > 1, il existe une grammaire G qui est analysable par LR ( 1 ) et reconnaît le même langage !Théorème : Pour toute grammaire G qui est analysable par LR ( k ) avec k > 1, il existe une grammaire G qui est analysable par LR ( 1 ) et reconnaît le même langage !

61 9 octobre 2007Cours de compilation 5 - Intranet61 Les différentes analyses ascendantes ---------------------------------------------------------------- Lanalyse classique est lanalyse LR ( 1 ) qui utilise un caractère de look-ahead !Lanalyse classique est lanalyse LR ( 1 ) qui utilise un caractère de look-ahead ! Nous pouvons définir des analyses LR ( k ) avec k > 1 !Nous pouvons définir des analyses LR ( k ) avec k > 1 ! Théorème : Pour toute grammaire G qui est analysable par LR ( k ) avec k > 1, il existe une grammaire G qui est analysable par LR ( 1 ) et reconnaît le même langage !Théorème : Pour toute grammaire G qui est analysable par LR ( k ) avec k > 1, il existe une grammaire G qui est analysable par LR ( 1 ) et reconnaît le même langage ! Lanalyse LALR utilise des tables plus compactes que lanalyse LR en fusionnant des états qui entraînent le même traitement !Lanalyse LALR utilise des tables plus compactes que lanalyse LR en fusionnant des états qui entraînent le même traitement !

62 9 octobre 2007Cours de compilation 5 - Intranet62 Les différentes analyses ascendantes ---------------------------------------------------------------- Lanalyse classique est lanalyse LR ( 1 ) qui utilise un caractère de look-ahead !Lanalyse classique est lanalyse LR ( 1 ) qui utilise un caractère de look-ahead ! Nous pouvons définir des analyses LR ( k ) avec k > 1 !Nous pouvons définir des analyses LR ( k ) avec k > 1 ! Théorème : Pour toute grammaire G qui est analysable par LR ( k ) avec k > 1, il existe une grammaire G qui est analysable par LR ( 1 ) et reconnaît le même langage !Théorème : Pour toute grammaire G qui est analysable par LR ( k ) avec k > 1, il existe une grammaire G qui est analysable par LR ( 1 ) et reconnaît le même langage ! Lanalyse LALR utilise des tables plus compactes que lanalyse LR en fusionnant des états qui entraînent le même traitement !Lanalyse LALR utilise des tables plus compactes que lanalyse LR en fusionnant des états qui entraînent le même traitement ! « yacc » et « bison » sont LALR !« yacc » et « bison » sont LALR !

63 9 octobre 2007Cours de compilation 5 - Intranet63 Les différentes analyses ascendantes ---------------------------------------------------------------- Lanalyse classique est lanalyse LR ( 1 ) qui utilise un caractère de look-ahead !Lanalyse classique est lanalyse LR ( 1 ) qui utilise un caractère de look-ahead ! Nous pouvons définir des analyses LR ( k ) avec k > 1 !Nous pouvons définir des analyses LR ( k ) avec k > 1 ! Théorème : Pour toute grammaire G qui est analysable par LR ( k ) avec k > 1, il existe une grammaire G qui est analysable par LR ( 1 ) et reconnaît le même langage !Théorème : Pour toute grammaire G qui est analysable par LR ( k ) avec k > 1, il existe une grammaire G qui est analysable par LR ( 1 ) et reconnaît le même langage ! Lanalyse LALR utilise des tables plus compactes que lanalyse LR en fusionnant des états qui entraînent le même traitement !Lanalyse LALR utilise des tables plus compactes que lanalyse LR en fusionnant des états qui entraînent le même traitement ! « yacc » et « bison » sont LALR !« yacc » et « bison » sont LALR ! Lanalyse SLR est la plus simple, mais elle est souvent inintéressante, car pas assez puissante !Lanalyse SLR est la plus simple, mais elle est souvent inintéressante, car pas assez puissante !

64 9 octobre 2007Cours de compilation 5 - Intranet64 L E S T A B L E S D A N A L Y S E L R ( 1 )

65 9 octobre 2007Cours de compilation 5 - Intranet65 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Nous partons dune grammaire G dite augmentée par ladjonction de la règle S ::= S qui fournit un nouvel axiome S.Nous partons dune grammaire G dite augmentée par ladjonction de la règle S ::= S qui fournit un nouvel axiome S.

66 9 octobre 2007Cours de compilation 5 - Intranet66 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Nous partons dune grammaire G dite augmentée par ladjonction de la règle S ::= S qui fournit un nouvel axiome S.Nous partons dune grammaire G dite augmentée par ladjonction de la règle S ::= S qui fournit un nouvel axiome S. Chaque état correspond à un ensemble dentités.Chaque état correspond à un ensemble dentités.

67 9 octobre 2007Cours de compilation 5 - Intranet67 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Nous partons dune grammaire G dite augmentée par ladjonction de la règle S ::= S qui fournit un nouvel axiome S.Nous partons dune grammaire G dite augmentée par ladjonction de la règle S ::= S qui fournit un nouvel axiome S. Chaque état correspond à un ensemble dentités.Chaque état correspond à un ensemble dentités. Une entité est une règle partiellement analysée accompagnée dun terminal a :Une entité est une règle partiellement analysée accompagnée dun terminal a : [ A ::=. B, a ] [ A ::=. B, a ]

68 9 octobre 2007Cours de compilation 5 - Intranet68 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Nous partons dune grammaire G dite augmentée par ladjonction de la règle S ::= S qui fournit un nouvel axiome S.Nous partons dune grammaire G dite augmentée par ladjonction de la règle S ::= S qui fournit un nouvel axiome S. Chaque état correspond à un ensemble dentités.Chaque état correspond à un ensemble dentités. Une entité est une règle partiellement analysée accompagnée dun terminal a :Une entité est une règle partiellement analysée accompagnée dun terminal a : [ A ::=. B, a ] [ A ::=. B, a ] La règle a été reconnue sur son préfixe alors que la suite doit encore être reconnue.La règle a été reconnue sur son préfixe alors que la suite doit encore être reconnue.

69 9 octobre 2007Cours de compilation 5 - Intranet69 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Nous partons dune grammaire G dite augmentée par ladjonction de la règle S ::= S qui fournit un nouvel axiome S.Nous partons dune grammaire G dite augmentée par ladjonction de la règle S ::= S qui fournit un nouvel axiome S. Chaque état correspond à un ensemble dentités.Chaque état correspond à un ensemble dentités. Une entité est une règle partiellement analysée accompagnée dun terminal a :Une entité est une règle partiellement analysée accompagnée dun terminal a : [ A ::=. B, a ] [ A ::=. B, a ] La règle a été reconnue sur son préfixe alors que la suite doit encore être reconnue.La règle a été reconnue sur son préfixe alors que la suite doit encore être reconnue. Le terminal a est un lexème qui pourra apparaître dans le flux au moment où B sera réduit en A !Le terminal a est un lexème qui pourra apparaître dans le flux au moment où B sera réduit en A !

70 9 octobre 2007Cours de compilation 5 - Intranet70 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Les ensembles dentités EE doivent être clos par lopération de fermeture !Les ensembles dentités EE doivent être clos par lopération de fermeture !

71 9 octobre 2007Cours de compilation 5 - Intranet71 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Les ensembles dentités EE doivent être clos par lopération de fermeture !Les ensembles dentités EE doivent être clos par lopération de fermeture ! fermeture ( EE ) est défini comme suit :fermeture ( EE ) est défini comme suit : tant que nous pouvons ajouter des entités tant que nous pouvons ajouter des entités

72 9 octobre 2007Cours de compilation 5 - Intranet72 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Les ensembles dentités EE doivent être clos par lopération de fermeture !Les ensembles dentités EE doivent être clos par lopération de fermeture ! fermeture ( EE ) est défini comme suit :fermeture ( EE ) est défini comme suit : tant que nous pouvons ajouter des entités tant que nous pouvons ajouter des entités pour toute entité [ A ::=. B, a ] de EE pour toute entité [ A ::=. B, a ] de EE

73 9 octobre 2007Cours de compilation 5 - Intranet73 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Les ensembles dentités EE doivent être clos par lopération de fermeture !Les ensembles dentités EE doivent être clos par lopération de fermeture ! fermeture ( EE ) est défini comme suit :fermeture ( EE ) est défini comme suit : tant que nous pouvons ajouter des entités tant que nous pouvons ajouter des entités pour toute entité [ A ::=. B, a ] de EE pour toute entité [ A ::=. B, a ] de EE pour toute règle B ::= de G pour toute règle B ::= de G

74 9 octobre 2007Cours de compilation 5 - Intranet74 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Les ensembles dentités EE doivent être clos par lopération de fermeture !Les ensembles dentités EE doivent être clos par lopération de fermeture ! fermeture ( EE ) est défini comme suit :fermeture ( EE ) est défini comme suit : tant que nous pouvons ajouter des entités tant que nous pouvons ajouter des entités pour toute entité [ A ::=. B, a ] de EE pour toute entité [ A ::=. B, a ] de EE pour toute règle B ::= de G pour toute règle B ::= de G pour tout terminal b Prem ( a ) pour tout terminal b Prem ( a )

75 9 octobre 2007Cours de compilation 5 - Intranet75 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Les ensembles dentités EE doivent être clos par lopération de fermeture !Les ensembles dentités EE doivent être clos par lopération de fermeture ! fermeture ( EE ) est défini comme suit :fermeture ( EE ) est défini comme suit : tant que nous pouvons ajouter des entités tant que nous pouvons ajouter des entités pour toute entité [ A ::=. B, a ] de EE pour toute entité [ A ::=. B, a ] de EE pour toute règle B ::= de G pour toute règle B ::= de G pour tout terminal b Prem ( a ) pour tout terminal b Prem ( a ) faire : rajouter [ B ::=., b ] à EE si elle ny faire : rajouter [ B ::=., b ] à EE si elle ny figure pas encore. figure pas encore.

76 9 octobre 2007Cours de compilation 5 - Intranet76 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Les ensembles dentités EE doivent être clos par lopération de fermeture !Les ensembles dentités EE doivent être clos par lopération de fermeture ! fermeture ( EE ) est défini comme suit :fermeture ( EE ) est défini comme suit : tant que nous pouvons ajouter des entités tant que nous pouvons ajouter des entités pour toute entité [ A ::=. B, a ] de EE pour toute entité [ A ::=. B, a ] de EE pour toute règle B ::= de G pour toute règle B ::= de G pour tout terminal b Prem ( a ) pour tout terminal b Prem ( a ) faire : rajouter [ B ::=., b ] à EE si elle ny faire : rajouter [ B ::=., b ] à EE si elle ny figure pas encore. figure pas encore.

77 9 octobre 2007Cours de compilation 5 - Intranet77 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Les ensembles dentités EE doivent être clos par lopération de fermeture !Les ensembles dentités EE doivent être clos par lopération de fermeture ! fermeture ( EE ) est défini comme suit :fermeture ( EE ) est défini comme suit : tant que nous pouvons ajouter des entités tant que nous pouvons ajouter des entités pour toute entité [ A ::=. B, a ] de EE pour toute entité [ A ::=. B, a ] de EE pour toute règle B ::= de G pour toute règle B ::= de G pour tout terminal b Prem ( a ) pour tout terminal b Prem ( a ) faire : rajouter [ B ::=., b ] à EE si elle ny faire : rajouter [ B ::=., b ] à EE si elle ny figure pas encore. figure pas encore.

78 9 octobre 2007Cours de compilation 5 - Intranet78 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Illustration : Soit EE = { [ A ::=. B c, a ] }Illustration : Soit EE = { [ A ::=. B c, a ] }

79 9 octobre 2007Cours de compilation 5 - Intranet79 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Illustration : Soit EE = { [ A ::=. B c, a ] }Illustration : Soit EE = { [ A ::=. B c, a ] } Soient les règles B ::= b | C d et C ::= e !Soient les règles B ::= b | C d et C ::= e !

80 9 octobre 2007Cours de compilation 5 - Intranet80 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Illustration : Soit EE = { [ A ::=. B c, a ] }Illustration : Soit EE = { [ A ::=. B c, a ] } Soient les règles B ::= b | C d et C ::= e !Soient les règles B ::= b | C d et C ::= e ! Successivement, EE devient :Successivement, EE devient : { [ A ::=. B c, a ], [ B ::=. b, c ], [ B ::=. C d, c ] }

81 9 octobre 2007Cours de compilation 5 - Intranet81 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Illustration : Soit EE = { [ A ::=. B c, a ] }Illustration : Soit EE = { [ A ::=. B c, a ] } Soient les règles B ::= b | C d et C ::= e !Soient les règles B ::= b | C d et C ::= e ! Successivement, EE devient :Successivement, EE devient : { [ A ::=. B c, a ], [ B ::=. b, c ], [ B ::=. C d, c ] } et { [ A ::=. B c, a ], [ B ::=. b, c ], [ B ::=. C d, c ], [ C ::=. e, d ] }

82 9 octobre 2007Cours de compilation 5 - Intranet82 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Illustration : Soit EE = { [ A ::=. B c, a ] }Illustration : Soit EE = { [ A ::=. B c, a ] } Soient les règles B ::= b | C d et C ::= e !Soient les règles B ::= b | C d et C ::= e ! Successivement, EE devient :Successivement, EE devient : { [ A ::=. B c, a ], [ B ::=. b, c ], [ B ::=. C d, c ] } et { [ A ::=. B c, a ], [ B ::=. b, c ], [ B ::=. C d, c ], [ C ::=. e, d ] } Ceci revient en fait à faire les réductions suivantes, qui font apparaître des terminaux après le. !Ceci revient en fait à faire les réductions suivantes, qui font apparaître des terminaux après le. !. B c. B c. b c. b c. C d c. C d c. e d c. e d c

83 9 octobre 2007Cours de compilation 5 - Intranet83 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Lopération goto :Lopération goto : Soit EI un ensemble dentités et X un terminal ou un non-terminal :Soit EI un ensemble dentités et X un terminal ou un non-terminal :

84 9 octobre 2007Cours de compilation 5 - Intranet84 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Lopération goto :Lopération goto : Soit EI un ensemble dentités et X un terminal ou un non-terminal :Soit EI un ensemble dentités et X un terminal ou un non-terminal : goto ( EI, X ) = goto ( EI, X ) = soit EJ lensemble des entités [ A ::= X., a ] soit EJ lensemble des entités [ A ::= X., a ] telles que [ A ::=. X, a ] est dans EI telles que [ A ::=. X, a ] est dans EI alors rendre fermeture ( EJ ) alors rendre fermeture ( EJ )

85 9 octobre 2007Cours de compilation 5 - Intranet85 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Lopération goto :Lopération goto : Soit EI un ensemble dentités et X un terminal ou un non-terminal :Soit EI un ensemble dentités et X un terminal ou un non-terminal : goto ( EI, X ) = goto ( EI, X ) = soit EJ lensemble des entités [ A ::= X., a ] soit EJ lensemble des entités [ A ::= X., a ] telles que [ A ::=. X, a ] est dans EI telles que [ A ::=. X, a ] est dans EI alors rendre fermeture ( EJ ) alors rendre fermeture ( EJ ) Nous déterminons, par rapport à létat courant, quel sera létat atteint lorsque nous aurons reconnu X !

86 9 octobre 2007Cours de compilation 5 - Intranet86 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Lopération tous_EE construite pour la grammaire G :Lopération tous_EE construite pour la grammaire G : tous_EE ( G ) =

87 9 octobre 2007Cours de compilation 5 - Intranet87 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Lopération tous_EE construite pour la grammaire G :Lopération tous_EE construite pour la grammaire G : tous_EE ( G ) = C < - { fermeture ( { [ S ::=. S, # ] } ) } C < - { fermeture ( { [ S ::=. S, # ] } ) }

88 9 octobre 2007Cours de compilation 5 - Intranet88 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Lopération tous_EE construite pour la grammaire G :Lopération tous_EE construite pour la grammaire G : tous_EE ( G ) = C < - { fermeture ( { [ S ::=. S, # ] } ) } C < - { fermeture ( { [ S ::=. S, # ] } ) } tant que nous pouvons rajouter des ensembles dentités à C tant que nous pouvons rajouter des ensembles dentités à C

89 9 octobre 2007Cours de compilation 5 - Intranet89 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Lopération tous_EE construite pour la grammaire G :Lopération tous_EE construite pour la grammaire G : tous_EE ( G ) = C < - { fermeture ( { [ S ::=. S, # ] } ) } C < - { fermeture ( { [ S ::=. S, # ] } ) } tant que nous pouvons rajouter des ensembles dentités à C tant que nous pouvons rajouter des ensembles dentités à C pour tout ensemble EE de C et tout symbole X pour tout ensemble EE de C et tout symbole X

90 9 octobre 2007Cours de compilation 5 - Intranet90 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Lopération tous_EE construite pour la grammaire G :Lopération tous_EE construite pour la grammaire G : tous_EE ( G ) = C < - { fermeture ( { [ S ::=. S, # ] } ) } C < - { fermeture ( { [ S ::=. S, # ] } ) } tant que nous pouvons rajouter des ensembles dentités à C tant que nous pouvons rajouter des ensembles dentités à C pour tout ensemble EE de C et tout symbole X pour tout ensemble EE de C et tout symbole X si goto ( EE, X ) nest pas vide si goto ( EE, X ) nest pas vide

91 9 octobre 2007Cours de compilation 5 - Intranet91 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Lopération tous_EE construite pour la grammaire G :Lopération tous_EE construite pour la grammaire G : tous_EE ( G ) = C < - { fermeture ( { [ S ::=. S, # ] } ) } C < - { fermeture ( { [ S ::=. S, # ] } ) } tant que nous pouvons rajouter des ensembles dentités à C tant que nous pouvons rajouter des ensembles dentités à C pour tout ensemble EE de C et tout symbole X pour tout ensemble EE de C et tout symbole X si goto ( EE, X ) nest pas vide si goto ( EE, X ) nest pas vide faire : rajouter goto ( EE, X ) à C sil ny figure pas faire : rajouter goto ( EE, X ) à C sil ny figure pas encore ! encore !

92 9 octobre 2007Cours de compilation 5 - Intranet92 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Lopération tous_EE construite pour la grammaire G :Lopération tous_EE construite pour la grammaire G : tous_EE ( G ) = C < - { fermeture ( { [ S ::=. S, # ] } ) } C < - { fermeture ( { [ S ::=. S, # ] } ) } tant que nous pouvons rajouter des ensembles dentités à C tant que nous pouvons rajouter des ensembles dentités à C pour tout ensemble EE de C et tout symbole X pour tout ensemble EE de C et tout symbole X si goto ( EE, X ) nest pas vide si goto ( EE, X ) nest pas vide faire : rajouter goto ( EE, X ) à C sil ny figure pas faire : rajouter goto ( EE, X ) à C sil ny figure pas encore ! encore ! Nous calculons tous les états atteignables à partir de C !

93 9 octobre 2007Cours de compilation 5 - Intranet93 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Les ACTIONS et SUCC sont définies comme suit !Les ACTIONS et SUCC sont définies comme suit !

94 9 octobre 2007Cours de compilation 5 - Intranet94 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Les ACTIONS et SUCC sont définies comme suit !Les ACTIONS et SUCC sont définies comme suit ! Soit C = { EE,..., EE } la collection des ensemblesSoit C = { EE,..., EE } la collection des ensembles dentités calculée par lopération tous_EE ! dentités calculée par lopération tous_EE ! 1n

95 9 octobre 2007Cours de compilation 5 - Intranet95 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Les ACTIONS et SUCC sont définies comme suit !Les ACTIONS et SUCC sont définies comme suit ! Soit C = { EE,..., EE } la collection des ensemblesSoit C = { EE,..., EE } la collection des ensembles dentités calculée par lopération tous_EE ! dentités calculée par lopération tous_EE ! Létat i de lanalyseur est construit à partir de EE comme :Létat i de lanalyseur est construit à partir de EE comme : 1n i

96 9 octobre 2007Cours de compilation 5 - Intranet96 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Les ACTIONS et SUCC sont définies comme suit !Les ACTIONS et SUCC sont définies comme suit ! Soit C = { EE,..., EE } la collection des ensemblesSoit C = { EE,..., EE } la collection des ensembles dentités calculée par lopération tous_EE ! dentités calculée par lopération tous_EE ! Létat i de lanalyseur est construit à partir de EE comme :Létat i de lanalyseur est construit à partir de EE comme : –Si [ A ::=. a, b ] EE et goto ( EE, a ) = EE alors ACTIONS ( i, a ) = SHIFT j ! alors ACTIONS ( i, a ) = SHIFT j ! 1n i iij

97 9 octobre 2007Cours de compilation 5 - Intranet97 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Les ACTIONS et SUCC sont définies comme suit !Les ACTIONS et SUCC sont définies comme suit ! Soit C = { EE,..., EE } la collection des ensemblesSoit C = { EE,..., EE } la collection des ensembles dentités calculée par lopération tous_EE ! dentités calculée par lopération tous_EE ! Létat i de lanalyseur est construit à partir de EE comme :Létat i de lanalyseur est construit à partir de EE comme : –Si [ A ::=. a, b ] EE et goto ( EE, a ) = EE alors ACTIONS ( i, a ) = SHIFT j ! alors ACTIONS ( i, a ) = SHIFT j ! –Si [ A ::=., b ] EE et A <> S alors ACTIONS ( i, b ) = REDUCE A ::= ! alors ACTIONS ( i, b ) = REDUCE A ::= ! 1n i iij i

98 9 octobre 2007Cours de compilation 5 - Intranet98 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Les ACTIONS et SUCC sont définies comme suit !Les ACTIONS et SUCC sont définies comme suit ! Soit C = { EE,..., EE } la collection des ensemblesSoit C = { EE,..., EE } la collection des ensembles dentités calculée par lopération tous_EE ! dentités calculée par lopération tous_EE ! Létat i de lanalyseur est construit à partir de EE comme :Létat i de lanalyseur est construit à partir de EE comme : –Si [ A ::=. a, b ] EE et goto ( EE, a ) = EE alors ACTIONS ( i, a ) = SHIFT j ! alors ACTIONS ( i, a ) = SHIFT j ! –Si [ A ::=., b ] EE et A <> S alors ACTIONS ( i, b ) = REDUCE A ::= ! alors ACTIONS ( i, b ) = REDUCE A ::= ! –Si [ S ::= S., # ] EE alors ACTIONS ( i, # ) = ACCEPT ! alors ACTIONS ( i, # ) = ACCEPT ! 1n i iij i i

99 9 octobre 2007Cours de compilation 5 - Intranet99 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Les ACTIONS et SUCC sont définies comme suit !Les ACTIONS et SUCC sont définies comme suit ! Soit C = { EE,..., EE } la collection des ensemblesSoit C = { EE,..., EE } la collection des ensembles dentités calculée par lopération tous_EE ! dentités calculée par lopération tous_EE ! Létat i de lanalyseur est construit à partir de EE comme :Létat i de lanalyseur est construit à partir de EE comme : –Si goto ( EE, A ) = EE, alors SUCC ( i, A ) = j ! ij 1n i

100 9 octobre 2007Cours de compilation 5 - Intranet100 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Les ACTIONS et SUCC sont définies comme suit !Les ACTIONS et SUCC sont définies comme suit ! Soit C = { EE,..., EE } la collection des ensemblesSoit C = { EE,..., EE } la collection des ensembles dentités calculée par lopération tous_EE ! dentités calculée par lopération tous_EE ! Létat i de lanalyseur est construit à partir de EE comme :Létat i de lanalyseur est construit à partir de EE comme : –Si goto ( EE, A ) = EE, alors SUCC ( i, A ) = j ! –Toute entrée non définie par une des règles ci-dessus est une erreur ! une erreur ! ij 1n i

101 9 octobre 2007Cours de compilation 5 - Intranet101 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Les ACTIONS et SUCC sont définies comme suit !Les ACTIONS et SUCC sont définies comme suit ! Soit C = { EE,..., EE } la collection des ensemblesSoit C = { EE,..., EE } la collection des ensembles dentités calculée par lopération tous_EE ! dentités calculée par lopération tous_EE ! Létat i de lanalyseur est construit à partir de EE comme :Létat i de lanalyseur est construit à partir de EE comme : –Si goto ( EE, A ) = EE, alors SUCC ( i, A ) = j ! –Toute entrée non définie par une des règles ci-dessus est une erreur ! une erreur ! –Létat initial est celui qui comprend dentité de démarrage [ S ::=. S, # ] ! [ S ::=. S, # ] ! ij 1n i

102 9 octobre 2007Cours de compilation 5 - Intranet102 Les tables danalyse LR ( 1 ) ---------------------------------------------------------------- Les ACTIONS et SUCC sont définies comme suit !Les ACTIONS et SUCC sont définies comme suit ! Soit C = { EE,..., EE } la collection des ensemblesSoit C = { EE,..., EE } la collection des ensembles dentités calculée par lopération tous_EE ! dentités calculée par lopération tous_EE ! Létat i de lanalyseur est construit à partir de EE comme :Létat i de lanalyseur est construit à partir de EE comme : –Si goto ( EE, A ) = EE, alors SUCC ( i, A ) = j ! –Toute entrée non définie par une des règles ci-dessus est une erreur ! une erreur ! –Létat initial est celui qui comprend dentité de démarrage [ S ::=. S, # ] ! [ S ::=. S, # ] ! ij 1n i

103 9 octobre 2007Cours de compilation 5 - Intranet103 C O N C R E T E M E N T Y A C C E T B I S O N

104 9 octobre 2007Cours de compilation 5 - Intranet104 YACC et BISON ---------------------------------------------------------------- Yet Another Compiler Compiler ( bison son remake ) ! Nous donnons une grammaire !Nous donnons une grammaire !

105 9 octobre 2007Cours de compilation 5 - Intranet105 YACC et BISON ---------------------------------------------------------------- Yet Another Compiler Compiler ( bison son remake ) ! Nous donnons une grammaire !Nous donnons une grammaire ! Nous associons du code aux différentes règles reconnues !Nous associons du code aux différentes règles reconnues !

106 9 octobre 2007Cours de compilation 5 - Intranet106 YACC et BISON ---------------------------------------------------------------- Yet Another Compiler Compiler ( bison son remake ) ! Nous donnons une grammaire !Nous donnons une grammaire ! Nous associons du code aux différentes règles reconnues !Nous associons du code aux différentes règles reconnues ! yacc construit un analyseur LALR qui comporte notre code !yacc construit un analyseur LALR qui comporte notre code !

107 9 octobre 2007Cours de compilation 5 - Intranet107 YACC et BISON ---------------------------------------------------------------- Yet Another Compiler Compiler ( bison son remake ) ! Nous donnons une grammaire !Nous donnons une grammaire ! Nous associons du code aux différentes règles reconnues !Nous associons du code aux différentes règles reconnues ! yacc construit un analyseur LALR qui comporte notre code !yacc construit un analyseur LALR qui comporte notre code ! Nous soumettons ensuite le texte à reconnaître à yacc !Nous soumettons ensuite le texte à reconnaître à yacc !

108 9 octobre 2007Cours de compilation 5 - Intranet108 YACC et BISON ---------------------------------------------------------------- Yet Another Compiler Compiler ( bison son remake ) ! Nous donnons une grammaire !Nous donnons une grammaire ! Nous associons du code aux différentes règles reconnues !Nous associons du code aux différentes règles reconnues ! yacc construit un analyseur LALR qui comporte notre code !yacc construit un analyseur LALR qui comporte notre code ! Nous soumettons ensuite le texte à reconnaître à yacc !Nous soumettons ensuite le texte à reconnaître à yacc ! Cette démarche permet de générer rapidement un code assembleur intermédiaire !Cette démarche permet de générer rapidement un code assembleur intermédiaire !

109 9 octobre 2007Cours de compilation 5 - Intranet109 YACC et BISON ---------------------------------------------------------------- Yet Another Compiler Compiler ( bison son remake ) ! Nous donnons une grammaire !Nous donnons une grammaire ! Nous associons du code aux différentes règles reconnues !Nous associons du code aux différentes règles reconnues ! yacc construit un analyseur LALR qui comporte notre code !yacc construit un analyseur LALR qui comporte notre code ! Nous soumettons ensuite le texte à reconnaître à yacc !Nous soumettons ensuite le texte à reconnaître à yacc ! Cette démarche permet de générer rapidement un code assembleur intermédiaire !Cette démarche permet de générer rapidement un code assembleur intermédiaire ! Loptimisation de ce code est faite en dehors de yacc !Loptimisation de ce code est faite en dehors de yacc !

110 9 octobre 2007Cours de compilation 5 - Intranet110 U N E X E M P L E P A R T I E L

111 9 octobre 2007Cours de compilation 5 - Intranet111 Un exemple partiel ---------------------------------------------------------------- Soit la grammaire : Soit la grammaire : S ::= E E ::= T E E ::= + E | E ::= + E | T ::= F T T ::= * T | T ::= * T | F ::= id | (E)

112 9 octobre 2007Cours de compilation 5 - Intranet112 Un exemple partiel ---------------------------------------------------------------- Soit la grammaire : Soit la grammaire : S ::= E E ::= T E E ::= + E | E ::= + E | T ::= F T T ::= * T | T ::= * T | F ::= id | ( E ) Le premier état : Le premier état : F ( { [ S ->. E, # ] } ) =

113 9 octobre 2007Cours de compilation 5 - Intranet113 Un exemple partiel ---------------------------------------------------------------- Soit la grammaire : Soit la grammaire : S ::= E E ::= T E E ::= + E | E ::= + E | T ::= F T T ::= * T | T ::= * T | F ::= id | ( E ) Le premier état : Le premier état : F ( { [ S ->. E, # ] } ) = { [ S ->. E, # ], { [ S ->. E, # ],......

114 9 octobre 2007Cours de compilation 5 - Intranet114 Un exemple partiel ---------------------------------------------------------------- Soit la grammaire : Soit la grammaire : S ::= E E ::= T E E ::= + E | E ::= + E | T ::= F T T ::= * T | T ::= * T | F ::= id | ( E ) Le premier état : Le premier état : F ( { [ S ->. E, # ] } ) = { [ S ->. E, # ], { [ S ->. E, # ], [ E ->. T E, # ], [ E ->. T E, # ],......

115 9 octobre 2007Cours de compilation 5 - Intranet115 Un exemple partiel ---------------------------------------------------------------- Soit la grammaire : Soit la grammaire : S ::= E E ::= T E E ::= + E | E ::= + E | T ::= F T T ::= * T | T ::= * T | F ::= id | ( E ) Le premier état : Le premier état : F ( { [ S ->. E, # ] } ) = { [ S ->. E, # ], { [ S ->. E, # ], [ E ->. T E, # ], [ E ->. T E, # ], [ T ->. F T, + ], [ T ->. F T, + ], [ T ->. F T, # ], [ T ->. F T, # ],......

116 9 octobre 2007Cours de compilation 5 - Intranet116 Un exemple partiel ---------------------------------------------------------------- Soit la grammaire : Soit la grammaire : S ::= E E ::= T E E ::= + E | E ::= + E | T ::= F T T ::= * T | T ::= * T | F ::= id | ( E ) Le premier état : Le premier état : F ( { [ S ->. E, # ] } ) = { [ S ->. E, # ], { [ S ->. E, # ], [ E ->. T E, # ], [ E ->. T E, # ], [ T ->. F T, + ], [ T ->. F T, + ], [ T ->. F T, # ], [ T ->. F T, # ], [ F ->. id, * ], [ F ->. id, * ], [ F ->. id, + ], [ F ->. id, + ], [ F ->. id, # ], [ F ->. id, # ],......

117 9 octobre 2007Cours de compilation 5 - Intranet117 Un exemple partiel ---------------------------------------------------------------- Soit la grammaire : Soit la grammaire : S ::= E E ::= T E E ::= + E | E ::= + E | T ::= F T T ::= * T | T ::= * T | F ::= id | ( E ) Le premier état : Le premier état : F ( { [ S ->. E, # ] } ) = { [ S ->. E, # ], { [ S ->. E, # ], [ E ->. T E, # ], [ E ->. T E, # ], [ T ->. F T, + ], [ T ->. F T, + ], [ T ->. F T, # ], [ T ->. F T, # ], [ F ->. id, * ], [ F ->. id, * ], [ F ->. id, + ], [ F ->. id, + ], [ F ->. id, # ], [ F ->. id, # ], [ F ->. ( E ), * ], [ F ->. ( E ), * ], [ F ->. ( E ), + ], [ F ->. ( E ), + ], [ F ->. ( E ), # ] } [ F ->. ( E ), # ] }

118 9 octobre 2007Cours de compilation 5 - Intranet118 Un exemple partiel ---------------------------------------------------------------- Soit la grammaire : Soit la grammaire : S ::= E E ::= T E E ::= + E | E ::= + E | T ::= F T T ::= * T | T ::= * T | F ::= id | ( E ) Le premier état : Le premier état : F ( { [ S ->. E, # ] } ) = { [ S ->. E, # ], { [ S ->. E, # ], [ E ->. T E, # ], [ E ->. T E, # ], [ T ->. F T, { +, # } ], [ T ->. F T, { +, # } ], [ F ->. id, { *, +, # } ], [ F ->. id, { *, +, # } ], [ F ->. ( E ), { *, +, # } ] } [ F ->. ( E ), { *, +, # } ] } Plus compact :

119 9 octobre 2007Cours de compilation 5 - Intranet119 Un exemple partiel ---------------------------------------------------------------- Soit la grammaire : Soit la grammaire : S ::= E E ::= T E E ::= + E | E ::= + E | T ::= F T T ::= * T | T ::= * T | F ::= id | ( E ) Le premier état : Le premier état : F ( { [ S ->. E, # ] } ) = { [ S ->. E, # ], { [ S ->. E, # ], [ E ->. T E, # ], [ E ->. T E, # ], [ T ->. F T, { +, # } ], [ T ->. F T, { +, # } ], [ F ->. id, { *, +, # } ], [ F ->. id, { *, +, # } ], [ F ->. ( E ), { *, +, # } ] } [ F ->. ( E ), { *, +, # } ] } Plus compact : Maintenant, nous allons calculer les transitions pour E, T, F, id et (.

120 9 octobre 2007Cours de compilation 5 - Intranet120 Un exemple partiel ---------------------------------------------------------------- F ( { [ S -> E., # ] } ) =...... 1 E 2

121 9 octobre 2007Cours de compilation 5 - Intranet121 Un exemple partiel ---------------------------------------------------------------- F ( { [ S -> E., # ] } ) = { [ S -> E., # ] } { [ S -> E., # ] } Cest le second état qui est en fait lacceptation ! 1 E 2

122 9 octobre 2007Cours de compilation 5 - Intranet122 Un exemple partiel ---------------------------------------------------------------- F ( { [ S -> E., # ] } ) = { [ S -> E., # ] } { [ S -> E., # ] } Cest le second état qui est en fait lacceptation ! 1 E 2 T 3 F ( { [ E -> T. E, # ] } ) =......

123 9 octobre 2007Cours de compilation 5 - Intranet123 Un exemple partiel ---------------------------------------------------------------- F ( { [ S -> E., # ] } ) = { [ S -> E., # ] } { [ S -> E., # ] } Cest le second état qui est en fait lacceptation ! 1 E 2 T 3 F ( { [ E -> T. E, # ] } ) = { [ E -> T. E, # ], { [ E -> T. E, # ], [ E ->. + E, # ], [ E ->. + E, # ], [ E ->., # ] } [ E ->., # ] }

124 9 octobre 2007Cours de compilation 5 - Intranet124 Un exemple partiel ---------------------------------------------------------------- F ( { [ S -> E., # ] } ) = { [ S -> E., # ] } { [ S -> E., # ] } Cest le second état qui est en fait lacceptation ! 1 E 2 T 3 F ( { [ E -> T. E, # ] } ) = { [ E -> T. E, # ], { [ E -> T. E, # ], [ E ->. + E, # ], [ E ->. + E, # ], [ E ->., # ] } [ E ->., # ] } F 4 F ( { [ T -> F. T, { +, # } ] } ) =......

125 9 octobre 2007Cours de compilation 5 - Intranet125 Un exemple partiel ---------------------------------------------------------------- F ( { [ S -> E., # ] } ) = { [ S -> E., # ] } { [ S -> E., # ] } Cest le second état qui est en fait lacceptation ! 1 E 2 T 3 F ( { [ E -> T. E, # ] } ) = { [ E -> T. E, # ], { [ E -> T. E, # ], [ E ->. + E, # ], [ E ->. + E, # ], [ E ->., # ] } [ E ->., # ] } F 4 F ( { [ T -> F. T, { +, # } ] } ) = { [ T -> F. T, { +, # } ], { [ T -> F. T, { +, # } ], [ T ->. * T, { +, # } ], [ T ->. * T, { +, # } ], [ T ->., { +, # } ] } [ T ->., { +, # } ] }

126 9 octobre 2007Cours de compilation 5 - Intranet126 Un exemple partiel ---------------------------------------------------------------- F ( { [ F -> id., { *, +, # } ] } ) = { [ F -> id., { *, +, # } ] } { [ F -> id., { *, +, # } ] } 1 id 5...

127 9 octobre 2007Cours de compilation 5 - Intranet127 Un exemple partiel ---------------------------------------------------------------- F ( { [ F -> id., { *, +, # } ] } ) = { [ F -> id., { *, +, # } ] } { [ F -> id., { *, +, # } ] } 1 id 5 ( 6 F ( { [ F -> (. E ), { *, +, # } ] } ) =.........

128 9 octobre 2007Cours de compilation 5 - Intranet128 Un exemple partiel ---------------------------------------------------------------- F ( { [ F -> id., { *, +, # } ] } ) = { [ F -> id., { *, +, # } ] } { [ F -> id., { *, +, # } ] } 1 id 5 ( 6 F ( { [ F -> (. E ), { *, +, # } ] } ) = { [ F -> (. E ), { *, +, # } ], { [ F -> (. E ), { *, +, # } ], [ E ->. T E, ) ], [ E ->. T E, ) ], [ T ->. F T, { +, ) } ], [ T ->. F T, { +, ) } ], [ F ->. id, { *, +, ) } ], [ F ->. id, { *, +, ) } ], [ F ->. ( E ), { *, +, ) } ] } [ F ->. ( E ), { *, +, ) } ] }...

129 9 octobre 2007Cours de compilation 5 - Intranet129 Un exemple partiel ---------------------------------------------------------------- F ( { [ F -> id., { *, +, # } ] } ) = { [ F -> id., { *, +, # } ] } { [ F -> id., { *, +, # } ] } 1 id 5 ( 6 F ( { [ F -> (. E ), { *, +, # } ] } ) = { [ F -> (. E ), { *, +, # } ], { [ F -> (. E ), { *, +, # } ], [ E ->. T E, ) ], [ E ->. T E, ) ], [ T ->. F T, { +, ) } ], [ T ->. F T, { +, ) } ], [ F ->. id, { *, +, ) } ], [ F ->. id, { *, +, ) } ], [ F ->. ( E ), { *, +, ) } ] } [ F ->. ( E ), { *, +, ) } ] }... Et, nous faisons le même travail pour les nouveaux états 2 à 6 !

130 9 octobre 2007Cours de compilation 5 - Intranet130 Un exemple partiel ---------------------------------------------------------------- 1 ACTIONS (, id ) = SHIFT ( ) 5 Quelques règles :

131 9 octobre 2007Cours de compilation 5 - Intranet131 Un exemple partiel ---------------------------------------------------------------- 1 ACTIONS (, id ) = SHIFT ( ) 5 Quelques règles : 1 ACTIONS (, ( ) = SHIFT ( ) 6

132 9 octobre 2007Cours de compilation 5 - Intranet132 ACTIONS (, # ) = ACCEPT ACTIONS (, # ) = ACCEPT Un exemple partiel ---------------------------------------------------------------- 1 ACTIONS (, id ) = SHIFT ( ) 5 Quelques règles : 1 ACTIONS (, ( ) = SHIFT ( ) 6 2

133 9 octobre 2007Cours de compilation 5 - Intranet133 ACTIONS (, # ) = ACCEPT ACTIONS (, # ) = ACCEPT Un exemple partiel ---------------------------------------------------------------- 1 ACTIONS (, id ) = SHIFT ( ) 5 Quelques règles : 1 ACTIONS (, ( ) = SHIFT ( ) 6 2 ACTIONS (, + ) = REDUCE ( F -> id. ) ACTIONS (, + ) = REDUCE ( F -> id. ) 5

134 9 octobre 2007Cours de compilation 5 - Intranet134 Résumé ---------------------------------------------------------------- Techniques danalyse ascendantes Techniques danalyse ascendantes

135 9 octobre 2007Cours de compilation 5 - Intranet135 C e S t L a F i N ! ! ! b O n N e J o U r N é E ! ! !