Grammaires Analyse grammaticale.

Didier Rmy e Octobre 2000

http://cristal.inria.fr/remy/poly/compil/8/
http://w3.edu.polytechnique.fr/profs/informatique/Didier.Remy/compil/8/

Grammaires algbriques (context-free) e

Une grammaire permet une reprsentation nie dun langage e (ventuellement inni). Noam Chomsky (c.f. author of e Manufacturing Conscent) a invent la notion de grammaire e formelle. Une grammaire algbrique (ou context free) G est un quadruplet e (, V, S, P ) o` : u est lalphabet des terminaux (lex`mes ou tokens), e V est lalphabet des non-terminaux (disjoint de ), S V est lunique axiome. P est un ensemble ni de r`gles de production, e de la forme avec V , et ( V ) Le langage L(G) associ ` la grammaire G est la fermeture e a transitive du singleton {S} par la r`gle dinduction : e

Slide 1

uv L P = uv L

Drivations e
Pour montrer quun mot w est dans le langage L il faut donc exhiber une suite nie dapplications de r`gles de production e partant de S et aboutissant ` w, appele une drivation. a e e On peut reprsenter une drivation par e e
1 2 n S = w0 w1 . . . wn = w

Slide 2

o` wk = uk k vk = uk+1 k+1 vk+1 et Pk = k k . u On laisse Pi implicite lorsquil ny a pas dambiguit, ou on crit : e e

S = u1 1 v1 u1 1 v1 = u2 2 v2 u2 2 v2 = . . . un n vn un n vn

Exemples : expressions arithmtiques e

Les terminaux (lex`mes) sont NUM, ID, PLUS et MINUS . e

SE

E NUM

E ID

E E PLUS E

E E MINUS E

Slide 3

Pour reconna tre lexpression 1 - 1 + x, i.e. apr`s analyse e lexicale, NUM MINUS NUM PLUS ID, il existe de nombreuses drivations possibles. Lensemble de ces drivations peut tre e e e reprsent par un ensemble darbres syntaxiques (ici deux) : e e E NUM E NUM E MINUS MINUS E NUM SE SE E NUM E PLUS PLUS E ID E ID Chaque arbre syntaxique reprsente lui mme un ensemble de e e drivations obtenues en xant un ordre dapplication des r`gles. e e

Drivations e
Par exemple, la drivation la plus ` gauche (resp. ` droite) de e a a larbre syntaxique de gauche est obtenue en rduisant toujours le e non-terminal le plus ` gauche (resp. ` droite). a a

S E
Slide 4

S E PLUS E MINUS E PLUS E PLUS E

resp.

E E

E PLUS E E PLUS ID PLUS ID

NUM MINUS E

E MINUS E E

NUM MINUS NUM PLUS E NUM MINUS NUM PLUS ID

MINUS NUM PLUS ID

NUM MINUS NUM PLUS ID

Parmi lensemble des drivations dun arbre syntaxique, il en e existe toujours une la plus ` gauche (resp. la plus ` droite). a a

Grammaires rguli`res e e
Les r`gles de production sont de la forme o` { } V . e u Langage rgulier Le langage dcrit par une grammaire rguli`re e e e e peut tre reconnu par un automate ni, et rciproquement. e e ` A (, V, S, P ), on associe (V {F }, , , S, {F }) o` q (q, a) si u q aq et q F si q . ` A un automate ni dterministe (Q, , , q0 , F ) on associe la e grammaire (, Q, q0 , P ) o` P contient q aq si q (q, a) et u q si q F . Exemple ` lexpression rguli`re (ab) correspond la grammaire a e e compose des lex`mes a et b et des r`gles : e e e

Slide 5

S
Un exemple de drivation : e

S aI

I bS

S aI abS abaI ababS abab

Grammaires ambiges u
Drivations et arbres de drivations e e En gnral, il existe de nombreuses drivations dun mme e e e e arbre syntaxique, mais ce nest pas gnant. e Lorsquil existe plusieurs arbres syntaxiques drivables pour une e mme expression, la grammaire est dite ambige. e u Slide 6 Elimination des ambiguits e Lexistence de plusieurs arbres syntaxiques pose un probl`me, car e il faudra faire un choix dans la construction de larbre de syntaxe abstraite qui va en gnral inuer sur la smantique (par e e e exemple, la soustraction des expressions arithmtiques nest pas e associative). Heureusement, il est souvent possible dliminer les ambiguits, e e ce qui consiste ` r-crire certaines r`gle de faon ` obtenir une a e e e c a grammaire non-ambige reconnaissant le mme langage. u e

Elimination des ambigu es t

Typiquement, on peut sparer un terminal E en deux terminaux e E et T .

SE E E PLUS T
Slide 7

ET T NUM T ID

E E MINUS T

Fin de chier/phrase on ajoute un lex`me EOF et e on change les r`gles S en S EOF , ou bien e on introduit un symbole S et on prend S S EOF pour axiome (S devient un non-terminal).

Grammaires prdictives LL(1) e

Simples, elles permettent lcriture manuelle danalyseurs. e Pour ( V ) , on dnit lensemble f irst() des lex`mes qui e e peuvent commencer une drivation de . Formellement, e

f irst() = {a | ( V ) , a}
Slide 8 Une grammaire est prdictive (i.e. LL(1)), si pour tout non e terminal V , pour toutes productions distinctes et alors f irst() f irst( ) = . Gnralisation possible ` LL(k) mais peu utilise (inecacit) e e a e e Exemple : la grammaire des expressions arithmtiques donne e e ci-dessus nest pas prdictive, car : e

f irst(E PLUS T ) = {NUM, ID} = f irst(E MINUS T ) = {NUM, ID}

Elimination de la rcursion gauche e

La rcursion gauche est une source de dambiguit (conit). On e e peut lliminer en par tansformation (rcriture) en des r`gles e ee e quivalentes, sans rcursion gauche. e e ET E E E PLUS T E PLUS T E Exemple E E MINUS T = E MINUS T E ET E

Slide 9

Cas gnral e e

X X 1 XX 2 X 1 X 2

X 1 X

X X 2 X 1 X X 2 X X

Factorisation gauche
Elle se traite de faon similaire. c Exemple du if-then-else

Slide 10

E IF B THEN E ELSE E E IF B THEN E

E IF B THEN E X

X ELSE E X

Analyseur pour les grammaires prdictives e

Pour chaque non-terminal V , on peut dcider de la e production ` appliquer en fonction du prochain lex`me a : a e cest lunique r`gle avec a f irst() (puisque deux r`gles e e drivant ne peuvent pas commencer par le mme lex`me). e e e On peut alors construire une table ` deux dimensions V ` a a valeurs dans P . Slide 11 Exemple pour les expressions arithmtiques (apr`s limination de e e e la rcursion gauche). e

PLUS S E E T PLUS T E

MINUS

ID E EOF T E

NUM E EOF T E

EOF

MINUS T E ID NUM

Programme danalyse
La table ci-dessus peut tre implmente directement en e e e interprtant le tableau ou bien par ltrage. (Il faudrait aussi e ajouter un rattrapage derreur dans les cases vides du tableau) :

Fichier expr.ml
Slide 12 type lex`me = PLUS | MINUS | ID | NUM | EOF;; e let buf = ref [];; let lit lex`me () = e match !buf with h::t > buf:= t; h | [] > EOF;; let lex`me = ref ( EOF : lex`me);; e e let avance() = lex`me := lit lex`me();; e e let accepte a = if ! lex`me = a then avance() else failwith accepte e

Slide 13

let rec S() = match !lex`me with e | ID | NUM > E(); accepte EOF and E() = match !lex`me with e | ID | NUM > T(); E() and E() = match !lex`me with e | PLUS > accepte PLUS; T(); E() | MINUS > accepte MINUS; T(); E() | EOF > () and T() = match !lex`me with e | ID > accepte ID; | NUM > accepte NUM let parse l = buf := l; avance(); S();;

Langages LR(1)
Left-to-right parse, Right-most derivation (1-token lookahead) Les grammaires LL(1) permettent lcriture facile donc manuelle e danalyseurs, mais lcriture dune grammaire LL(1) pour un e langage est contraignante et revient ` une forme de compilation a manuelle. De plus, celle-ci nest pas toujours possible. Slide 14 Les grammaires LR sont plus gnrales : une grammaire LR(1) e e est aussi LL(1) donc la classe des langages reconnus par une grammaire LR(1) contient celle des langages LL(1). Les grammaires LR(1) sont galement plus souples (moins e contraignantes) dans lcriture des r`gles. e e

Principe
Leur moteur utilise une pile auxiliaire. Le ux de lex`me est lu en e consultant au plus 1 lex`me non empil. Il faut alors pouvoir e e dcider dune action ` eectuer (en fonction de la pile et du e a prochain lex`me) : e shif t, i.e. consommer et empiler un lex`me, ou e reduce, i.e. rduire une r`gle. Cela revient ` appliquer une r`gle e e a e de production sur le sommet (partie droite) de la pile. Si pour une mme conguration de pile et du prochain lex`me, e e plusieurs axiomes sont possibles, alors la grammaire nest pas LR(1) et dite ambige. u Gnralisation possible en regardant les k prochains lex`mes e e e (grammaires LR(k)) mais peu utilise (inecacit). e e

Slide 15

Pile

Flux de lex`mes e

Action

. . . . . . . . . . . . NUM MINUS NUM PLUS ID EOF

shif t reduce reduce shif t shif t reduce reduce shif t shif t reduce reduce shif t reduce

NUM . . . . . . . . . . . MINUS NUM PLUS ID EOF T . . . . . . . . . . . MINUS NUM PLUS ID EOF E . . . . . . . . . . . MINUS NUM PLUS ID EOF E MINUS . . . . . . . . . . . . . NUM PLUS ID EOF E MINUS NUM . . . . . . . . . . . . . PLUS ID EOF
Slide 16 Trace dexcution e

E MINUS T . . . . . . . . . . . . . PLUS ID EOF E . . . . . . . . . . . . . . . . . . . . . PLUS ID EOF E PLUS . . . . . . . . . . . . . . . . . . . . . . . ID EOF E PLUS ID . . . . . . . . . . . . . . . . . . . . . EOF E PLUS T . . . . . . . . . . . . . . . . . . . . . EOF E . . . . . . . . . . . . . . . . . . . . . . . . . . . . EOF E EOF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . S .................................

Reconnaissance par un automate ` pile a

Une grammaire LR(1) est reconnaissable par un automate ` pile a qui mcanise le calcul prcdent. e e e Description Les lments sur la pile sont des paires (Xi , si ) dun tat si et ee e dun lex`me X V sauf le fond de pile qui est ltat initial e e s0 . Lautomate est dtermin par deux fonctions partiellement e e dnies : e goto(s, X) pour X V . action(s, a) qui peut prendre les valeurs shif t ou reduce(P ) o` u P est une r`gle de production e

Slide 17

Transitions
Dans une conguration de pile s0 (X1 , s1 )...(Xm , sm ) (sommet ` a droite), lautomate consulte le lex`me suivant a et par cas sur la e valeur de action(sm , a) eectue lune des deux actions : shif t : le prochain lex`me est consomm et (a, goto(sm , a)) est e e empile e reduce(X ) : k lments o` k est la longueur de sont ee u dpils et (X, goto(smk , X)) est empil. e e e Lorsque action(sm , ai ) est indnie, lautomate sarrte, avec e e succ`s si la pile est rduite ` laxiome, avec chec sinon. e e a e

Slide 18

Construction des tats e

Un tat I est compos dun ensemble de congurations C . e e Une conguration C est une paire compose : e 1. dune r`gle de production pointe . . i.e. est e e une r`gle de production et est le sommet de pile. e 2. du prochain lex`me possible a . e Slide 19 La fermeture dun ensemble de congurations I est le plus petit ensemble contenant I et satisfaisant

((X Y , a) I Y G b f irst(a)) = (Y , b) I
La transition dune conguration I par un lex`me X V est e

goto(I, Y ) = f ermeture({(X Y , a) | (X Y , a) I})

10

Construction des tables

Ltat initial est la fermeture de laxiome. Les tats sont les e e ensembles de congurations fermes non vides atteignables par e une suite de transitions arbitraires ` partir de ltat initial. a e Les actions sont de 4 types : 1. Si (X a, b) I et goto(I, a) = J , alors action(I, a) = shif t Slide 20 (on peut reprsenter simultanment goto(I, a) en crivant e e e shif t(J)) 2. Si (X , a) I , alors action(I, a) = reduce(X ). Sauf, si X est laxiome, alors action(I, a) = accept. (Il reste ` reprsenter la table goto(I, Y ) pour Y V .) a e Enn, la grammaire nest pas LR(1) sil y a des conits, i.e. plusieurs valeurs possibles pour action(I, a). Pour les autres cases, action(I, a) = echec.

Slide 21

q  5 0X1 65 4 WD V 55     %11 65 4 SI V f q R1 U T  S e 55    0a9`Y c6b P 5 g 6655 F  EC   F dcb   EC D C B G    q p ha9`Y  A 65 4   @ 65 4 9)( !   dcb  i 8 4 7 65 4 3%$# 2 0a9`Y 1 &
11

0)( I  Q3& E#$% CH I 0)( I  232#$& % CH I '0)%$(# " ! & "!        

LR(0) v.s. LR(1)

Dans la construction prcdente, lensemble des lex`mes e e e prossibles apr`s le dclanchement dune r`gle est presque toujours e e e EOF , PLUS , MINUS , et ne sert jamais ` dambiger deux tats. a e u e En eet, lexemple considrer est aussi LALR(0). e Exercice 1 On consid`re la grammaire suivante e Slide 22

S E EOF

E T PLUS E

ET

T ID

Vrier que la grammaire nest pas LR(0). (On construit les e tats comme pour une grammaire LR(1), mais dans lesquelles les e congurations ne comporte que les premi`res composante (une e r`gle pointe. Il sut alors de vrier quil existe deux transition e e e possibles avec une mme tiquette). e e Vrier que la grammaire est LR(1). e

Construction de la table de lautomate

On construit un tableau de dimension 2 avec les tats en e ordonnes et les lments de lettre de lalphabet V en e ee abscisse. On remplit le tableau ligne par ligne. Pour chaque tat I , e Pour chaque `che tiquette par un terminal I a J , on e e e associe une action shif t(J) dans la colonne a. Pour chaque `che tiquette par un non-terminal I a J , on e e e associe on mmorise la valeur J de goto(I, a) dans la case a. e (pseudo-action shif t(J)). Enn, pour chaque r`gle pointe ` la n (en rouge) on associe e e a une action rduce dans la case associ ` chacun des terminaux e e a suivant possibles (en vert).

Slide 23

12

Tables
I 1 3 4 5
Slide 24

NUM s3

ID s4

S 5

E 6

T 7 r 1 2
r`gle e

r5 r6

r5 r6

r5 r6

S E$ E E+T E ET ET T NUM T ID

6 7 8 9 10 11 12

s9 r4 r1

s10 r4 r1 s3 s3 s4 s4

s8 r4 r1 11 12 r2 r3

3 4 5 6

r2 r3

r2 r3

Pile
1

Flux de lex`mes e

Action

. . . . . . . . . . . . . . . . . . . . . . . . . . NUM NUM + ID$ . . . . . . . . . . . . . . . . . . . . . . . . . NUM + ID$

shif t reduce reduce shif t shif t reduce reduce shif t shif t reduce reduce shif t reduce

1 NUM3 1 1

T7 . . . . . . . . . . . . . . . . . . . . . . . . . . NUM + ID$ E6 . . . . . . . . . . . . . . . . . . . . . . . . . . NUM + ID$ . . . . . . . . . . . . . . . . . . . . . . . . . . . NUM + ID$ 10 NUM3 . . . . . . . . . . . . . . . . . . . . . . . . + ID$ 10 T12 . . . . . . . . . . . . . . . . . . . . . . . . . + ID$ +9 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ID$ +9 ID4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . $ +9 T11 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . $
....................................

1 E6 1 E6

Slide 25

1 E6 1

E6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . + ID$

1 E6 1 E6 1 E6 1

E6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . $ S5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 E$8 1

13

Correction
Exercice 2 (Correction) Vrier que lorsque lalgorithme e ci-dessus trouve une solution, alors il est possible de construire une drivation. e Exercice 3 (Complture) Vrier que lorsque lalgorithme ne e e trouve pas de solution, alors il nexiste pas de drivation. e Slide 26

Conits
Un conit se produit lorsquil existe plusieurs une conguration (I, a) pour laquelle action(I, a) admet plusieurs valeurs possibles. On parle de conit :

reduce reduce

lorsque (X , a) I et (Y , a) I .

Slide 27

Ces conits sont graves et correspondent gnralement ` une e e a forte ambigu e dans la grammaire. Il faut rcrire la t ee grammaire.

shif t reduce

lorsque (X a, b) I et (Y , a) I .

Ces conits sont moins graves, et correspondent souvent ` des a priorits quil faut rendre explicites, soit par rcriture, soit par e ee ajout de r`gles de priorit. e e (Par construction, les conits shif t shif t ne sont pas possibles)

14

R`gles dassociativit e e
La grammaire suivante contient un conit shif t/ reduce

1:E E+E

2 : E NUM

Slide 28

En eet, la squence NUM PLUS NUM PLUS NUM est reconnue par e reduce 1, shif t, reduce 2, reduce 1 shif t, reduce 2, shif t, shif t, reduce 2, shif t, reduce 2, reduce 1, reduce 1 La premi`re solution reconna (E + E) + E , lautre E + (E + E). e t On peut rcrire la grammaire pour forcer lune ou lautre r`gle, ee e mais il est aussi possible et prfrable (bien que sortant du ee formalisme LR(1)) de choisir entre les deux actions possibles par des r`gles dassociativit et de priorit. e e e (Les r`gles de priorit sappliquent localement pour ordonner les e e actions possibles ` partir dun tat ambig.) a e u

R`gles de priorit e e
Selon que + est dclar associative ` gauche ou ` droite, laction e e a a retenue sera reduce ou shif t. On peut galement dclarer des lex`mes plus prioritaires que e e e dautres, ou des r`gles plus prioritaires que dautres. e

Slide 29

15

Grammaires LALR(1)
Look Ahead LR(1) Les grammaires LALR(1) sont une restriction des grammaires LR(1) an dobtenir des tables plus petites. Le langage reconnu est un peu plus restrictif, mais ce nest pas une gne en pratique. e Dans une grammaire LALR(1) les tats qui ne sont distingus e e que par le lex`me suivant (mais qui ont exactement le mme e e ensemble de r`gles de production) sont identis (avant e e construction des tables). Yacc, Ocamlyacc, Bison, etc., sont des compilateurs de grammaires LALR(1).

Slide 30

Ocamlyacc
Fichier foo.mly
%{ ( %} / %% / %% ( prelude : code Ocaml reproduit verbatim ) declarations yacc / r`gles yacc / e postlude : code Ocaml reproduit verbatim )

Slide 31

Pour compiler la grammaire ocamlyacc v foo.mly ocamlc foo.ml # produit foo.ml et foo. output

Loption -v copie les tables dans un chier foo.output (utile pour la mise au point)

16

Exemple
exp.mly
%token EOP PLUS MINUS %token <int> NUM %token <string> ID %start S %type <string> S %% S : E EOP { ( $1 : string ) } E : E PLUS T { Plus ($1, $3) } | E MINUS T { Minus ($1, $3) } | T { $1 } T : NUM { Num (string of int $1) } | ID { Id $1 } %%

Slide 32

Indication des priorits e

Dans la partie dclaration : e %noassoc lower %left PLUS MINUS %left TIMES DIV %right FOO %noassoc BAR %noassoc higher Par dfaut, la priorit dune r`gle est celle de son dernier lex`me. e e e e La directive %prec peut tre utilise ` la n dune r`gle pour e e a e indiquer la priorit ` donner ` cette r`gle. e a a e

Slide 33

17

Mise en uvre
Il faut combiner le parseur avec un lexeur. voir lexp.mll. Le parseur doit tre compil en premier, car il produit e e simultanment la dnition du type des token utilis par le lexeur e e e (le nom de lidenticateur token est x par convention). e Le programme principal appelle le parseur qui appelle le lexeur comme ci-dessus. Report derreur Il existe un mcanisme de report derreur dans yacc, mais qui e nest pas facile ` mettre en uvre. En cas derreur, il est simple a et souvent susant de signaler le dernier lex`me lu et son e emplacement (voir le compilateur Pseudo-Pascal main.ml)

Slide 34

Exercices
Exercice 4 (Langage de parenth`ses) Ecrire un parseur (et e un lexeur) pour le langage de parenth`ses. e Comparer avec la reconnaissance des parenth`ses directement e dans le lexeur. Quelle approche est-elle prfrable ? ee Rponse e Exercice 5 (Expressions arithmtiques) Ecrire un parseur (et e un lexeur) pour reconna tre les expressions arithmtiques sans e variables. Retourner larbre de syntaxe abstraite. En dduire une calculette en remplaant la gnration de larbre e c e e par le calcul. Pour obtenir une Super calculette, on pourra Ajouter des mmoires (set n et get n). e Ajouter la comparaison et les expressions conditionnelles.

Slide 35

18

Travaux dirigs e
Exercice 6 (Pseudo Pascal) Ecrire un lexeur pour le langage Pseudo Pascal. (On rutilisera le lexeur de cet exercice). e Un exemple de programme Pseudo Pascal est fact.p. La syntaxe programmes est donne dans une forme BNF (Backus e Normal Form) que lon peut lire comme des r`gles de production, e une par ligne (le symbole | remplace un saut ` la ligne). a La notation u s . . . u (resp. u s . . . u s ) reprsente une squence e e possiblement vide de u spars par des s (resp. et termine par e e e un s).

Slide 36

Programmes p ::= program v; . . . v; d; . . . d; i ; ; Dclarations e v ::= var x : t

Programme Dcl. de variable e Dcl. de fonction e Dcl. de procdure e e Aectation Squence e Conditionnelle Appel de procdure e Lecture Ecriture Ecriture avec newline Aectation de tableau

d ::= function x( var x : t, . . . var x : t ) : t; v; . . . v; i procedure x( var x : t, . . . var x : t ); v; . . . v; i

Slide 37 Instructions i ::= x := e begin i; . . . i end if e then i else i x( e, . . . e ) read (x) write (e) writeln (e) e[e] := e

19

Exercice (Suite)

Slide 38

Expressions e ::= (e) x n true | false x( e, . . . e ) alloc (e : t) e bin e

Expression parenth`se e e Variables Entiers Boolens e Appel de fonction Allocation Opration binaire e Acc`s dans un tableau e Arithmtiques e Comparaison

e[e]
Oprations e bin ::= + | | | / < | > | <= | >= | = | <> Types t ::=

integer boolean array of t

Exercice (Suite)
Dans un premier temps, on pourra laisser les actions vides (on retour unit). Ensuite, on produira un arbre de syntaxe abstraite dni par le type concret program du chier dinterface e pp.mli. Rponse e

Slide 39

Enn, on pourra complter le programme avec un imprimeur qui e imprime le programme (arbre de syntaxe abstraire reconnu) dans la sortie standard. En particulier, cela permet de vrier que le e programme a t compris correctememt. e e Rponse e

20