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

9 octobre 2007 Cours de compilation 5 - Intranet 1

Cours de compilationCours de compilation

Techniques d’analyseTechniques d’analyseascendantesascendantes

Les grandes lignes du coursLes grandes lignes du cours

•Définitions de baseDéfinitions de base•Composition de compilateursComposition de compilateurs•L’environnement d’un compilateurL’environnement d’un compilateur•Evaluation partielle et compilationEvaluation partielle et compilation•Analyses lexicales et syntaxiquesAnalyses lexicales et syntaxiques•Techniques d’analyse descendantesTechniques d’analyse descendantes•Techniques d’analyse ascendantesTechniques d’analyse ascendantes•YACCYACC•Analyse sémantiqueAnalyse sémantique•Environnement d’exécutionEnvironnement d’exécution•Génération de codeGénération de code•Optimisation de codeOptimisation de code

U N EU N E

G R A M M A I R EG R A M M A I R E

N O N N O N

L L ( K )L L ( K )

Une grammaire non LL ( k )Une grammaire non LL ( k )----------------------------------------------------------------------------------------------------------------------------

----• En TD, nous avons démontré que la grammaire des En TD, nous avons démontré que la grammaire des

expressions arithmétiques ci-dessous à gauche est LL expressions arithmétiques ci-dessous à gauche est LL ( 1 ) :( 1 ) :

A ::= T E’ A ::= T E’

E’ ::= + T E’ | E’ ::= + T E’ |

T ::= F T’ T ::= F T’

T’ ::= * F T’ | T’ ::= * F T’ |

F ::= id | ( A ) F ::= id | ( A )

• Il en est de même pour la grammaire ci-dessous à droite Il en est de même pour la grammaire ci-dessous à droite qui est celles des expressions logiques :qui est celles des expressions logiques :

A ::= T E’ A ::= T E’ L ::= D H’L ::= D H’E’ ::= + T E’ | E’ ::= + T E’ | H’ ::= v D H’ | H’ ::= v D H’ | T ::= F T’ T ::= F T’ D ::= C I’D ::= C I’T’ ::= * F T’ | T’ ::= * F T’ | I’ ::= C I’ | I’ ::= C I’ | F ::= id | ( A ) F ::= id | ( A ) C ::= id | ( E ) C ::= id | ( E )

• En combinant les expressions arithmétiques et logiques, En combinant les expressions arithmétiques et logiques, nous ne sommes plus LL ( k ) pour aucun k :nous ne sommes plus LL ( k ) pour aucun k :

A ::= T E’ A ::= T E’ L ::= D H’L ::= D H’

E’ ::= + T E’ | E’ ::= + T E’ | H’ ::= v D H’ | H’ ::= v D H’ | T ::= F T’ T ::= F T’ D ::= C I’D ::= C I’

T’ ::= * F T’ | T’ ::= * F T’ | I’ ::= C I’ | I’ ::= C I’ | F ::= id | ( A ) F ::= id | ( A ) C ::= id | ( E ) C ::= id | ( E )

| A = A| A = A

• En combinant les expressions arithmétiques et logiques, En combinant les expressions arithmétiques et logiques, nous ne sommes plus LL ( k ) pour aucun k :nous ne sommes plus LL ( k ) pour aucun k :

A ::= T E’ A ::= T E’ L ::= D H’L ::= D H’

E’ ::= + T E’ | E’ ::= + T E’ | H’ ::= v D H’ | H’ ::= v D H’ | T ::= F T’ T ::= F T’ D ::= C I’D ::= C I’

T’ ::= * F T’ | T’ ::= * F T’ | I’ ::= C I’ | I’ ::= C I’ | F ::= id | ( A ) F ::= id | ( A ) C ::= id | ( E ) C ::= id | ( E )

| A = A| A = A

----• Il y a problème pour la règleIl y a problème pour la règle

C ::= id | ( E ) | A = AC ::= id | ( E ) | A = A

car car (( Prem (Prem ( ( E )( E ) ) v Prem () v Prem ( A = AA = A ))

C ::= id | ( E ) | A = AC ::= id | ( E ) | A = A

• Il y a des parenthèses arithmétiques et des Il y a des parenthèses arithmétiques et des parenthèses logiques :parenthèses logiques :

(( (( A A ++ B B )) = C = C vv . . . . . . ))

C ::= id | ( E ) | A = AC ::= id | ( E ) | A = A

(( (( A A ++ B B )) = C = C vv . . . . . . ))

C ::= id | ( E ) | A = AC ::= id | ( E ) | A = A

(( (( A A ++ B B )) = C = C vv . . . . . . ))

C ::= id | ( E ) | A = AC ::= id | ( E ) | A = A

(( (( A A ++ B B )) = C = C vv . . . . . . ))

• Il peut y avoir plus que k parenthèses ouvrantes, Il peut y avoir plus que k parenthèses ouvrantes, quelle que soit la valeur de k !quelle que soit la valeur de k !

C ::= id | ( E ) | A = AC ::= id | ( E ) | A = A

(( (( A A ++ B B )) = C = C vv . . . . . . ))

• Il peut y avoir plus que k parenthèses ouvrantes, Il peut y avoir plus que k parenthèses ouvrantes, quelle que soit la valeur de k !quelle que soit la valeur de k !

R E C U P E R A T I O NR E C U P E R A T I O N

S U RS U R

E R R E U R E R R E U R

Récupération sur erreurRécupération sur erreur----------------------------------------------------------------------------------------------------------------------------

----• Soit :Soit :

InstInst

M_gaucheM_gauche == ExprExpr

InstInst

Ou reprendre ?Ou reprendre ?

Comment interpréter ?Comment interpréter ?

InstInst

. . . [ . . . ( 5 . . . [ . . . ( 5 ++-- . . . . . .

InstInst

. . . [ . . . . . . [ . . . (( 5 5 ++-- . . . . . . )) . . . . . .

InstInst

Cherchez la parenthèse fermante ! Si elle existe ! ! !Cherchez la parenthèse fermante ! Si elle existe ! ! !

. . . . . . [[ . . . . . . (( 5 5 ++-- . . . . . . . . . . . . ]] . . . . . .

InstInst

Cherchez le crochet fermant ! S’il existe ! ! !Cherchez le crochet fermant ! S’il existe ! ! !

. . . . . . [[ . . . . . . (( 5 5 ++-- . . . . . . . . . . . . . . . . . . ;;

InstInst

Cherchez le point virgule ! S’il existe ! ! !Cherchez le point virgule ! S’il existe ! ! !

----• 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 à considérer les différentes constructions démarrées, mais non terminées ( par exemple : démarrées, mais non terminées ( par exemple : une expression dans un indexage d’une une expression dans un indexage d’une instruction, d’une fonction ) ,instruction, d’une fonction ) ,

– à déterminer les « lexèmes suivants » de ces à déterminer les « lexèmes suivants » de ces différentes constructions etdifférentes constructions et

– à reprendre l’analyse après le premier tel lexème à reprendre l’analyse après le premier tel lexème que nous rencontrons !que nous rencontrons !

• Dans la table d’analyse nous pouvons indiquer les Dans la table d’analyse nous pouvons indiquer les « suivants » souhaités en cas de problème !« suivants » souhaités en cas de problème !

S T R U C T U R ES T R U C T U R E

D ‘ U ND ‘ U N

A N A L Y S E U RA N A L Y S E U R

A S C E N D A N T A S C E N D A N T

L’analyseur ascendantL’analyseur ascendant----------------------------------------------------------------------------------------------------------------------------

----• Une vue d’ensemble :Une vue d’ensemble :

ProgrammeProgramme

w =w = aa ii ##. . .. . . . . .. . .

ProgrammeProgramme

w =w = aa ii ##. . .. . . . . .. . .

. . .. . .

ProgrammeProgramme

w =w = aa ii ##. . .. . . . . .. . .

. . .. . .

x x N v V N v V

s s ETATS ETATSii

ProgrammeProgramme

w =w = aa ii ##. . .. . . . . .. . .

. . .. . .

x x N v V N v V

s s ETATS ETATSii

ACTIONS SUCCACTIONS SUCC

ProgrammeProgramme

w =w = aa ii ##. . .. . . . . .. . .

. . .. . .

x x N v V N v V

s s ETATS ETATSii

ACTIONS SUCCACTIONS SUCC

ACTIONS ( s , a )ACTIONS ( s , a )

SUCC ( s , A )SUCC ( s , A )

----• Une autre vue de l’état de la machine :Une autre vue de l’état de la machine :

( s x s . . . x s , a . . . # )( s x s . . . x s , a . . . # )00 11 11 mm mm ii

La pile !La pile ! Le mot !Le mot !

• Il y a quatre types d’actions :Il y a quatre types d’actions :

– Décaler ( SHIFT ) avec un état s !Décaler ( SHIFT ) avec un état s !

– Réduire ( REDUCE ) avec une règle B ::= Réduire ( REDUCE ) avec une règle B ::= ! !

– Accepter ( ACCEPT ) !Accepter ( ACCEPT ) !

– Erreur ( ERROR ) !Erreur ( ERROR ) !

( s x s . . . x s , a . . . # )( s x s . . . x s , a . . . # )

Evidentes !Evidentes !

00 11 11 mm mm ii

• Regardons en détail le SHIFT et le REDUCE !Regardons en détail le SHIFT et le REDUCE !

• Le SHIFT :Le SHIFT :

– Si ACTIONS ( s , a ) = SHIFT s :Si ACTIONS ( s , a ) = SHIFT s :

– alors nous engrangeons le lexème a etalors nous engrangeons le lexème a et

– nous empilons aussi l’état s qui est nous empilons aussi l’état s qui est caractéristique de toute la séquence x . . . x a caractéristique de toute la séquence x . . . x a ! !

ii11 mm

( s x s . . . x s , a . . . # )( s x s . . . x s , a . . . # )

( s x s . . . x s ( s x s . . . x s a sa s , a . . . # ) , a . . . # )

00 11 11 mm mm ii

ii11 mm

00 11 11 mm mm ii i+1i+1

( s x s . . . x s , a . . . # )( s x s . . . x s , a . . . # )

ii11 mm

( s x s . . . x s ( s x s . . . x s a sa s , a . . . # ) , a . . . # )00 11 11 mm mm ii i+1i+1

00 11 11 mm mm ii

• Le REDUCE :Le REDUCE :

– Si ACTIONS ( s , a ) = REDUCE par A ::= Si ACTIONS ( s , a ) = REDUCE par A ::= . . . . . . : :

mm ii 11 rr

– alors nous avons x . . . x = alors nous avons x . . . x = . . . . . . ! !

mm ii 11 rr

mmm-r+1m-r+1 11 rr

– Nous dépilons ces Nous dépilons ces et leurs états et leurs états correspondants etcorrespondants 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 . . . # )

( s x s . . . x s ( s x s . . . x s A A , a . . . # ) , a . . . # )

00 11 11 mm mm ii

00 11 11 m-rm-r ii

mmm-r+1m-r+1 11 rr

m-rm-r

– Nous dépilons ces Nous dépilons ces et leurs états correspondants et leurs états correspondants etet

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 Le nouvel état est s obtenu grâce à SUCC ( s , A ) !) !

( s x s . . . x s , a . . . # )( s x s . . . x s , a . . . # )

( s x s . . . x s ( s x s . . . x s A sA s , a . . . # ) , a . . . # )00 11 11 m-rm-r ii

mmm-r+1m-r+1 11 rr

m-rm-r

00 11 11 mm mm ii

C O N F L I T SC O N F L I T S

D A N SD A N S

L ‘ A N A L Y S EL ‘ A N A L Y S E

A S C E N D A N T E A S C E N D A N T E

Les conflits de l’analyse ascendanteLes conflits de l’analyse ascendante----------------------------------------------------------------------------------------------------------------------------

----• Toutes les grammaires ne conviennent pas à une Toutes les grammaires ne conviennent pas à une

analyse ascendante, comme pour l’analyse analyse ascendante, comme pour l’analyse descendante.descendante.

• Un état correspond « en gros » au fait qu’une règle Un état correspond « en gros » au fait qu’une règle soit analysée jusqu’à un certain point ( matérialisé soit analysée jusqu’à un certain point ( matérialisé par un . ) :par un . ) :

A ::= A ::=

11 22 33 44 55

A ::= A ::=

• Le premier conflit est de type SHIFT – REDUCE .Le premier conflit est de type SHIFT – REDUCE .

11 22 33 44 55

• Un état correspond « en gros » au fait qu’une règle Un état correspond « en gros » au fait qu’une règle soit analysée jusqu’à un certain point ( matérialisé par soit analysée jusqu’à un certain point ( matérialisé par un . ) :un . ) :

A ::= A ::=

• L’état courant correspond aux deux règles suivantes :L’état courant correspond aux deux règles suivantes :

A ::= X --- X A ::= X --- X . et . et B ::= X --- X B ::= X --- X . . X X --- X --- X

11 22 33 44 55

11 kk 11 kk k+1k+1 nn

A ::= A ::=

11 22 33 44 55

11 kk 11 kk k+1k+1 nn

A ::= A ::=

11 22 33 44 55

11 kk 11 kk k+1k+1 nn

A ::= A ::=

• Le second conflit est de type REDUCE – REDUCE .Le second conflit est de type REDUCE – REDUCE .

11 22 33 44 55

• Un état correspond « en gros » au fait qu’une règle soit Un état correspond « en gros » au fait qu’une règle soit analysée jusqu’à un certain point ( matérialisé par analysée jusqu’à un certain point ( matérialisé par un . ) :un . ) :

A ::= A ::=

A ::= X --- X A ::= X --- X . et . et B ::= X --- X B ::= X --- X . .

11 22 33 44 55

11 kk 11 kk

A ::= A ::=

A ::= X --- X A ::= X --- X . et . et B ::= X --- X B ::= X --- X . .

11 22 33 44 55

11 kk 11 kk

A ::= A ::=

A ::= X --- X A ::= X --- X . et . et B ::= X --- X B ::= X --- X . . 11 kk 11 kk

11 22 33 44 55

V A R I A N T E S V A R I A N T E S

D ‘ A N A L Y S E SD ‘ A N A L Y S E S

A S C E N D A N T E S A S C E N D A N T E S

Les différentes analyses ascendantesLes différentes analyses ascendantes----------------------------------------------------------------------------------------------------------------------------

----• L’analyse classique est l’analyse LR ( 1 ) qui utilise L’analyse classique est l’analyse LR ( 1 ) qui utilise

un caractère de look-ahead !un caractère de look-ahead !

• Nous pouvons définir des analyses LR ( k ) avec k > Nous pouvons définir des analyses LR ( k ) avec k > 1 !1 !

• Théorème : Pour toute grammaire G qui est Théorème : Pour toute grammaire G qui est analysable par LR ( k ) avec k > 1 , il existe une analysable par LR ( k ) avec k > 1 , il existe une grammaire G’ qui est analysable par LR ( 1 ) et grammaire G’ qui est analysable par LR ( 1 ) et reconnaît le même langage ! reconnaît le même langage !

• L’analyse LALR utilise des tables plus compactes L’analyse LALR utilise des tables plus compactes que l’analyse LR en fusionnant des états qui que l’analyse LR en fusionnant des états qui entraînent le même traitement !entraînent le même traitement !

• « yacc » et « bison » sont LALR !« yacc » et « bison » sont LALR !

----• L’analyse classique est l’analyse LR ( 1 ) qui utilise un L’analyse classique est l’analyse LR ( 1 ) qui utilise un

caractère de look-ahead !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 Théorème : Pour toute grammaire G qui est analysable par LR ( k ) avec k > 1 , il existe une grammaire G’ qui par LR ( k ) avec k > 1 , il existe une grammaire G’ qui est analysable par LR ( 1 ) et reconnaît le même est analysable par LR ( 1 ) et reconnaît le même langage ! langage !

• L’analyse LALR utilise des tables plus compactes que L’analyse LALR utilise des tables plus compactes que l’analyse LR en fusionnant des états qui entraînent le l’analyse LR en fusionnant des états qui entraînent le même traitement !même traitement !

• « yacc » et « bison » sont LALR !« yacc » et « bison » sont LALR !

• L’analyse SLR est la plus simple, mais elle est souvent L’analyse SLR est la plus simple, mais elle est souvent inintéressante, car pas assez puissante !inintéressante, car pas assez puissante !

L E SL E S

T A B L E S T A B L E S

D ‘ A N A L Y S ED ‘ A N A L Y S E

L R ( 1 ) L R ( 1 )

Les tables d’analyse LR ( 1 )Les tables d’analyse LR ( 1 )----------------------------------------------------------------------------------------------------------------------------

----• Nous partons d’une grammaire G’ dite augmentée Nous partons d’une grammaire G’ dite augmentée

par l’adjonction de la règle S’ ::= S qui fournit un par l’adjonction de la règle S’ ::= S qui fournit un nouvel axiome S’ .nouvel axiome S’ .

• Chaque état correspond à un ensemble d’entités.Chaque état correspond à un ensemble d’entités.

• Une entité est une règle partiellement analysée Une entité est une règle partiellement analysée accompagnée d’un terminal a :accompagnée d’un terminal a :

[ A ::= [ A ::= . B . B , a ] , a ]

• La règle a été reconnue sur son préfixe La règle a été reconnue sur son préfixe alors que alors que la suite doit encore être reconnue.la suite doit encore être reconnue.

[ A ::= [ A ::= . B . B , a ] , a ]

• La règle a été reconnue sur son préfixe La règle a été reconnue sur son préfixe alors que alors que la suite doit encore être reconnue.la suite doit encore être reconnue.

• Le terminal a est un lexème qui pourra apparaître Le terminal a est un lexème qui pourra apparaître dans le flux au moment où dans le flux au moment où B B sera réduit en A ! sera réduit en A !

----• Les ensembles d’entités EE doivent être clos par Les ensembles d’entités EE doivent être clos par

l’opération de fermeture !l’opération de fermeture !

• fermeture ( EE ) est défini comme suit :fermeture ( EE ) est défini comme suit :

tant que nous pouvons ajouter des entitéstant que nous pouvons ajouter des entités

pour toute entité [ A ::= pour toute entité [ A ::= . B . B , a ] de , a ] de EEEE

pour toute règle B ::= pour toute règle B ::= de G’ de G’

pour tout terminal b pour tout terminal b Prem ( Prem ( a )a )

pour toute entité [ A ::= pour toute entité [ A ::= . B . B , a ] de EE , a ] de EE

faire : rajouter [ B ::= . faire : rajouter [ B ::= . , b ] à EE si elle , b ] à EE si elle n’yn’y

figure pas encore.figure pas encore.

----• Illustration : Soit EE = { [ A ::= Illustration : Soit EE = { [ A ::= . B c , 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 ::= { [ A ::= . B c , a ] , [ B ::= . b , c ] , [ B ::= . C d , . B c , a ] , [ B ::= . b , c ] , [ B ::= . C d , c ] }c ] }

{ [ A ::= { [ A ::= . B c , a ] , [ B ::= . b , c ] , [ B ::= . C d , c ] , . B c , a ] , [ B ::= . b , c ] , [ B ::= . C d , c ] , [ C ::= . e , d ] }[ C ::= . e , d ] }

• Ceci revient en fait à faire les réductions suivantes, qui Ceci revient en fait à faire les réductions suivantes, qui font apparaître des terminaux après le . !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

----• L’opération goto :L’opération goto :

• Soit EI un ensemble d’entités et X un terminal ou Soit EI un ensemble d’entités et X un terminal ou un non-terminal :un non-terminal :

goto ( EI , X ) =goto ( EI , X ) =

soit EJ l’ensemble des entités [ A ::= soit EJ l’ensemble des entités [ A ::= X . X . , , a ]a ]

telles que [ A ::= telles que [ A ::= . X . X , a ] est dans EI , a ] est dans EI

alors rendre fermeture ( EJ )alors rendre fermeture ( EJ )

goto ( EI , X ) =goto ( EI , X ) =

soit EJ l’ensemble des entités [ A ::= soit EJ l’ensemble des entités [ A ::= X . X . , , a ]a ]

telles que [ A ::= telles que [ A ::= . X . X , a ] est dans EI , a ] est dans EI

alors rendre fermeture ( EJ )alors rendre fermeture ( EJ )

Nous déterminons, par rapport à l’état courant, quelNous déterminons, par rapport à l’état courant, quelsera l’état atteint lorsque nous aurons reconnu X !sera l’état atteint lorsque nous aurons reconnu X !

----• L’opération tous_EE construite pour la grammaire G’ :L’opération tous_EE construite pour la grammaire G’ :

tous_EE ( G’ ) = tous_EE ( G’ ) =

C <C <-- { fermeture ( { [ S’ ::= . S , # ] } ) } { fermeture ( { [ S’ ::= . S , # ] } ) }

tant que nous pouvons rajouter des ensembles tant que nous pouvons rajouter des ensembles d’entités à Cd’entités à C

pour tout ensemble EE de C et tout symbole Xpour tout ensemble EE de C et tout symbole X

si goto ( EE , X ) n’est pas videsi goto ( EE , X ) n’est pas vide

tant que nous pouvons rajouter des ensembles d’entités tant que nous pouvons rajouter des ensembles d’entités à Cà C

faire : rajouter goto ( EE , X ) à C s’il n’y figure faire : rajouter goto ( EE , X ) à C s’il n’y figure paspas

encore !encore !

tant que nous pouvons rajouter des ensembles d’entités tant que nous pouvons rajouter des ensembles d’entités à Cà C

faire : rajouter goto ( EE , X ) à C s’il n’y figure faire : rajouter goto ( EE , X ) à C s’il n’y figure paspas

encore !encore !Nous calculons tous les états atteignables à partir de C !Nous calculons tous les états atteignables à partir de C !

----• 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 Soit C = { EE , . . . , EE } la collection des ensembles ensembles

d’entités calculée par l’opération tous_EE !d’entités calculée par l’opération tous_EE !

• L’état i de l’analyseur est construit à partir de EE L’état i de l’analyseur est construit à partir de EE comme :comme :

– Si [ A ::= Si [ A ::= . a . a , b ] , b ] EE et goto ( EE , a ) EE et goto ( EE , a ) = EE= EE

alors ACTIONS ( i , a ) = SHIFT j !alors ACTIONS ( i , a ) = SHIFT j !

ii ii jj

– Si [ A ::= Si [ A ::= . a . a , b ] , b ] EE et goto ( EE , a ) EE et goto ( EE , a ) = EE= EE

– Si [ A ::= Si [ A ::= . , b ] . , b ] EE et A <> S’ EE et A <> S’

alors ACTIONS ( i , b ) = REDUCE A ::= alors ACTIONS ( i , b ) = REDUCE A ::= ! !

ii ii jj

• Soit C = { EE , . . . , EE } la collection des ensembles Soit C = { EE , . . . , EE } la collection des ensembles

• L’état i de l’analyseur est construit à partir de EE comme :L’état i de l’analyseur est construit à partir de EE comme :

– Si [ A ::= Si [ A ::= . a . a , b ] , b ] EE et goto ( EE , a ) = EE EE et goto ( EE , a ) = EE

– Si [ A ::= Si [ A ::= . , b ] . , b ] EE et A <> S’ EE et A <> S’

alors ACTIONS ( i , b ) = REDUCE A ::= alors ACTIONS ( i , b ) = REDUCE A ::= ! !

– Si [ S’ ::= S . , # ] Si [ S’ ::= S . , # ] EE EE

alors ACTIONS ( i , # ) = ACCEPT !alors ACTIONS ( i , # ) = ACCEPT !

ii ii jj

– Si goto ( EE , A ) = EE , alors SUCC ( i , A ) Si goto ( EE , A ) = EE , alors SUCC ( i , A ) = j ! = j !

– Toute entrée non définie par une des règles ci-dessus Toute entrée non définie par une des règles ci-dessus est est

une erreur !une erreur !

– Si goto ( EE , A ) = EE , alors SUCC ( i , A ) = j ! Si goto ( EE , A ) = EE , alors SUCC ( i , A ) = j !

– Toute entrée non définie par une des règles ci-dessus est Toute entrée non définie par une des règles ci-dessus est

– L’état initial est celui qui comprend d’entité de démarrage L’état initial est celui qui comprend d’entité de démarrage

[ S’ ::= . S , # ] ![ S’ ::= . S , # ] !

– Si goto ( EE , A ) = EE , alors SUCC ( i , A ) = j ! Si goto ( EE , A ) = EE , alors SUCC ( i , A ) = j !

– Toute entrée non définie par une des règles ci-dessus est Toute entrée non définie par une des règles ci-dessus est

– L’état initial est celui qui comprend d’entité de démarrage L’état initial est celui qui comprend d’entité de démarrage

[ S’ ::= . S , # ] ![ S’ ::= . S , # ] !

C O N C R E T E M E N TC O N C R E T E M E N T

Y A C CY A C C

E TE T

B I S O NB I S O N

YACC et BISONYACC et BISON----------------------------------------------------------------------------------------------------------------------------

----Yet Another Compiler Compiler ( bison son remake ) !Yet Another Compiler Compiler ( bison son remake ) !

• Nous donnons une grammaire !Nous donnons une grammaire !

• Nous associons du code aux différentes règles Nous associons du code aux différentes règles reconnues !reconnues !

• yacc construit un analyseur LALR qui comporte notre yacc construit un analyseur LALR qui comporte notre code !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 Cette démarche permet de générer rapidement un code assembleur intermédiaire !assembleur intermédiaire !

• L’optimisation de ce code est faite en dehors de yacc ! L’optimisation de ce code est faite en dehors de yacc !

U NU N

E X E M P L EE X E M P L E

P A R T I E LP A R T I E L

Un exemple partielUn exemple partiel----------------------------------------------------------------------------------------------------------------------------

----•Soit la grammaire :Soit la grammaire :

S ::= ES ::= EE ::= T E’E ::= T E’E’ ::= + E’ | E’ ::= + E’ | T ::= F T’T ::= F T’T’ ::= * T’ | T’ ::= * T’ | F ::= id | (E)F ::= id | (E)

S ::= ES ::= EE ::= T E’E ::= T E’E’ ::= + E’ | E’ ::= + E’ | T ::= F T’T ::= F T’T’ ::= * T’ | T’ ::= * T’ | F ::= id | ( E )F ::= id | ( E )

Le premier état :Le premier état :