1 / 60

Compilation Analyses Lexicale, Syntaxique, et S mantique

Transparent 2. Sommaire. 1. Introduction

laszlo
Télécharger la présentation

Compilation Analyses Lexicale, Syntaxique, et S mantique

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

    1. 1 Compilation Analyses Lexicale, Syntaxique, et Smantique Introduction Les techniques d'analyse syntaxique utilisables dans la construction pratique des compilateurs sont principalement issues de deux grandes familles de grammaires, les LL(k) et les LR(k), pour lesquelles la thorie fournit des rsultats quasi optimaux. Introduction Les techniques d'analyse syntaxique utilisables dans la construction pratique des compilateurs sont principalement issues de deux grandes familles de grammaires, les LL(k) et les LR(k), pour lesquelles la thorie fournit des rsultats quasi optimaux.

    2. Transparent 2 Sommaire 1. Introduction la compilation 2. Analyse lexicale 3. Rappels sur les langages formels 4. Analyse syntaxique non dterministe 5. Analyse syntaxique descendante mthodes LL() 6. Analyse syntaxique ascendante mthodes LR() 7. Traduction dirige par la syntaxe 8. Gnrateurs LR() 9. Smantique statique des L.P. 10. Traitements source to source Rfrences bibliographiques Compilateurs: Principes, techniques et outils, A. Aho, R. Sethi, J. Ullman; InterEditions (1991) Lex & Yacc, JR Lewine, T. Mason, D. Brown; OReilly & Associates, Inc (1992) A first course using ANSI C, LEX and YACC, J. P. Bennett, 2nd edition, McGraw Hill (1996) Modern Compilation Implementation, A. Appel; Cambridge University Press (1998) The Essence of Compilers, R. Hunter, Prentice hall (1999) Compilateurs, D.Grune et all, Dunod (2002) Crafting a Compiler, C.Fischer, R.LeBlanc, Benjamin Cummings Series (1988) Autres Cours ESSI Petit Prcis de Lex. J. Farr; Notes de TP ESSI-2 (1998) Petit Prcis de Yacc. J. Farr; Notes de TP ESSI-2 (1998) Cours de Compilation du MIT (format .ppt en Anglais) lecture3: grammaires, arbres, langages, analyseurs lecture4: construction SLR lecture5: construction LR(1) lecture6: construction LALR(1) lecture7: smantique statique. Rfrences bibliographiques Compilateurs: Principes, techniques et outils, A. Aho, R. Sethi, J. Ullman; InterEditions (1991) Lex & Yacc, JR Lewine, T. Mason, D. Brown; OReilly & Associates, Inc (1992) A first course using ANSI C, LEX and YACC, J. P. Bennett, 2nd edition, McGraw Hill (1996) Modern Compilation Implementation, A. Appel; Cambridge University Press (1998) The Essence of Compilers, R. Hunter, Prentice hall (1999) Compilateurs, D.Grune et all, Dunod (2002) Crafting a Compiler, C.Fischer, R.LeBlanc, Benjamin Cummings Series (1988) Autres Cours ESSI Petit Prcis de Lex. J. Farr; Notes de TP ESSI-2 (1998) Petit Prcis de Yacc. J. Farr; Notes de TP ESSI-2 (1998) Cours de Compilation du MIT (format .ppt en Anglais) lecture3: grammaires, arbres, langages, analyseurs lecture4: construction SLR lecture5: construction LR(1) lecture6: construction LALR(1) lecture7: smantique statique.

    3. 3 Chapitre 5 Analyse syntaxique descendante mthodes LL(k) Proprit LL(k) Dterminer si une grammaire est LL(1) ? Analyseur LL(1) Gnrateur syntaxique LL(1) Quelques Environnments de Compilation (compiler- compiler) Java Compiler Compiler [tm] (JavaCC [tm]) - The Java Parser Generator http://javacc.java.net/ SYNTAX http://syntax.gforge.inria.fr/ Free Compiler Construction Tools http://www.thefreecountry.com/programming/compilerconstruction.shtml ANTLR, ANother Tool for Language Recognition, http://www.antlr.org/ The Compiler Generator Coco/R http://www.ssw.uni-linz.ac.at/Coco/Quelques Environnments de Compilation (compiler- compiler) Java Compiler Compiler [tm] (JavaCC [tm]) - The Java Parser Generator http://javacc.java.net/ SYNTAX http://syntax.gforge.inria.fr/ Free Compiler Construction Tools http://www.thefreecountry.com/programming/compilerconstruction.shtml ANTLR, ANother Tool for Language Recognition, http://www.antlr.org/ The Compiler Generator Coco/R http://www.ssw.uni-linz.ac.at/Coco/

    4. Transparent 4 Proprit LL(k) il existe k? 0 dpendant uniquement de la grammaire tel que: pour tout mot X analyser dans T* pour tout A dans N au plus une rgle A?? de P drive de S en: A?? *? y1 . . . yk T* LL(k) Lecture du mot de gauche droite(Left to Right) Drivations gauches (Leftmost) Proprit LL(k) des grammaires Notation: pour toute production {A??} d' une grammaire G, on note: Vuek(A??)={y[k], S ??g uAv ?u?v ?? uyw ?T*, avec v ?(N ? T)* } ? Interprtation: Vuek(A??) est l'ensemble des prfixes de longueur k que l'on peut rellement obtenir dans un arbre de drivation, en drivant A?? Dfinition: une grammaire est LL(k) si pour tout non terminal A et pour toute paire de production A?? et A?? : ? ? ? => Vuek(A??) ? Vuek(A??) = ? ? Proprit: une grammaire LL(k) est LL(k') pour k' > k ? Grammaire LL(1) Notation: pour k= 1, on note: Vue(A??) = Vuek(A??) ? Principe : Pour dcider si une grammaire est LL(1), il suffit de savoir construire tous les ensembles Vue(A??) ? T , pour toutes les productions A?? vrifier la proprit de la dfinition ci-dessus.LL(k) Lecture du mot de gauche droite(Left to Right) Drivations gauches (Leftmost) Proprit LL(k) des grammaires Notation: pour toute production {A??} d' une grammaire G, on note: Vuek(A??)={y[k], S ??g uAv ?u?v ?? uyw ?T*, avec v ?(N ? T)* } ? Interprtation: Vuek(A??) est l'ensemble des prfixes de longueur k que l'on peut rellement obtenir dans un arbre de drivation, en drivant A?? Dfinition: une grammaire est LL(k) si pour tout non terminal A et pour toute paire de production A?? et A?? : ? ? ? => Vuek(A??) ? Vuek(A??) = ? ? Proprit: une grammaire LL(k) est LL(k') pour k' > k ? Grammaire LL(1) Notation: pour k= 1, on note: Vue(A??) = Vuek(A??) ? Principe : Pour dcider si une grammaire est LL(1), il suffit de savoir construire tous les ensembles Vue(A??) ? T , pour toutes les productions A?? vrifier la proprit de la dfinition ci-dessus.

    5. Transparent 5 Grammaire non LL() Grammaire INST inst ::= var := exp (r1) inst ::= if exp then s_d_inst else s_d_inst endif (r2) s_d_inst ::= inst ; s_d_inst | inst (r3 r4) exp ::= var + exp | var = exp | var (r5 r6 r7) Analyse non LL(k) if v1= v2 then v3 := v4 + v5 ; if v3= v4 then v5 := v1 = v4 else v3 := v4 end if ; v7 := v8 else v3 := v4 endif Grammaires LL() Certaines proprits permettent de dcider facilement si une grammaire est ou n'est pas LL(k)? Grammaires Rcursives Gauches Thorme: Une grammaire LL(k) n'est pas rcursive gauche ? Preuve en TD3 Simples LL(k) Dfinition: Une grammaire est simple LL(k), not SLL(k), si toutes les rgles de P sont de la forme Si ? a1.. an ui avec a1.. an ? T+ et ui ? (N u T) * il existe k >= 0 tel que pour toute paire de rgles Si ? a1.. an ui et Si ? b1.. bm vi les mots a1.. an et b1.. bm n'ont pas de prfixe commun de longueur k ? Thorme: Une grammaire SLL(k) est LL(k) ? Analyse de la grammaire INST La grammaire INST n'est pas RG; Les drivations issues de INST sont SLL(1): se dcident par "var" ou "if" Les drivations issues de EXP sont LL(2) (pas SLL(2)) se dcident par "var" "+" ou "var" "=" ou "var" suivi d'un lexme ? diffrent de "+" ou "=" Les drivations issues de S_D_INST ne sont pas LL(k): pour tout k, il existe des INST plus longues que k Grammaires LL() Certaines proprits permettent de dcider facilement si une grammaire est ou n'est pas LL(k)? Grammaires Rcursives Gauches Thorme: Une grammaire LL(k) n'est pas rcursive gauche ? Preuve en TD3 Simples LL(k) Dfinition: Une grammaire est simple LL(k), not SLL(k), si toutes les rgles de P sont de la forme Si ? a1.. an ui avec a1.. an ? T+ et ui ? (N u T) * il existe k >= 0 tel que pour toute paire de rgles Si ? a1.. an ui et Si ? b1.. bm vi les mots a1.. an et b1.. bm n'ont pas de prfixe commun de longueur k ? Thorme: Une grammaire SLL(k) est LL(k) ? Analyse de la grammaire INST La grammaire INST n'est pas RG; Les drivations issues de INST sont SLL(1): se dcident par "var" ou "if" Les drivations issues de EXP sont LL(2) (pas SLL(2)) se dcident par "var" "+" ou "var" "=" ou "var" suivi d'un lexme ? diffrent de "+" ou "=" Les drivations issues de S_D_INST ne sont pas LL(k): pour tout k, il existe des INST plus longues que k

    6. Transparent 6 Grammaire LL(1) Grammaire INST' inst ::= var := exp (r1) inst ::= if exp then s_d_inst else s_d_inst endif (r2) s_d_inst ::= inst s_s_inst (r3) s_s_inst ::= ; s_d_inst | ? (r4 r5) exp ::= var s_d_exp (r6) s_d_exp ::= + exp | = exp | ? (r7 r8 r9) Analyse LL(1) if v1 = v2 then v3 := v4 + v5 ; if v3= v4 then v5 := v1 = v4 else v3 := v4 end if ; v7 := v8 else v3 := v4 endif Factorisation gauche de la grammaire INST La grammaire INST' est obtenue par factorisation: de inst en s_s_inst dans r3 et r4 de var en s_d_exp dans r5, r6, r7 Remarque: Une "bonne" grammaire (factorise gauche et non rcursive gauche) peut n'tre ni SLL(k), ni mme LL(k) pour aucun k ? Analyse de la grammaire INST ' La grammaire INST n' est pas RG; Les drivations issues de INST sont SLL(1): se dcident par "var" ou "if" Les drivations issues de EXP sont SLL(0) Les drivations issues de S_D_EXP sont LL(1) se dcident par "+" ou "=" ou un lexme diffrent de "+" ou "=" ? Les drivations issues de S_D_INST sont LL(0) Les drivations issues de S_S_INST sont LL(1) se dcident par ";" ou un lexme diffrent de ";" ? Factorisation gauche de la grammaire INST La grammaire INST' est obtenue par factorisation: de inst en s_s_inst dans r3 et r4 de var en s_d_exp dans r5, r6, r7 Remarque: Une "bonne" grammaire (factorise gauche et non rcursive gauche) peut n'tre ni SLL(k), ni mme LL(k) pour aucun k ? Analyse de la grammaire INST ' La grammaire INST n' est pas RG; Les drivations issues de INST sont SLL(1): se dcident par "var" ou "if" Les drivations issues de EXP sont SLL(0) Les drivations issues de S_D_EXP sont LL(1) se dcident par "+" ou "=" ou un lexme diffrent de "+" ou "=" ? Les drivations issues de S_D_INST sont LL(0) Les drivations issues de S_S_INST sont LL(1) se dcident par ";" ou un lexme diffrent de ";" ?

    7. Transparent 7 Code Ada pour un analyseur LL(1) Analyseur pile pour INST' Lex(ul); while ul /= EOT() loop case ul of "var" => case Som() of end case; "if" => case Som() of end case; end case; end loop; Analyseur pile pour une grammaire LL(1) procedure Analyseur { Lex(ul); while ul /= EOT() loop case ul of "var" => voir cot "if" => voir cot ";" => case Som() of ";" => S_S_INST => // r4 S_D_EXP => // r9 others => raise ERREUR_de_syntaxe; end case; "+" => case Som() of "+" => S_D_EXP => // r7 others => raise ERREUR_de_syntaxe; end case; "=" | "then" => comme "+" "else" | "endif" => comme ";" end case; end loop; } Analyseur pile pour une grammaire LL(1) procedure Analyseur { Lex(ul); while ul /= EOT() loop case ul of "var" => voir cot "if" => voir cot ";" => case Som() of ";" => S_S_INST => // r4 S_D_EXP => // r9 others => raise ERREUR_de_syntaxe; end case; "+" => case Som() of "+" => S_D_EXP => // r7 others => raise ERREUR_de_syntaxe; end case; "=" | "then" => comme "+" "else" | "endif" => comme ";" end case; end loop; }

    8. Transparent 8 Code Ada pour un analyseur LL(1) Analyseur pile pour INST' Lex(ul); while ul /= EOT() loop case ul of "var" => case Som() of "var" => Dep() ; Lex(ul) ; INST => Dep();Emp(EXP); Emp(":="); Emp("var"); // r1 S_D_INST => Dep(); Emp(S_S_INST); Emp(INST); // r3 EXP => Dep(); Emp(S_D_EXP); Emp("var"); // r6 others => raise ERREUR_de_syntaxe; end case; "if" => case Som() of "if" => Dep() ; Lex(ul) ; "INST" => Dep(); Emp( "endif"); Emp(S_D_INST); Emp("else"); Emp(S_D_INST); Emp("then"); Emp(EXP); Emp( "if" ); // r2 S_D_INST => Dep(); Emp(S_S_INST) ; Emp(INST); // r3 others => raise ERREUR_de_syntaxe; end case; - - - - - - - Analyseur pile pour une grammaire LL(1) procedure Analyseur { Lex(ul); while ul /= EOT() loop case ul of "var" => voir cot "if" => voir cot ";" => case Som() of ";" => S_S_INST => // r4 S_D_EXP => // r9 others => raise ERREUR_de_syntaxe; end case; "+" => case Som() of "+" => S_D_EXP => // r7 others => raise ERREUR_de_syntaxe; end case; "=" | "then" => comme "+" "else" | "endif" => comme ";" end case; end loop; } Analyseur pile pour une grammaire LL(1) procedure Analyseur { Lex(ul); while ul /= EOT() loop case ul of "var" => voir cot "if" => voir cot ";" => case Som() of ";" => S_S_INST => // r4 S_D_EXP => // r9 others => raise ERREUR_de_syntaxe; end case; "+" => case Som() of "+" => S_D_EXP => // r7 others => raise ERREUR_de_syntaxe; end case; "=" | "then" => comme "+" "else" | "endif" => comme ";" end case; end loop; }

    9. Transparent 9 Code Java pour un analyseur LL(1) Analyseur pile pour INST' Lex(ul) ; while (ul != EOT() ) { switch (ul) { case "var": switch (Som() ) { } ; break; case "if" : switch (Som() ){ } ; break; } } Analyseur pile pour une grammaire LL(1) procedure Analyseur() { Lex(ul); while ( ul != EOT() ) { switch (ul) { case "var" : voir cot case "if" : voir cot case ";" : switch (Som() ) { case ";" : case S_S_INST: // r4 case S_D_EXP : // r9 default: throw new ErreurSyntaxe(); } ; break ; case "+" : switch (Som() ) { case "+" : case S_D_EXP : // r7 default: throw new ErreurSyntaxe(); } ; break ; case "=" : case "then" : comme "+" case "else": case "endif" : comme ";" } } } Analyseur pile pour une grammaire LL(1) procedure Analyseur() { Lex(ul); while ( ul != EOT() ) { switch (ul) { case "var" : voir cot case "if" : voir cot case ";" : switch (Som() ) { case ";" : case S_S_INST: // r4 case S_D_EXP : // r9 default: throw new ErreurSyntaxe(); } ; break ; case "+" : switch (Som() ) { case "+" : case S_D_EXP : // r7 default: throw new ErreurSyntaxe(); } ; break ; case "=" : case "then" : comme "+" case "else": case "endif" : comme ";" } } }

    10. Transparent 10 Code Java pour un analyseur LL(1) Lex(ul) ; while (ul != EOT() ) { switch (ul) { case "var": switch (Som() ) { case "var": Dep() ; Lex(ul) ; break ; case INST: Dep(); Emp(EXP); Emp(":="); Emp("var"); break ; // r1 case S_D_INST: Dep(); Emp(S_S_INST); Emp(INST); break; // r3 case EXP : Dep(); Emp(S_D_EXP); Emp("var"); break ; // r6 default : throw new ErreurSyntaxe(); } ; break; case "if" : switch (Som() ) { case "if" : Dep() ; Lex(ul) ; break ; case "INST": Dep(); Emp( "endif"); Emp(S_D_INST); Emp("else"); Emp(S_D_INST); Emp("then"); Emp(EXP); Emp( "if" ); break ; // r2 case S_D_INST : Dep(); Emp(S_S_INST) ; Emp(INST); break ; // r3 default : throw new ErreurSyntaxe(); } ; break; } } Analyseur pile pour une grammaire LL(1) procedure Analyseur() { Lex(ul); while ( ul != EOT() ) { switch (ul) { case "var" : voir cot case "if" : voir cot case ";" : switch (Som() ) { case ";" : case S_S_INST: // r4 case S_D_EXP : // r9 default: throw new ErreurSyntaxe(); } ; break ; case "+" : switch (Som() ) { case "+" : case S_D_EXP : // r7 default: throw new ErreurSyntaxe(); } ; break ; case "=" : case "then" : comme "+" case "else": case "endif" : comme ";" } } } Analyseur pile pour une grammaire LL(1) procedure Analyseur() { Lex(ul); while ( ul != EOT() ) { switch (ul) { case "var" : voir cot case "if" : voir cot case ";" : switch (Som() ) { case ";" : case S_S_INST: // r4 case S_D_EXP : // r9 default: throw new ErreurSyntaxe(); } ; break ; case "+" : switch (Som() ) { case "+" : case S_D_EXP : // r7 default: throw new ErreurSyntaxe(); } ; break ; case "=" : case "then" : comme "+" case "else": case "endif" : comme ";" } } }

    11. Transparent 11 Analyseur rcursif LL(1) proc INST(ul) { switch( ul ) { case "var" : break; case "if" : break; default : throw new ErreurSyntaxe(); } } proc EXP(ul) { switch( ul ) { case "var" : break; default : throw new ErreurSyntaxe(); } } proc S_D_INST(ul) { switch( ul ) { case "var" : case"if" : break; default : throw new ErreurSyntaxe(); } } Analyseur pour une grammaire LL(1) proc scan(ul, term) { if (ul = term) Lex(ul) ; else throw new ErreurSyntaxe();} proc INST(ul); voir cot proc EXP(ul) ; voir cot proc S_D_INST(ul) voir cot proc S_S_INST(ul) { switch ( ul) { case ";": scan(ul, ";" ); S_D_INST(ul) ; break ; // r4 case"else": case "endif": case ";" : break; // r5 default: throw new ErreurSyntaxe(); } } proc S_D_EXP(ul) { switch ( ul) { case "+": scan(ul, "+" ); EXP(ul) ; break; // r7 case "=" : scan(ul, "=" ); EXP(ul) ; break; // r8 cas "then": case"else": case"endif": case";": break; // r9 default: throw new ErreurSyntaxe(); } } Analyseur pour une grammaire LL(1) proc scan(ul, term) { if (ul = term) Lex(ul) ; else throw new ErreurSyntaxe();} proc INST(ul); voir cot proc EXP(ul) ; voir cot proc S_D_INST(ul) voir cot proc S_S_INST(ul) { switch ( ul) { case ";": scan(ul, ";" ); S_D_INST(ul) ; break ; // r4 case"else": case "endif": case ";" : break; // r5 default: throw new ErreurSyntaxe(); } } proc S_D_EXP(ul) { switch ( ul) { case "+": scan(ul, "+" ); EXP(ul) ; break; // r7 case "=" : scan(ul, "=" ); EXP(ul) ; break; // r8 cas "then": case"else": case"endif": case";": break; // r9 default: throw new ErreurSyntaxe(); } }

    12. Transparent 12 Analyseur rcursif LL(1) proc INST(ul) { switch( ul ) { case "var" : scan(ul, "var" ); scan(ul, ":=" ); EXP(ul) ; break; // r1 case "if" : scan(ul, "if" ); EXP(ul) ; scan(ul, "then" ); S_D_INST(ul); scan(ul, "else" ); S_D_INST(ul); scan(ul, "endif" ); break; // r2 default : throw new ErreurSyntaxe(); } } proc EXP(ul) { switch( ul ) { case "var": scan(ul, "var" ); S_D_EXP(ul) ; break; // r6 default : throw new ErreurSyntaxe(); } } proc S_D_INST(ul) { switch( ul ) { case "var": case"if": INST (ul); S_S_INST (ul); break; // r3 default : throw new ErreurSyntaxe(); } } Analyseur pour une grammaire LL(1) proc scan(ul, term) { if (ul = term) Lex(ul) ; else throw new ErreurSyntaxe();} proc INST(ul); voir cot proc EXP(ul) ; voir cot proc S_D_INST(ul) voir cot proc S_S_INST(ul) { switch ( ul) { case ";": scan(ul, ";" ); S_D_INST(ul) ; break ; // r4 case"else": case "endif": case ";" : break; // r5 default: throw new ErreurSyntaxe(); } } proc S_D_EXP(ul) { switch ( ul) { case "+": scan(ul, "+" ); EXP(ul) ; break; // r7 case "=" : scan(ul, "=" ); EXP(ul) ; break; // r8 case"then": case"else": cas "endif": case";": break; // r9 default: throw new ErreurSyntaxe(); } } Analyseur pour une grammaire LL(1) proc scan(ul, term) { if (ul = term) Lex(ul) ; else throw new ErreurSyntaxe();} proc INST(ul); voir cot proc EXP(ul) ; voir cot proc S_D_INST(ul) voir cot proc S_S_INST(ul) { switch ( ul) { case ";": scan(ul, ";" ); S_D_INST(ul) ; break ; // r4 case"else": case "endif": case ";" : break; // r5 default: throw new ErreurSyntaxe(); } } proc S_D_EXP(ul) { switch ( ul) { case "+": scan(ul, "+" ); EXP(ul) ; break; // r7 case "=" : scan(ul, "=" ); EXP(ul) ; break; // r8 case"then": case"else": cas "endif": case";": break; // r9 default: throw new ErreurSyntaxe(); } }

    13. Transparent 13 PREMIER() Calcul de Prem(X) si x ? T alors Prem(x) = {x} si {X ? ?} ? P alors ? ? Prem(X) si X ? N et {X ? Y1 ..Yi..Yn } ? P alors calculer la clture des rgles suivantes: Prem(Y1) - ? ? Prem(X) si ? ? Prem(Yj) pour j = 1.. i-1 alors Prem(Yi) - ? ? Prem(X) si ? ? Prem(Yj) pour j = 1 .. n alors ? ? Prem(X) Calcul de Prem(X1 XjXn): Prem(X1) - ? ? Prem(X1 XjXn) si ? ? Prem(Xj) pour j = 1 .. i-1 alors Prem(Xj) - ? ? Prem(X1 XjXn) si ? ? Prem(Xj) pour j = 1 .. n alors ? ? Prem(X1 XjXn) Les Premiers dans une grammaire (ici de longueur 1) Notation: pour tout ? ?(N ?T)+, on note: Prem(? ) = { a ?T si ? ?? a w avec w ? (N ?T)?, et ? si ? ?? ? } ? Interprtation: Prem(?) est l'ensemble des premiers symboles terminaux de tous les mots que l'on peut driver partir de ? ( partir de l'axiome ou non !) Proprit: si une grammaire G ne contient pas de ?-production (rgle A? ?): Vue(A? ?) = Prem(?[1]) ? Exemple: si ? = RSw et R?? ? P : alors Vue(A? ? ) ? Prem(R) et Prem(S) Gnralisation: Premiers de longueur k Premk(? ) = { a ?Tk si ? ?? a w avec w ? (N ?T)?, et ? si ? ?? ? } ? Les Premiers dans une grammaire (ici de longueur 1) Notation: pour tout ? ?(N ?T)+, on note: Prem(? ) = { a ?T si ? ?? a w avec w ? (N ?T)?, et ? si ? ?? ? } ? Interprtation: Prem(?) est l'ensemble des premiers symboles terminaux de tous les mots que l'on peut driver partir de ? ( partir de l'axiome ou non !) Proprit: si une grammaire G ne contient pas de ?-production (rgle A? ?): Vue(A? ?) = Prem(?[1]) ? Exemple: si ? = RSw et R?? ? P : alors Vue(A? ? ) ? Prem(R) et Prem(S) Gnralisation: Premiers de longueur k Premk(? ) = { a ?Tk si ? ?? a w avec w ? (N ?T)?, et ? si ? ?? ? } ?

    14. Transparent 14 PREMIERs de EE'TT'F Cloture Les premiers dans une grammaire si {X ? Y1 ..Yi..Yn } ? P Prem(Y1) - ? ? Prem(X) si ? ? Prem(Yj) pour j = 1.. i-1 alors Prem(Yi) - ? ? Prem(X) si ? ? Prem(Yj) pour j = 1 .. n alors ? ? Prem(X) Les Premiers pour EE'TT'F: (r1) E ? T E' (r2, r3) E' ? + T E' | ? (r4) T ? F T' (r5, r6) T' ? * F T' | ? (r7, r8) F ? ( E ) | id Les premiers dans une grammaire si {X ? Y1 ..Yi..Yn } ? P Prem(Y1) - ? ? Prem(X) si ? ? Prem(Yj) pour j = 1.. i-1 alors Prem(Yi) - ? ? Prem(X) si ? ? Prem(Yj) pour j = 1 .. n alors ? ? Prem(X) Les Premiers pour EE'TT'F: (r1) E ? T E' (r2, r3) E' ? + T E' | ? (r4) T ? F T' (r5, r6) T' ? * F T' | ? (r7, r8) F ? ( E ) | id

    15. Transparent 15 PREMIERs de EE'TT'F Cloture T ? FT' E ? TE' {X ? ?Y?} et ??Prem(?) Les premiers dans une grammaire si {X ? Y1 ..Yi..Yn } ? P Prem(Y1) - ? ? Prem(X) si ? ? Prem(Yj) pour j = 1.. i-1 alors Prem(Yi) - ? ? Prem(X) si ? ? Prem(Yj) pour j = 1 .. n alors ? ? Prem(X) Les Premiers pour EE'TT'F: (r1) E ? T E' (r2, r3) E' ? + T E' | ? (r4) T ? F T' (r5, r6) T' ? * F T' | ? (r7, r8) F ? ( E ) | var Prem(F) = { ( ,var } Prem(E') = { + , ? } Prem(T') = { * , ? } Prem(E, T, F) = { ( ,var } Les premiers dans une grammaire si {X ? Y1 ..Yi..Yn } ? P Prem(Y1) - ? ? Prem(X) si ? ? Prem(Yj) pour j = 1.. i-1 alors Prem(Yi) - ? ? Prem(X) si ? ? Prem(Yj) pour j = 1 .. n alors ? ? Prem(X) Les Premiers pour EE'TT'F: (r1) E ? T E' (r2, r3) E' ? + T E' | ? (r4) T ? F T' (r5, r6) T' ? * F T' | ? (r7, r8) F ? ( E ) | var Prem(F) = { ( ,var } Prem(E') = { + , ? } Prem(T') = { * , ? } Prem(E, T, F) = { ( ,var }

    16. Transparent 16 SUIVANT() Calcul de Suiv(X) si S est l'axiome alors # ? Suiv(S) si A et B ? N et x ? T et {A ? ?Bx} ? P alors x ? Suiv(B) si {A ? ?B?} ? P alors Prem(?) - ? ? Suiv(B) calculer la clture des rgles suivantes: si {A ? ?B} ? P alors Suiv(A) ? Suiv(B) si {A ? ?B?} ? P et ? ? Prem(?) alors Suiv(A) ? Suiv(B) Les suivants dans une grammaire (ici de longueur 1) Notation: pour tout A ?N, on note: Suiv(A) = {a?T? #, S#??uAav avec uv?(N ? T)? } ? Interprtation: Suiv(A) est l'ensemble des symboles terminaux qui peuvent suivre immdiatement A dans une drivation partir de l'axiome. Proprit: soit A? ? une production d'une grammaire G: Vue(A? ? ) =Prem(?) ? Suiv(A) si ? ?? ? Vue(A? ? ) =Prem(?) sinon ? Calcul des suivants dans une grammaire Notation: pour tout ? ?(N ?T)+, on note: Fin(? ) = {X ? N, ? ?? ? X avec ? ? (N ? T)? } ? Interprtation: Fin(? ) est l'ensemble des non terminaux qui peuvent terminer une drivation issue de ? Proprit: x ? T, x ? Suiv(A) <=> il existe X? ?? ? P tel que A ? Fin(?) et x ? Prem(? ) ? Dcidabilit de la proprit LL(1) Thorme: Pour dcider si une grammaire est LL(1) il suffit de calculer les ensembles Prem() et Suiv() et de tester la proprit sur Vue sur l'ensemble des rgles de production : pour toute paire de production A? ? et A? ? , ? ? ? si ? ?? ? => ( Prem(?) ? Suiv(A) ) ? Prem(?) = ? si ? ?? ? => Prem(?) ? ( Prem(?) ? Suiv(A) ) = ? si ni ?, ni ? ?? ? => Prem(?) ? Prem(?) = ? sinon ?, et ? ?? ? => pas LL(1) ?Les suivants dans une grammaire (ici de longueur 1) Notation: pour tout A ?N, on note: Suiv(A) = {a?T? #, S#??uAav avec uv?(N ? T)? } ? Interprtation: Suiv(A) est l'ensemble des symboles terminaux qui peuvent suivre immdiatement A dans une drivation partir de l'axiome. Proprit: soit A? ? une production d'une grammaire G: Vue(A? ? ) =Prem(?) ? Suiv(A) si ? ?? ? Vue(A? ? ) =Prem(?) sinon ? Calcul des suivants dans une grammaire Notation: pour tout ? ?(N ?T)+, on note: Fin(? ) = {X ? N, ? ?? ? X avec ? ? (N ? T)? } ? Interprtation: Fin(? ) est l'ensemble des non terminaux qui peuvent terminer une drivation issue de ? Proprit: x ? T, x ? Suiv(A) <=> il existe X? ?? ? P tel que A ? Fin(?) et x ? Prem(? ) ? Dcidabilit de la proprit LL(1) Thorme: Pour dcider si une grammaire est LL(1) il suffit de calculer les ensembles Prem() et Suiv() et de tester la proprit sur Vue sur l'ensemble des rgles de production : pour toute paire de production A? ? et A? ? , ? ? ? si ? ?? ? => ( Prem(?) ? Suiv(A) ) ? Prem(?) = ? si ? ?? ? => Prem(?) ? ( Prem(?) ? Suiv(A) ) = ? si ni ?, ni ? ?? ? => Prem(?) ? Prem(?) = ? sinon ?, et ? ?? ? => pas LL(1) ?

    17. Transparent 17 SUIVANTs de EE'TT'F Cloture E ? TE' T ? FT' E ? TE' ??Prem(E') T ? FT' ??Prem(T') Suivant() calculer la clture des rgles suivantes: si {A ? ?B?} ? P alors Prem(?) - ? ? Suiv(B) si {A ? ?B} ? P alors Suiv(A) ? Suiv(B) si {A ? ?B?} ? P et ? ? Prem(?) alors Suiv(A) ? Suiv(B) Calcul de Suiv() pour EE'TT'F: (r1) E ? T E' (r2, r3) E' ? + T E' | ? (r4) T ? F T' (r5, r6) T' ? * F T' | ? (r7, r8) F ? ( E ) | id Prem(F) = { ( ,var } Prem(E') = { + , ? } Prem(T') = { * , ? } Prem(E, T, F) = { ( ,var } Suivant() calculer la clture des rgles suivantes: si {A ? ?B?} ? P alors Prem(?) - ? ? Suiv(B) si {A ? ?B} ? P alors Suiv(A) ? Suiv(B) si {A ? ?B?} ? P et ? ? Prem(?) alors Suiv(A) ? Suiv(B) Calcul de Suiv() pour EE'TT'F: (r1) E ? T E' (r2, r3) E' ? + T E' | ? (r4) T ? F T' (r5, r6) T' ? * F T' | ? (r7, r8) F ? ( E ) | id Prem(F) = { ( ,var } Prem(E') = { + , ? } Prem(T') = { * , ? } Prem(E, T, F) = { ( ,var }

    18. Transparent 18 SUIVANTs de EE'TT'F Cloture E ? TE' T ? FT' E ? TE' ??Prem(E') T ? FT' ??Prem(T') Suivant() calculer la clture des rgles suivantes: si {A ? ?B?} ? P alors Prem(?) - ? ? Suiv(B) si {A ? ?B} ? P alors Suiv(A) ? Suiv(B) si {A ? ?B?} ? P et ? ? Prem(?) alors Suiv(A) ? Suiv(B) Calcul de Suiv() pour EE'TT'F: (r0) E0 ? E # (r1) E ? T E' (r2, r3) E' ? + T E' | ? (r4) T ? F T' (r5, r6) T' ? * F T' | ? (r7, r8) F ? ( E ) | id Prem(F) = { ( ,var } Prem(E') = { + , ? } Prem(T') = { * , ? } Prem(E, T, F) = { ( ,var } Suiv(E) = Suiv(E') = { ) , # } Suiv(T) = Suiv(T') = {+ ,) , # } Suiv(F) = { *, + ,) , # } Suivant() calculer la clture des rgles suivantes: si {A ? ?B?} ? P alors Prem(?) - ? ? Suiv(B) si {A ? ?B} ? P alors Suiv(A) ? Suiv(B) si {A ? ?B?} ? P et ? ? Prem(?) alors Suiv(A) ? Suiv(B) Calcul de Suiv() pour EE'TT'F: (r0) E0 ? E # (r1) E ? T E' (r2, r3) E' ? + T E' | ? (r4) T ? F T' (r5, r6) T' ? * F T' | ? (r7, r8) F ? ( E ) | id Prem(F) = { ( ,var } Prem(E') = { + , ? } Prem(T') = { * , ? } Prem(E, T, F) = { ( ,var } Suiv(E) = Suiv(E') = { ) , # } Suiv(T) = Suiv(T') = {+ ,) , # } Suiv(F) = { *, + ,) , # }

    19. Transparent 19 Gnration des Tables LL(1) pour chaque {A ? ?} ? P { pour chaque a ? T, a ? Prem(?) { M[A, a] += {A ? ?} } si ? ? Prem(?) alors { pour chaque b ? T, b ? Suiv(A) { M[A, b] += {A ? ?} } si # ? Suiv(A) alors M[A, #] += {A ? ?} } } toute entre non dfinie dans M est une "erreur" M[$, #] = "accepter" Construction des Tables LL(1) Donnes: une grammaire G, suppose LL(1). La construction permet de vrifier la proprit Rsultat: une table d'analyse LL(1) pour un analyseur prdictif Mthode: Prem() et Suiv() permettent de construire une table d'analyse M pour un analyseur prdictif M : (N ? {$}) x (T ? {#}) ? P ? {erreur, accepter} Proprit: La grammaire est LL(1) ssi M[A, a] contient au plus une action pour tout A et a? Construction des Tables LL(1) Donnes: une grammaire G, suppose LL(1). La construction permet de vrifier la proprit Rsultat: une table d'analyse LL(1) pour un analyseur prdictif Mthode: Prem() et Suiv() permettent de construire une table d'analyse M pour un analyseur prdictif M : (N ? {$}) x (T ? {#}) ? P ? {erreur, accepter} Proprit: La grammaire est LL(1) ssi M[A, a] contient au plus une action pour tout A et a?

    20. Transparent 20 Table LL(1) pour EE'TT'F PREMIERS SUIVANTS Construction des Tables LL(1) Donnes: une grammaire G, suppose LL(1). La construction permet de vrifier la proprit Rsultat: une table d'analyse LL(1) pour un analyseur prdictif Mthode: Prem() et Suiv() permettent de construire une table d'analyse M pour un analyseur prdictif M : (N ? {$}) x (T ? {#}) ? P ? {erreur, accepter} Proprit: La grammaire est LL(1) ssi M[A, a] contient au plus une action pour tout A et a? Table LL(1) pour EE'TT'F: (r1) E ? T E' (r2, r3) E' ? + T E' | ? (r4) T ? F T' (r5, r6) T' ? * F T' | ? (r7, r8) F ? ( E ) | var Construction des Tables LL(1) Donnes: une grammaire G, suppose LL(1). La construction permet de vrifier la proprit Rsultat: une table d'analyse LL(1) pour un analyseur prdictif Mthode: Prem() et Suiv() permettent de construire une table d'analyse M pour un analyseur prdictif M : (N ? {$}) x (T ? {#}) ? P ? {erreur, accepter} Proprit: La grammaire est LL(1) ssi M[A, a] contient au plus une action pour tout A et a? Table LL(1) pour EE'TT'F: (r1) E ? T E' (r2, r3) E' ? + T E' | ? (r4) T ? F T' (r5, r6) T' ? * F T' | ? (r7, r8) F ? ( E ) | var

    21. Transparent 21 Table LL(1) pour EE'TT'F PREMIERS Prem(E) = Prem(T) = Prem(F) = { var , ( } Prem(E') = { +, ? } Prem(T') = { *, ? } SUIVANTS Suiv(E) = Suiv(E') = { ) , # } Suiv(T) = Suiv(T') = {+ ,) ,# } Suiv(F) = { *, + ,) , #} Construction des Tables LL(1) Donnes: une grammaire G, suppose LL(1). La construction permet de vrifier la proprit Rsultat: une table d'analyse LL(1) pour un analyseur prdictif Mthode: Prem() et Suiv() permettent de construire une table d'analyse M pour un analyseur prdictif M : (N ? {$}) x (T ? {#}) ? P ? {erreur, accepter} Proprit: La grammaire est LL(1) ssi M[A, a] contient au plus une action pour tout A et a? Table LL(1) pour EE'TT'F: (r1) E ? T E' (r2, r3) E' ? + T E' | ? (r4) T ? F T' (r5, r6) T' ? * F T' | ? (r7, r8) F ? ( E ) | var Construction des Tables LL(1) Donnes: une grammaire G, suppose LL(1). La construction permet de vrifier la proprit Rsultat: une table d'analyse LL(1) pour un analyseur prdictif Mthode: Prem() et Suiv() permettent de construire une table d'analyse M pour un analyseur prdictif M : (N ? {$}) x (T ? {#}) ? P ? {erreur, accepter} Proprit: La grammaire est LL(1) ssi M[A, a] contient au plus une action pour tout A et a? Table LL(1) pour EE'TT'F: (r1) E ? T E' (r2, r3) E' ? + T E' | ? (r4) T ? F T' (r5, r6) T' ? * F T' | ? (r7, r8) F ? ( E ) | var

    22. Transparent 22 Table LL(1) pour INST' Construction des Tables LL(1) Donnes: une grammaire G, suppose LL(1). La construction permet de vrifier la proprit Rsultat: une table d'analyse LL(1) pour un analyseur prdictif Mthode: Prem() et Suiv() permettent de construire une table d'analyse M pour un analyseur prdictif M : (N ? {$}) x (T ? {#}) ? P ? {erreur, accepter} Proprit: La grammaire est LL(1) ssi M[A, a] contient au plus une action pour tout A et a? Table LL(1) pour INST' inst ::= var := exp (r1) inst ::= if exp then s_d_inst else s_d_inst endif (r2) s_d_inst ::= inst s_s_inst (r3) s_s_inst ::= ; s_d_inst | ? (r4 r5) exp ::= var s_d_exp (r6) s_d_exp ::= + exp | = exp | ? (r7 r8 r9) Construction des Tables LL(1) Donnes: une grammaire G, suppose LL(1). La construction permet de vrifier la proprit Rsultat: une table d'analyse LL(1) pour un analyseur prdictif Mthode: Prem() et Suiv() permettent de construire une table d'analyse M pour un analyseur prdictif M : (N ? {$}) x (T ? {#}) ? P ? {erreur, accepter} Proprit: La grammaire est LL(1) ssi M[A, a] contient au plus une action pour tout A et a? Table LL(1) pour INST' inst ::= var := exp (r1) inst ::= if exp then s_d_inst else s_d_inst endif (r2) s_d_inst ::= inst s_s_inst (r3) s_s_inst ::= ; s_d_inst | ? (r4 r5) exp ::= var s_d_exp (r6) s_d_exp ::= + exp | = exp | ? (r7 r8 r9)

    23. Transparent 23 Table LL(1) pour INST' Construction des Tables LL(1) Donnes: une grammaire G, suppose LL(1). La construction permet de vrifier la proprit Rsultat: une table d'analyse LL(1) pour un analyseur prdictif Mthode: Prem() et Suiv() permettent de construire une table d'analyse M pour un analyseur prdictif M : (N ? {$}) x (T ? {#}) ? P ? {erreur, accepter} Proprit: La grammaire est LL(1) ssi M[A, a] contient au plus une action pour tout A et a? Table LL(1) pour INST' inst ::= var := exp (r1) inst ::= if exp then s_d_inst else s_d_inst endif (r2) s_d_inst ::= inst s_s_inst (r3) s_s_inst ::= ; s_d_inst | ? (r4 r5) exp ::= var s_d_exp (r6) s_d_exp ::= + exp | = exp | ? (r7 r8 r9) Construction des Tables LL(1) Donnes: une grammaire G, suppose LL(1). La construction permet de vrifier la proprit Rsultat: une table d'analyse LL(1) pour un analyseur prdictif Mthode: Prem() et Suiv() permettent de construire une table d'analyse M pour un analyseur prdictif M : (N ? {$}) x (T ? {#}) ? P ? {erreur, accepter} Proprit: La grammaire est LL(1) ssi M[A, a] contient au plus une action pour tout A et a? Table LL(1) pour INST' inst ::= var := exp (r1) inst ::= if exp then s_d_inst else s_d_inst endif (r2) s_d_inst ::= inst s_s_inst (r3) s_s_inst ::= ; s_d_inst | ? (r4 r5) exp ::= var s_d_exp (r6) s_d_exp ::= + exp | = exp | ? (r7 r8 r9)

    24. Transparent 24 Analyse descendante LL(1) Source ? if v1= v2 then v3 := v4 + v5 ; if v3= v4 then v5 := v1= v4 else v3 := v4 endif ; v7 := v8 else v3 := v4 endif # Grammaire INST aprs factorisation gauche inst ::= var := exp (r1) inst ::= if exp then s_d_inst else s_d_inst endif (r2) s_d_inst ::= inst s_s_inst (r3) s_s_inst ::= ; s_d_inst | ? (r4 r5) exp ::= var s_d_exp (r6) s_d_ exp ::= + exp | = exp | ? (r7 r8 r9) Analyse LL(1) du source if v1= v2 then v3 := v4 + v5 ; if v3= v4 then v5 := v1= v4 else v3 := v4 endif ; v7 := v8 else v3 := v4 endif #Grammaire INST aprs factorisation gauche inst ::= var := exp (r1) inst ::= if exp then s_d_inst else s_d_inst endif (r2) s_d_inst ::= inst s_s_inst (r3) s_s_inst ::= ; s_d_inst | ? (r4 r5) exp ::= var s_d_exp (r6) s_d_ exp ::= + exp | = exp | ? (r7 r8 r9) Analyse LL(1) du source if v1= v2 then v3 := v4 + v5 ; if v3= v4 then v5 := v1= v4 else v3 := v4 endif ; v7 := v8 else v3 := v4 endif #

    25. Transparent 25 Analyseur gnrique LL(1) Actions procedure Action(u: LEX; X: N_ou_T) { if (X = u ) { Dep(X) ; Lex(u) ; } else switch (M(u, X)) { case "A ? ? " : Dep(X) ; Emp(miroir(? )) ; break ; case "A ? ?" : Dep(X) ; break ; case "succs" : break ; case "erreur" : throw new Erreur() ; } } Analyseur function Analyse() { Lex(ul); Emp(Axiome); while (ul != "#") { Action(ul, Som()) ; } return succes ; } Dcidabilit sur les grammaires LL() Thorme: La proprit LL(k) d'une grammaire est indcidable (pour k non fix) ? Corollaire: Il n'existe pas d'algorithme permettant de transformer une grammaire quelconque en une grammaire quivalente LL(k) ; mais on peut toujours essayer sur une grammaire donne! Thorme: Une grammaire LL(1) est non ambigu preuve: d'aprs la proprit LL(1) il ne peut exister deux drivations distinctes pour deux mots identiques ? gnralisation: ce rsultat est vrai pour les grammaires LL(k) ? Complexit de l'analyse LL() Thorme: Le test LL(1) et la construction de la table d'analyse est en O( |P|*|T|*|N| ) preuve: d'aprs le calcul de Prem() et Suiv() et la construction prcdente ? gnralisation: ce rsultat est vrai pour l'analyse LL(k) ? Thorme: L'analyse LL(1) d'un mot m est en O(|m|) preuve: directement d'aprs le code ci-contre ? gnralisation: ce rsultat est vrai pour l'analyse LL(k) ? Langages LL() Thorme: La proprit LL(k) d'un langage est indcidable (pour k non fix) ? Thorme: LL(1) ?... ? LL(k) ? ALG DETERMINISTE ? Dcidabilit sur les grammaires LL() Thorme: La proprit LL(k) d'une grammaire est indcidable (pour k non fix) ? Corollaire: Il n'existe pas d'algorithme permettant de transformer une grammaire quelconque en une grammaire quivalente LL(k) ; mais on peut toujours essayer sur une grammaire donne! Thorme: Une grammaire LL(1) est non ambigu preuve: d'aprs la proprit LL(1) il ne peut exister deux drivations distinctes pour deux mots identiques ? gnralisation: ce rsultat est vrai pour les grammaires LL(k) ? Complexit de l'analyse LL() Thorme: Le test LL(1) et la construction de la table d'analyse est en O( |P|*|T|*|N| ) preuve: d'aprs le calcul de Prem() et Suiv() et la construction prcdente ? gnralisation: ce rsultat est vrai pour l'analyse LL(k) ? Thorme: L'analyse LL(1) d'un mot m est en O(|m|) preuve: directement d'aprs le code ci-contre ? gnralisation: ce rsultat est vrai pour l'analyse LL(k) ? Langages LL() Thorme: La proprit LL(k) d'un langage est indcidable (pour k non fix) ? Thorme: LL(1) ?... ? LL(k) ? ALG DETERMINISTE ?

    26. 26 Chapitre 6 Analyse syntaxique ascendante mthodes LR(k) Analyse Ascendante Proprit LR(k) Grammaire SLR, LR(1), LALR(1) Analyseur LR(1) Gnrateur syntaxique LR(1)

    27. Transparent 27 Analyse Ascendante Principe le mot x analyser dans T* est lu une seule fois de gauche droite on construit un arbre de drivation en montant des feuilles (= x ) vers la racine = axiome Mthode par dcalage ou rduction rduire par une drivation droite inverse se dcaler sur X Principe de l'Analyse Ascendante le mot X analyser dans T* est lu une seule fois de gauche droite on construit un arbre de drivation en montant des feuilles (mot des feuilles = X) vers la racine=axiome en assemblant des sous arbres d'analyse on "remonte" les drivations en utilisant les rgles A?? de P de la droite vers la gauche (Pile), cad ? (au Sommet) est rduit en A: on dit que l'on rduit ? Mthode dcalage-rduction on gre un mot w dans (N ? T)+ comme le mot des racines des sous arbres d'analyse dj construits pris de gauche droite lorsque w = u o u ? (N ? T)* et P ne contient pas de rgle A?u , l'analyseur avance dans la lecture de X la lettre suivante x et donc w = u x lorsque w = u? o u ? (N ? T)* et ? est une partie droite de rgles A?? dans P (plusieurs ? possibles, car dcomposition de w = u? non unique) , l'analyseur doit pouvoir dcider: s'il y a lieu de rduire w en uA et par quelle rgle de P ? s'il y a lieu d'avancer dans la lecture du mot X la lettre suivante x et donc w = u? x Proprit: la suite de drivations utilises pour rduire un mot X correspond la suite inverse des drivations les + droites (Rightmost) pour produire XPrincipe de l'Analyse Ascendante le mot X analyser dans T* est lu une seule fois de gauche droite on construit un arbre de drivation en montant des feuilles (mot des feuilles = X) vers la racine=axiome en assemblant des sous arbres d'analyse on "remonte" les drivations en utilisant les rgles A?? de P de la droite vers la gauche (Pile), cad ? (au Sommet) est rduit en A: on dit que l'on rduit ? Mthode dcalage-rduction on gre un mot w dans (N ? T)+ comme le mot des racines des sous arbres d'analyse dj construits pris de gauche droite lorsque w = u o u ? (N ? T)* et P ne contient pas de rgle A?u , l'analyseur avance dans la lecture de X la lettre suivante x et donc w = u x lorsque w = u? o u ? (N ? T)* et ? est une partie droite de rgles A?? dans P (plusieurs ? possibles, car dcomposition de w = u? non unique) , l'analyseur doit pouvoir dcider: s'il y a lieu de rduire w en uA et par quelle rgle de P ? s'il y a lieu d'avancer dans la lecture du mot X la lettre suivante x et donc w = u? x Proprit: la suite de drivations utilises pour rduire un mot X correspond la suite inverse des drivations les + droites (Rightmost) pour produire X

    28. Transparent 28 Analyse Ascendante Dterministe Grammaire ETF E ::= E + T | T (r1 r2) T ::= T * F | F (r3 r4) F ::= var | ( E ) (r5 r6) Analyse dterministe? v1 + v2 * v3 v1 + v2 * v3 v1 + v2 * v3 Suite de drivations et Analyse Drivations gauches: E ?g E + T ?g T + T ?g F + T ?g v1 + T ?g v1 + T * F ?g v1 + F * F ?g v1 + v2 * F ?g v1 + v2 * v3 Drivations droites: E ?d E + T ?d E + T * F ?d E + T * v3 ?d E + F * v3 ?d E + v2 * v3 ?d T + v2 * v3 ?d F + v2 * v3 ?d v1 + v2 * v3 Manche (traduction pour "handle") Dfinition: ? ? (N ? T)* est une forme sententielle droite (fsd) dans une grammaire G si S *?d ? ? Dfinition: ? ? (N ? T)* est appel manche dans une fsd ? si ? = g ? x o x ? T* et g A x est une fsd avec A?? ? P Les Manches (des fsg et fsd) sont souligns dans les drivations ci-dessus ? Gnration ou Analyse "descendante" d'un mot: on "descend" les drivations gauches; v1 est le premier manche ?T* produit et v3 le dernier ; en symtrisant la dfinition de manche pour d'une fsg: le manche est prcd d'un mot terminal ?T* et provient d'une fsg Analyse "ascendante" d'un mot: on "remonte" les drivations droites o v3 est le premier manche ?T* rduit et v1 le dernier; le manche est suivi d'un mot terminal ?T* et provient d'une fsdSuite de drivations et Analyse Drivations gauches: E ?g E + T ?g T + T ?g F + T ?g v1 + T ?g v1 + T * F ?g v1 + F * F ?g v1 + v2 * F ?g v1 + v2 * v3 Drivations droites: E ?d E + T ?d E + T * F ?d E + T * v3 ?d E + F * v3 ?d E + v2 * v3 ?d T + v2 * v3 ?d F + v2 * v3 ?d v1 + v2 * v3 Manche (traduction pour "handle") Dfinition: ? ? (N ? T)* est une forme sententielle droite (fsd) dans une grammaire G si S *?d ? ? Dfinition: ? ? (N ? T)* est appel manche dans une fsd ? si ? = g ? x o x ? T* et g A x est une fsd avec A?? ? P Les Manches (des fsg et fsd) sont souligns dans les drivations ci-dessus ? Gnration ou Analyse "descendante" d'un mot: on "descend" les drivations gauches; v1 est le premier manche ?T* produit et v3 le dernier ; en symtrisant la dfinition de manche pour d'une fsg: le manche est prcd d'un mot terminal ?T* et provient d'une fsg Analyse "ascendante" d'un mot: on "remonte" les drivations droites o v3 est le premier manche ?T* rduit et v1 le dernier; le manche est suivi d'un mot terminal ?T* et provient d'une fsd

    29. Transparent 29 Un manche ou LE manche ? Grammaire ambigu des expressions E ::= E + E | E * E (r1 r2) E ::= var | ( E ) (r3 r4) Des Manches diffrents v1 + v2 * v3 v1 + v2 * v3 Un Manche ou LE Manche ? Proprit: si une grammaire est non ambigu, toute fsd a exactement un manche ? Exemple d'ambigut: Deux Drivations droites distinctes: E ?d E + E ?d E + E * E ?d E + E * v3 ?d E + v2 * v3 ?d v1 + v2 * v3 E ?d E * E ?d E * v3 ?d E + E * v3 ?d E + v2 * v3 ?d v1 + v2 * v3 Un Manche ou LE Manche ? Proprit: si une grammaire est non ambigu, toute fsd a exactement un manche ? Exemple d'ambigut: Deux Drivations droites distinctes: E ?d E + E ?d E + E * E ?d E + E * v3 ?d E + v2 * v3 ?d v1 + v2 * v3 E ?d E * E ?d E * v3 ?d E + E * v3 ?d E + v2 * v3 ?d v1 + v2 * v3

    30. Transparent 30 Analyseur par Dcalage-Rduction Schma simplifi Analyseur par Dcalage - Rduction Dfinition: un ADR pour une grammaire G se compose de : un tampon d'entre pour les lexmes dans T*, termin par # une pile M de symboles dans (N ? T)*, initialement vide. une sortie pour produire la drivation (ou l'arbre de) une table A gnre pour G, avec 4 actions {M} ? { D, R, ac, er} Dcaler "shift": empile dans M le symbole courant de l'entre avancer d'un symbole en entre Rduire "reduce": dpiler le manche dans M (p symboles en sommet de pile) empile dans M le non terminal de la rduction du manche Accepter: si M contient l'axiome et que l'entre contient # Erreur: si pas d'action prvue dans A un analyseur indpendant de la grammaire G excutant A en boucle, jusqu' Accepter ou Erreur ? Conflits pour un ADR L'implmentation d'un ADR consiste rgler deux sortes de choix : conflit dcaler ou rduire ("shift/reduce" terminologie Yacc) conflit rduire r1 ou rduire r2 ("reduce/reduce" sous Yacc) Divers ADRs: analyseurs LR(k), LALR(k) , SLR(k) analyseurs par prcdence d'oprateurs Analyseur par Dcalage - Rduction Dfinition: un ADR pour une grammaire G se compose de : un tampon d'entre pour les lexmes dans T*, termin par # une pile M de symboles dans (N ? T)*, initialement vide. une sortie pour produire la drivation (ou l'arbre de) une table A gnre pour G, avec 4 actions {M} ? { D, R, ac, er} Dcaler "shift": empile dans M le symbole courant de l'entre avancer d'un symbole en entre Rduire "reduce": dpiler le manche dans M (p symboles en sommet de pile) empile dans M le non terminal de la rduction du manche Accepter: si M contient l'axiome et que l'entre contient # Erreur: si pas d'action prvue dans A un analyseur indpendant de la grammaire G excutant A en boucle, jusqu' Accepter ou Erreur ? Conflits pour un ADR L'implmentation d'un ADR consiste rgler deux sortes de choix : conflit dcaler ou rduire ("shift/reduce" terminologie Yacc) conflit rduire r1 ou rduire r2 ("reduce/reduce" sous Yacc) Divers ADRs: analyseurs LR(k), LALR(k) , SLR(k) analyseurs par prcdence d'oprateurs

    31. Transparent 31 Analyse par dcalage-rduction dans ETF Source dans ETF v1 + v2 * v3 # Analyse ADR Grammaire ETF rcursive gauche (r1, r2) E ? E + T | T (r3, r4) T ? T * F | F (r5, r6) F ? var | ( E ) Analyse ADR "remonter" la drivation droite: E ?d E + T ?d E + T * F ?d E + T * v3 ?d E + F * v3 ?d E + v2 * v3 ?d T + v2 * v3 ?d F + v2 * v3 ?d v1 + v2 * v3 Les conflits se rsolvent comme suit: rduire v1 par r5 (au lieu de dcaler), car il n'existe pas de manche contenant var + rduire F par r4 (au lieu de dcaler), car il n'existe pas de manche contenant F + rduire T par r2 (au lieu de dcaler), car il n'existe pas de manche contenant T + rduire v2 par r5 (au lieu de dcaler), car il n'existe pas de manche contenant var * rduire F par r4 (au lieu de dcaler), car il n'existe pas de manche contenant F * rduire v3 par r5 (au lieu de dcaler), car il n'existe pas de manche contenant var # rduire T*F par r3 (au lieu de dcaler), car il n'existe pas de manche contenant T*F # rduire E+T par r1 (au lieu de dcaler), car il n'existe pas de manche contenant E+T # Grammaire ETF rcursive gauche (r1, r2) E ? E + T | T (r3, r4) T ? T * F | F (r5, r6) F ? var | ( E ) Analyse ADR "remonter" la drivation droite: E ?d E + T ?d E + T * F ?d E + T * v3 ?d E + F * v3 ?d E + v2 * v3 ?d T + v2 * v3 ?d F + v2 * v3 ?d v1 + v2 * v3 Les conflits se rsolvent comme suit: rduire v1 par r5 (au lieu de dcaler), car il n'existe pas de manche contenant var + rduire F par r4 (au lieu de dcaler), car il n'existe pas de manche contenant F + rduire T par r2 (au lieu de dcaler), car il n'existe pas de manche contenant T + rduire v2 par r5 (au lieu de dcaler), car il n'existe pas de manche contenant var * rduire F par r4 (au lieu de dcaler), car il n'existe pas de manche contenant F * rduire v3 par r5 (au lieu de dcaler), car il n'existe pas de manche contenant var # rduire T*F par r3 (au lieu de dcaler), car il n'existe pas de manche contenant T*F # rduire E+T par r1 (au lieu de dcaler), car il n'existe pas de manche contenant E+T #

    32. Transparent 32 Analyse par dcalage-rduction dans ETF Source dans ETF v1 + v2 * v3 # Analyse ADR Grammaire ETF rcursive gauche (r1, r2) E ? E + T | T (r3, r4) T ? T * F | F (r5, r6) F ? var | ( E ) Analyse ADR Le tableau ci-contre donne les tats successifs d'un analyseur ADR pour le mot : v1 + v2 * v3 # . On "remonte" la drivation droite: E ?d E + T ?d E + T * F ?d E + T * v3 ?d E + F * v3 ?d E + v2 * v3 ?d T + v2 * v3 ?d F + v2 * v3 ?d v1 + v2 * v3 Les conflits ont t rsolus comme suit: rduire v1 par r5 (au lieu de dcaler), car il n'existe pas de manche contenant var + rduire F par r4 (au lieu de dcaler), car il n'existe pas de manche contenant F + rduire T par r2 (au lieu de dcaler), car il n'existe pas de manche contenant T + rduire v2 par r5 (au lieu de dcaler), car il n'existe pas de manche contenant var * rduire F par r4 (au lieu de dcaler), car il n'existe pas de manche contenant F * rduire v3 par r5 (au lieu de dcaler), car il n'existe pas de manche contenant var # rduire T*F par r3 (au lieu de dcaler), car il n'existe pas de manche contenant T*F # rduire E+T par r1 (au lieu de dcaler), car il n'existe pas de manche contenant E+T # Grammaire ETF rcursive gauche (r1, r2) E ? E + T | T (r3, r4) T ? T * F | F (r5, r6) F ? var | ( E ) Analyse ADR Le tableau ci-contre donne les tats successifs d'un analyseur ADR pour le mot : v1 + v2 * v3 # . On "remonte" la drivation droite: E ?d E + T ?d E + T * F ?d E + T * v3 ?d E + F * v3 ?d E + v2 * v3 ?d T + v2 * v3 ?d F + v2 * v3 ?d v1 + v2 * v3 Les conflits ont t rsolus comme suit: rduire v1 par r5 (au lieu de dcaler), car il n'existe pas de manche contenant var + rduire F par r4 (au lieu de dcaler), car il n'existe pas de manche contenant F + rduire T par r2 (au lieu de dcaler), car il n'existe pas de manche contenant T + rduire v2 par r5 (au lieu de dcaler), car il n'existe pas de manche contenant var * rduire F par r4 (au lieu de dcaler), car il n'existe pas de manche contenant F * rduire v3 par r5 (au lieu de dcaler), car il n'existe pas de manche contenant var # rduire T*F par r3 (au lieu de dcaler), car il n'existe pas de manche contenant T*F # rduire E+T par r1 (au lieu de dcaler), car il n'existe pas de manche contenant E+T #

    33. Transparent 33 Proprit LR(k) il existe k? 0 dpendant uniquement de la grammaire tel que: pour tout mot X analyser dans T* pour toute fsd F= ? ? a w dans (N ? T)* et tout manche ? il existe au plus une rgle A? ? dans P telle que ? A a w est une fsd Intitul LR(k) Lecture du mot de gauche droite("Left to Right") Drivations (les + ) droites ("Rightmost") Proprit LR(k) des grammaires Dfinition: une grammaire est LR(k) ssi pour ?, ?, ?, ? ?(N ? T)*; A, B ?N ; a ?Tk ; w, w'? T* si S *?d ? A aw ?d ? ? a w et si S *?d ? B w' ?d ? ?' w' = ? ? a ? alors A=B , ? =?' , ? = ? et w'=a ? Note: ? est un manche des deux fsd ? ? aw et ? ?' w' ? Proprit: une grammaire LR(k) est LR(k') pour k' > k ? Grammaire LR(1) La dfinition prcdente donne celle des: LR(0) en prenant a = ? LR(1) en prenant a ?T ? Intitul LR(k) Lecture du mot de gauche droite("Left to Right") Drivations (les + ) droites ("Rightmost") Proprit LR(k) des grammaires Dfinition: une grammaire est LR(k) ssi pour ?, ?, ?, ? ?(N ? T)*; A, B ?N ; a ?Tk ; w, w'? T* si S *?d ? A aw ?d ? ? a w et si S *?d ? B w' ?d ? ?' w' = ? ? a ? alors A=B , ? =?' , ? = ? et w'=a ? Note: ? est un manche des deux fsd ? ? aw et ? ?' w' ? Proprit: une grammaire LR(k) est LR(k') pour k' > k ? Grammaire LR(1) La dfinition prcdente donne celle des: LR(0) en prenant a = ? LR(1) en prenant a ?T ?

    34. Transparent 34 ETF est elle LR(0) ? Grammaire ETF E ::= E + T | T (r1 r2) T ::= T * F | F (r3 r4) F ::= var | ( E ) (r5 r6) pas LR(0) , mais LR(1) ? La dcision peut dpendre du prochain terminal lire (look ahead) v1 + v2 + v3 v1 + v2 * v3 Une grammaire est elle LR(k) ? En pratique on considre les grammaires LR(0) ou LR(1) Intuitivement, la proprit est vraie si la connaissance de k terminaux aprs le caractre courant (look-ahead) permet de dcider de manire unique comment traiter le manche. La dfinition prcdente est difficile utiliser pour prouver la proprit; par contre, on peut exhiber un contre-exemple de drivations pour prouver l'absence de cette proprit. La construction de l'analyseur LR(k) donne ci aprs permet de rpondre la mme question. ETF est elle LR(0) ? Intuitivement, la rponse est NON Formellement: on considre deux drivations droites: E ?d E + T ?d E + F ?d E + v3 ?d E + T + v3 avec ? =a= ? , A = E , ? = E+T, w = + v3 E ?d E + T ?dE + T * F avec ? = E+, B = T, ?' = T*F, w'= ? et ? ?' w' = ? ? a ? = E+T*F avec ? = *F voir aussi l'analyse des items canoniques de l'analyseur SLR Une grammaire est elle LR(k) ? En pratique on considre les grammaires LR(0) ou LR(1) Intuitivement, la proprit est vraie si la connaissance de k terminaux aprs le caractre courant (look-ahead) permet de dcider de manire unique comment traiter le manche. La dfinition prcdente est difficile utiliser pour prouver la proprit; par contre, on peut exhiber un contre-exemple de drivations pour prouver l'absence de cette proprit. La construction de l'analyseur LR(k) donne ci aprs permet de rpondre la mme question. ETF est elle LR(0) ? Intuitivement, la rponse est NON Formellement: on considre deux drivations droites: E ?d E + T ?d E + F ?d E + v3 ?d E + T + v3 avec ? =a= ? , A = E , ? = E+T, w = + v3 E ?d E + T ?dE + T * F avec ? = E+, B = T, ?' = T*F, w'= ? et ? ?' w' = ? ? a ? = E+T*F avec ? = *F voir aussi l'analyse des items canoniques de l'analyseur SLR

    35. Transparent 35 Les langages de mots de pile Grammaire Dyck des () D ::= D D (r1) | a D b (r2) | a b (r3) Langage des Contextes Gauches CG = {?, ? D est un prfixe viable de Dyck} CG ::= CG D ( par r1) | CG a ( par r2) | ? ( par r3) => CG = (D | a)* Langage des Prfixes Viables PV est le langage des mots de pile ADR PV ::= CG D + CG D D | CG a + CG a D + CG a D b | CG a + CG a b => PV ? RAT Comment trouver le Manche ? Les analyseurs ADR utilisent pour reprer les manches une proprit fondamentale des grammaires algbriques: le langage des prfixes des fsd , cad les mots de pile d'un ADR, est rationnel. Dfinition: Tout prfixe p= ? u de ? ? dans une fsd F= ? ? w o ? est le manche est dit prfixe viable de F Remarque: p dborde le dbut du manche ?, mais pas la fin Proprit: Les prfixes viables forment l'ensemble des mots qui peuvent apparatre dans la pile lors d'une ADR ? Thorme: Le langage des prfixes viables d'une grammaire algbrique est un langage rationnel Preuve: voir la construction de l'automate des prfixes viables SLR ? Rsolution ADR: l'analyseur ADR utilise un automate d'tat fini pour reprer les manches. Comment trouver le Manche ? Les analyseurs ADR utilisent pour reprer les manches une proprit fondamentale des grammaires algbriques: le langage des prfixes des fsd , cad les mots de pile d'un ADR, est rationnel. Dfinition: Tout prfixe p= ? u de ? ? dans une fsd F= ? ? w o ? est le manche est dit prfixe viable de F Remarque: p dborde le dbut du manche ?, mais pas la fin Proprit: Les prfixes viables forment l'ensemble des mots qui peuvent apparatre dans la pile lors d'une ADR ? Thorme: Le langage des prfixes viables d'une grammaire algbrique est un langage rationnel Preuve: voir la construction de l'automate des prfixes viables SLR ? Rsolution ADR: l'analyseur ADR utilise un automate d'tat fini pour reprer les manches.

    36. Transparent 36 Analyseur LR Schma conceptuel Analyseur LR Dfinition: un ALR pour une grammaire G se compose de : un tampon d'entre pour les lexmes analyser dans T*, termin par # une pile M de symboles dans (N ? T)*, initialement vide. une pile E d'tats de l'automate fini PV , initialement avec un tat initial une sortie pour produire la drivation (ou l'arbre de) une table de transition T[{e}, N ? T] ? {e} pour les tats de PV une table A gnre pour G, avec 4 actions {M} ? { D, R, A, E} Dcaler: empile dans M le symbole courant de l'entre empile dans E l'tat atteint = T[etat_courant, som(M)] avancer d'un symbole en entre Rduire: dpiler le manche dans M (p symboles en sommet de pile) dpiler p tats dans E empile dans M le non terminal de la rduction du manche empile dans E l'tat atteint = T[etat_courant, som(M)] Accepter: si M = {l'axiome} et que l'entre = {#} Erreur: si pas d'action prvue dans A un analyseur indpendant de la grammaire G excutant A en boucle, jusqu' pile ou entre vide ?Analyseur LR Dfinition: un ALR pour une grammaire G se compose de : un tampon d'entre pour les lexmes analyser dans T*, termin par # une pile M de symboles dans (N ? T)*, initialement vide. une pile E d'tats de l'automate fini PV , initialement avec un tat initial une sortie pour produire la drivation (ou l'arbre de) une table de transition T[{e}, N ? T] ? {e} pour les tats de PV une table A gnre pour G, avec 4 actions {M} ? { D, R, A, E} Dcaler: empile dans M le symbole courant de l'entre empile dans E l'tat atteint = T[etat_courant, som(M)] avancer d'un symbole en entre Rduire: dpiler le manche dans M (p symboles en sommet de pile) dpiler p tats dans E empile dans M le non terminal de la rduction du manche empile dans E l'tat atteint = T[etat_courant, som(M)] Accepter: si M = {l'axiome} et que l'entre = {#} Erreur: si pas d'action prvue dans A un analyseur indpendant de la grammaire G excutant A en boucle, jusqu' pile ou entre vide ?

    37. Transparent 37 Analyseur gnrique LR(1) Actions boolean Action(LEX u) { Etat e = som().etat() ; switch (A[e, u] ){ "dcaler " => e' = T[e, u] ; emp(u, e') ; lex(u) ; break; " rduire A? m" => e = som().etat() ; dep(e, m) ; emp("A", T[e, "A"] ) ; "succs" => return true; "erreur" => return false ; } } Analyseur function Analyse() { lex(ul); emp(Fond, Etat_Initial); while ul /= "#" { succes=Action(ul) } return succes ; } Grammaires LR() Proprit (rappel): pour k' > k >= 0, LR(k) => LR(k') ? Thorme: La proprit LR(k) d'une grammaire est indcidable (pour k non fix) ? Corollaire: Il n'existe pas d'algorithme permettant de transformer une grammaire quelconque en une grammaire quivalente LR(k) ; mais on peut toujours essayer sur une grammaire donne! Thorme: Une grammaire LR(1) est non ambigu preuve: d'aprs la proprit LR(1) il ne peut exister deux drivations distinctes pour deux mots identiques ? gnralisation: ce rsultat est vrai pour les grammaires LR(k) ? Complexit de l'analyse LR() Thorme: L'analyse LR(1) d'un mot m est en O(|m|) preuve: d'aprs le code ci-contre ? gnralisation: ce rsultat est vrai pour l'analyse LR(k) ? Langages LR() Thorme: LR(0) = LR(1) = LR(k) = ALG DETERMINISTE ? Remarque: En pratique, pour un langage donn, on peut tre amen prfrer une grammaire LR(1), voire LR(2), une grammaire LR(0) qui peut tre beaucoup plus difficile lire et volumineuse en nombre de rgles de production. Thorme: La proprit LR(k) d'un langage est indcidable (pour k non fix) ? Grammaires LR() Proprit (rappel): pour k' > k >= 0, LR(k) => LR(k') ? Thorme: La proprit LR(k) d'une grammaire est indcidable (pour k non fix) ? Corollaire: Il n'existe pas d'algorithme permettant de transformer une grammaire quelconque en une grammaire quivalente LR(k) ; mais on peut toujours essayer sur une grammaire donne! Thorme: Une grammaire LR(1) est non ambigu preuve: d'aprs la proprit LR(1) il ne peut exister deux drivations distinctes pour deux mots identiques ? gnralisation: ce rsultat est vrai pour les grammaires LR(k) ? Complexit de l'analyse LR() Thorme: L'analyse LR(1) d'un mot m est en O(|m|) preuve: d'aprs le code ci-contre ? gnralisation: ce rsultat est vrai pour l'analyse LR(k) ? Langages LR() Thorme: LR(0) = LR(1) = LR(k) = ALG DETERMINISTE ? Remarque: En pratique, pour un langage donn, on peut tre amen prfrer une grammaire LR(1), voire LR(2), une grammaire LR(0) qui peut tre beaucoup plus difficile lire et volumineuse en nombre de rgles de production. Thorme: La proprit LR(k) d'un langage est indcidable (pour k non fix) ?

    38. Transparent 38 Grammaires SLR() items LR(0) pour E ::= E + T Grammaire ETF enracine E ' ::= E # (r0) E ::= E + T | T (r1 r2) T ::= T * F | F (r3 r4) F ::= var | ( E ) (r5 r6) Construction des analyseurs LR() La construction des analyseurs LR() pour une grammaire donne est fastidieuse: on utilise donc de prfrence un gnrateur syntaxique LR comme YACC ou BISON. Cette construction repose sur le calcul de la table d'Actions et de la Table de Transition pour les tats de l'automate des Prfixes Viables. Trois classes de grammaires, avec une inclusion stricte: SLR ? LALR ? LR permettent de raliser cette construction en utilisant l'analyseur gnrique LR prsent prcdemment. Construction des analyseurs SLR On prsente une construction gnrale qui permet d'obtenir le dcoupage des manches par un Automate d'tat fini. Dans le cas des grammaires, dites SLR, cette construction permet d'obtenir directement les tables d'analyse LR(). Dans la suite, on "enracine" les grammaires utilises par une rgle de production ajoute P: { S'?S# } ; ceci afin de ne pas devoir traiter la dernire "remonte" vers S comme un cas particulier. Dfinition: On appelle item LR(0) une production de P marque en partie droite par "?" Interprtation: le marqueur matrialise la position courante de la reconnaissance ascendante de la rgle ?Construction des analyseurs LR() La construction des analyseurs LR() pour une grammaire donne est fastidieuse: on utilise donc de prfrence un gnrateur syntaxique LR comme YACC ou BISON. Cette construction repose sur le calcul de la table d'Actions et de la Table de Transition pour les tats de l'automate des Prfixes Viables. Trois classes de grammaires, avec une inclusion stricte: SLR ? LALR ? LR permettent de raliser cette construction en utilisant l'analyseur gnrique LR prsent prcdemment. Construction des analyseurs SLR On prsente une construction gnrale qui permet d'obtenir le dcoupage des manches par un Automate d'tat fini. Dans le cas des grammaires, dites SLR, cette construction permet d'obtenir directement les tables d'analyse LR(). Dans la suite, on "enracine" les grammaires utilises par une rgle de production ajoute P: { S'?S# } ; ceci afin de ne pas devoir traiter la dernire "remonte" vers S comme un cas particulier. Dfinition: On appelle item LR(0) une production de P marque en partie droite par "?" Interprtation: le marqueur matrialise la position courante de la reconnaissance ascendante de la rgle ?

    39. Transparent 39 Automates SLR() La fermeture ? ( { E'? ? E } ) E'? ?E E? ?E + T E? ?T T? ?T * F T? ?F F? ?var F? ?( E ) Les transitions LR(0) Fermeture d'un item LR(0) Dfinition: Soit I un ensemble d'items, on note ? (I) la fermeture de I dfinie par: I ? ? si A?? ? B? ? ? alors B? ? g ? ? pour B? g ? P Interprtation: le marqueur indique que dans l'tat I (ensemble I): on espre rduire ?B? en A ? a dj t "remont" il faut "remonter" B on ajoute donc cet tat I, toutes les possibilits pour "remonter" B ? Construction de l'Automate de Transition LR(0) Thorme: Le langage des prfixes viables d'une grammaire algbrique est reconnu par l'automate TRANS de Transition LR(0) dfini comme suit: les tats de TRANS sont des fermetures ? les transitions sont dfinies par : TRANS[I, X] = ? ( {A?? X??} pour {A?? ?X? } ? I) o I est un ensemble d'items et X ? N ? T l'tat initial est ? ( {S'? ? S } ) tous les tats sont terminaux Interprtation : les tats de l'automate codent l'ensemble des parties droites possibles pour complter le prfixe empil en cours d'analyse ? Fermeture d'un item LR(0) Dfinition: Soit I un ensemble d'items, on note ? (I) la fermeture de I dfinie par: I ? ? si A?? ? B? ? ? alors B? ? g ? ? pour B? g ? P Interprtation: le marqueur indique que dans l'tat I (ensemble I): on espre rduire ?B? en A ? a dj t "remont" il faut "remonter" B on ajoute donc cet tat I, toutes les possibilits pour "remonter" B ? Construction de l'Automate de Transition LR(0) Thorme: Le langage des prfixes viables d'une grammaire algbrique est reconnu par l'automate TRANS de Transition LR(0) dfini comme suit: les tats de TRANS sont des fermetures ? les transitions sont dfinies par : TRANS[I, X] = ? ( {A?? X??} pour {A?? ?X? } ? I) o I est un ensemble d'items et X ? N ? T l'tat initial est ? ( {S'? ? S } ) tous les tats sont terminaux Interprtation : les tats de l'automate codent l'ensemble des parties droites possibles pour complter le prfixe empil en cours d'analyse ?

    40. Transparent 40 Items LR(0) Canoniques ? I ensemble d'items LR(0) ? X ? (N ? T) FERMETURE ? ( I ): ? I? ? ( I ) ? si [A? ??B ? ] ? ? ( I ) et [B? ? ] ? P, alors [B? ? ? ] ? ? ( I ) TRANSITIONS TRANS( I, X ) : ? TRANS( I, X ) = ? ( { [A? ?X? ? ] } , pour [A? ??X ? ] ? I ) C: Ensemble d'items canoniques ? ? ( { [E'? ? E] } ) ? C ? ? I ? C, TRANS(I, X) ? C Dfinition: On appelle Items LR(0) canoniques les tats atteignables dans TRANS partir de l'tat initial ? ( {S'? ? S } ) Construction des items LR(0) canoniques Items pour ETF Dfinition: On appelle Items LR(0) canoniques les tats atteignables dans TRANS partir de l'tat initial ? ( {S'? ? S } ) Construction des items LR(0) canoniques Items pour ETF

    41. Transparent 41 Automates SLR() L'Automate des Prfixes Viables dans ETF Construction des items LR(0) canoniques Items pour ETF Construction des items LR(0) canoniques Items pour ETF

    42. Transparent 42 Tables SLR pour ETF ETF est SLR Construction de la Table ACTION SLR On construit la table A d'analyse en appliquant les rgles suivantes o A?N, a?T ? {#} et Ip l'item LR(0) associ l'tat p de l'Automate des prfixes viables. si A???a? ? Ip alors A[p, a] = "dcaler" si A??? ? Ip alors pour tout a ? Suivant(A): A[p, a] = "rduire par A ? ? " si S'?S? ? Ip alors A[p, #] = "accepter" sinon A[p, a] = "erreur" Conflits pendant la construction de la table ACTION dcalage/rduction: il existe Ip contenant les items: A???a? => A[p, a] = "dcaler" B??'? avec a ? Suite(B) =>A[p, a] = "rduire " rduction/rduction: il existe Ip contenant les items: A??? et a ? Suiv(A) => A[p, a] = "rd par A" B??'? et a ? Suiv(B) =>A[p, a] = "rd par B" Construction de la Table ACTION SLR On construit la table A d'analyse en appliquant les rgles suivantes o A?N, a?T ? {#} et Ip l'item LR(0) associ l'tat p de l'Automate des prfixes viables. si A???a? ? Ip alors A[p, a] = "dcaler" si A??? ? Ip alors pour tout a ? Suivant(A): A[p, a] = "rduire par A ? ? " si S'?S? ? Ip alors A[p, #] = "accepter" sinon A[p, a] = "erreur" Conflits pendant la construction de la table ACTION dcalage/rduction: il existe Ip contenant les items: A???a? => A[p, a] = "dcaler" B??'? avec a ? Suite(B) =>A[p, a] = "rduire " rduction/rduction: il existe Ip contenant les items: A??? et a ? Suiv(A) => A[p, a] = "rd par A" B??'? et a ? Suiv(B) =>A[p, a] = "rd par B"

    43. Transparent 43 Tables SLR pour ETF ETF est SLR, mais pas LR(0) Proprit LR() des grammaires Dfinition: une grammaire est SLR(1) ou SLR, si la construction prcdente de la table Action se termine sans conflit. ? Proprit: une grammaire est LR(0) ? SLR, si la construction prcdente de la table Action se termine sans conflit et que pour chaque tat, les actions (D, Ri ou Rj) ne dpendent pas des Terminaux ? Grammaire ETF rcursive gauche (r1, r2) E ? E + T | T (r3, r4) T ? T * F | F (r5, r6) F ? var | ( E ) Suivants pour ETF (r0) E : # (r1) E : + (r6) E : ) (r3) T : * (r2) T : + ) # (r4) F : * + ) # F = { * + ) # } => T = { * + ) # } => E = { + ) # } Proprit LR() des grammaires Dfinition: une grammaire est SLR(1) ou SLR, si la construction prcdente de la table Action se termine sans conflit. ? Proprit: une grammaire est LR(0) ? SLR, si la construction prcdente de la table Action se termine sans conflit et que pour chaque tat, les actions (D, Ri ou Rj) ne dpendent pas des Terminaux ? Grammaire ETF rcursive gauche (r1, r2) E ? E + T | T (r3, r4) T ? T * F | F (r5, r6) F ? var | ( E ) Suivants pour ETF (r0) E : # (r1) E : + (r6) E : ) (r3) T : * (r2) T : + ) # (r4) F : * + ) # F = { * + ) # } => T = { * + ) # } => E = { + ) # }

    44. Transparent 44 Analyse LR(1) dans ETF Source v1 + v2 * v3 # Analyse SLR Grammaire ETF rcursive gauche (r1, r2) E ? E + T | T (r3, r4) T ? T * F | F (r5, r6) F ? var | ( E ) Analyse ADR Le tableau ci_contre donne les tats successifs d'un analyseur ADR pour le mot : v1 + v2 * v3. Rssultat La suite des Rductions excutes par l'Automate: R6 R4 R2 R6 R4 R6 R3 R1 est la suite des drivations inverses les + droite pour le mot en entre Grammaire ETF rcursive gauche (r1, r2) E ? E + T | T (r3, r4) T ? T * F | F (r5, r6) F ? var | ( E ) Analyse ADR Le tableau ci_contre donne les tats successifs d'un analyseur ADR pour le mot : v1 + v2 * v3. Rssultat La suite des Rductions excutes par l'Automate: R6 R4 R2 R6 R4 R6 R3 R1 est la suite des drivations inverses les + droite pour le mot en entre

    45. Transparent 45 Un conflit dans la construction SLR Grammaire des affectations sur valeurs rfrences A ::= G = D | D (r1, r2) G ::= * D | var (r3, r4) D ::= G (r5) Items LR(0) canoniques Conflit dans la table Action[2, "="] = "dcaler" Action[2, "="] = "rduire D ? G" Conflits pendant la construction de la table ACTION dcalage/rduction: il existe un tat I2 contenant les items: A?G?=D => A[2, "="] = "dcaler" D?G? => A[2, "="] = "rduire par D?G " car A ? G=D ?*D=D => "=" ? Suivants(D) Exemple: le mot *v1= v2# se rduit en *G avec = v2# en entre deux possibilits: rduire G en D => *D = v2 ?G=v2 ?G=G ?G=D ? A => accepter dcaler =v2 => *G = v2 ?* G = G ?* G = D ?* A => erreur Interprtation: la grammaire prsente ici n'est pas ambigu; le conflit provient de la technique SLR qui n'est pas assez puissante pour mmoriser suffisamment de contexte gauche; Aprs avoir remonter une entre vers G, l'analyseur ne dispose pas d'assez d'information pour dcider qu'il faut rduire G car dcaler ne peut conduire une bonne solution ! Conflits pendant la construction de la table ACTION dcalage/rduction: il existe un tat I2 contenant les items: A?G?=D => A[2, "="] = "dcaler" D?G? => A[2, "="] = "rduire par D?G " car A ? G=D ?*D=D => "=" ? Suivants(D) Exemple: le mot *v1= v2# se rduit en *G avec = v2# en entre deux possibilits: rduire G en D => *D = v2 ?G=v2 ?G=G ?G=D ? A => accepter dcaler =v2 => *G = v2 ?* G = G ?* G = D ?* A => erreur Interprtation: la grammaire prsente ici n'est pas ambigu; le conflit provient de la technique SLR qui n'est pas assez puissante pour mmoriser suffisamment de contexte gauche; Aprs avoir remonter une entre vers G, l'analyseur ne dispose pas d'assez d'information pour dcider qu'il faut rduire G car dcaler ne peut conduire une bonne solution !

    46. Transparent 46 Grammaires LR() Grammaire SCC enracine S' ::= S # (r0) S ::= CC (r1) C ::= c C | d (r2 r3) items LR(1) SUIVANTS SUIV(S)= {#} SUIV(C) = {c d #} Extension des analyseurs SLR() aux LR() Dans l'analyse SLR on excute l'action rduire { A? ? } dans l'tat Ip pour tout a?T ? {#} si A?? ? ? Ip et a ? Suivant(A) Or il se peut que ?? soit un prfixe viable mais pas ?Aa Un analyseur LR peut s'obtenir partir de la construction SLR o l'on ne rduit ?? en ?A que si ?Aa est un prfixe viable Dfinition: On appelle item LR(1) un couple [A? ? ?? , a], compos d'un item LR(0) et d'un terminal a (de prvision ou d'anticipation) . Dfinition:un item LR(1) [A? ? ? ? , a] est dit valide pour un prfixe viable ?? si: S *?d ?Aaw avec ?Aaw ?d ???aw Interprtation: si on a dj remont ?? si ce qui suit en entre commence par ?a alors ???aw est une fsd dont la dernire drivation est ?Aaw ?d ???aw la prvision a n'a aucun effet dans les items sans rduction, de la forme A? ? ??, avec ? non vide. Extension des analyseurs SLR() aux LR() Dans l'analyse SLR on excute l'action rduire { A? ? } dans l'tat Ip pour tout a?T ? {#} si A?? ? ? Ip et a ? Suivant(A) Or il se peut que ?? soit un prfixe viable mais pas ?Aa Un analyseur LR peut s'obtenir partir de la construction SLR o l'on ne rduit ?? en ?A que si ?Aa est un prfixe viable Dfinition: On appelle item LR(1) un couple [A? ? ?? , a], compos d'un item LR(0) et d'un terminal a (de prvision ou d'anticipation) . Dfinition:un item LR(1) [A? ? ? ? , a] est dit valide pour un prfixe viable ?? si: S *?d ?Aaw avec ?Aaw ?d ???aw Interprtation: si on a dj remont ?? si ce qui suit en entre commence par ?a alors ???aw est une fsd dont la dernire drivation est ?Aaw ?d ???aw la prvision a n'a aucun effet dans les items sans rduction, de la forme A? ? ??, avec ? non vide.

    47. Transparent 47 Automates LR() Grammaire SCC {S'? S # ; S? CC ; C? cC | d } ? ( [ S'? ? S, # ] ) S'? ?S, # S? ?CC , # C? ?cC, c|d C? ? d , c|d Les transitions LR(1) Fermeture d'un item LR(1) Dfinition: Soit I un ensemble d'items LR(1) , on appelle ? (I) la fermeture de I dfinie par: I ? ? si [A?? ? B?, a]? ? alors [B? ? g, b]? ? pour [B? g ] ?P et b?Prem(?a) ? Construction de l'Automate de Transition LR(1) Thorme: Le langage des "prfixes viables suivis d'un terminal d'anticipation " d'une grammaire algbrique est reconnu par l'automate T de Transition LR(1) dfini comme suit: les tats de T sont des fermetures ? les transitions sont dfinies par : T(I, X) = ?( [A?? X??, b] pour [A?? ?X?, b] ? I ) o I est un ensemble d'items LR(1) et X ? N ? T l'tat initial est ? ( [S'? ? S, #] ) tous les tats sont terminaux ? Fermeture d'un item LR(1) Dfinition: Soit I un ensemble d'items LR(1) , on appelle ? (I) la fermeture de I dfinie par: I ? ? si [A?? ? B?, a]? ? alors [B? ? g, b]? ? pour [B? g ] ?P et b?Prem(?a) ? Construction de l'Automate de Transition LR(1) Thorme: Le langage des "prfixes viables suivis d'un terminal d'anticipation " d'une grammaire algbrique est reconnu par l'automate T de Transition LR(1) dfini comme suit: les tats de T sont des fermetures ? les transitions sont dfinies par : T(I, X) = ?( [A?? X??, b] pour [A?? ?X?, b] ? I ) o I est un ensemble d'items LR(1) et X ? N ? T l'tat initial est ? ( [S'? ? S, #] ) tous les tats sont terminaux ?

    48. Transparent 48 Construction des items LR(1) canoniques Items LR(1) pour SCC tat I4: on reconnat le premier "d" : on doit donc rduire ssi le lookahead = "c" | "d" et erreur sinon tat I7: on reconnat le second "d" : on doit donc rduire ssi le lookahead = "#" et erreur sinon tat I3: on reconnat les premiers "c" tat I6: on reconnat les seconds "c" Construction des items LR(1) canoniques Items LR(1) pour SCC tat I4: on reconnat le premier "d" : on doit donc rduire ssi le lookahead = "c" | "d" et erreur sinon tat I7: on reconnat le second "d" : on doit donc rduire ssi le lookahead = "#" et erreur sinon tat I3: on reconnat les premiers "c" tat I6: on reconnat les seconds "c"

    49. Transparent 49 Automates LR(1) L'Automate des Transitions LR(1) dans SCC Construction des items LR(1) canoniques Items LR(1) pour SCC tat I4: on reconnat le premier "d" : on doit donc rduire ssi le lookahead = "c" | "d" et erreur sinon tat I7: on reconnat le second "d" : on doit donc rduire ssi le lookahead = "#" et erreur sinon tat I3: on reconnat les premiers "c" tat I6: on reconnat les seconds "c" Construction des items LR(1) canoniques Items LR(1) pour SCC tat I4: on reconnat le premier "d" : on doit donc rduire ssi le lookahead = "c" | "d" et erreur sinon tat I7: on reconnat le second "d" : on doit donc rduire ssi le lookahead = "#" et erreur sinon tat I3: on reconnat les premiers "c" tat I6: on reconnat les seconds "c"

    50. Transparent 50 Tables LR(1) pour SCC Construction de la Table ACTION LR(1) On construit la table comme dans le cas SLR soit A?N, a?T ? {#} et Ip l'item LR(1) associ l'tat p de l'Automate des prfixes viables. si [A???a?, b]? Ip alors A[p, a] = "dcaler" si [A???, a] ? Ip alors A[p, a] = "rduire par A ? ? " si [S'?S?, #] ? Ip alors A[p, #] = "accepter" sinon A[p, a] = "erreur" tat initial = [S'??S, #] transitions comme dans le cas SLR Etats et items LR(1) canoniques de SCC C? c?C , c|d C? c?C , # I3= C? ?cC , c|d I6= C? ?cC , # C? ?d , c|d C? ?d , # I4= C? d? , c|d I7= C? d? , # I8= C? cC? , c|d I9= C? cC? , # Proprit des grammaires LR(1) Thorme: La construction donne ci dessus est sans conflit pour toute grammaire LR(1) ? Construction de la Table ACTION LR(1) On construit la table comme dans le cas SLR soit A?N, a?T ? {#} et Ip l'item LR(1) associ l'tat p de l'Automate des prfixes viables. si [A???a?, b]? Ip alors A[p, a] = "dcaler" si [A???, a] ? Ip alors A[p, a] = "rduire par A ? ? " si [S'?S?, #] ? Ip alors A[p, #] = "accepter" sinon A[p, a] = "erreur" tat initial = [S'??S, #] transitions comme dans le cas SLR Etats et items LR(1) canoniques de SCC C? c?C , c|d C? c?C , # I3= C? ?cC , c|d I6= C? ?cC , # C? ?d , c|d C? ?d , # I4= C? d? , c|d I7= C? d? , # I8= C? cC? , c|d I9= C? cC? , # Proprit des grammaires LR(1) Thorme: La construction donne ci dessus est sans conflit pour toute grammaire LR(1) ?

    51. Transparent 51 Construction LR(1) vs SLR L'Automate des Transitions SLR dans SCC Construction SLR pour SCC Items LR(0) pour SCC les Items LR(0) regroupent des items LR(1) La construction SLR pour SCC est plus conomique On fusionne I4 et I7 sans conflit de rduction en I4: on doit rduire (r3) ssi le lookahead = "c" | "d" en I7: on doit rduire (r3) ssi le lookahead = "#" en I74: on rduit dans tous les cas, et l'erreur (ventuelle) sera dtecte plus tard les tats I3 et I6 peuvent tre fusionns sans conflit car les actions sont "shift". Idem pour I8 et I9 Construction SLR pour SCC Items LR(0) pour SCC les Items LR(0) regroupent des items LR(1) La construction SLR pour SCC est plus conomique On fusionne I4 et I7 sans conflit de rduction en I4: on doit rduire (r3) ssi le lookahead = "c" | "d" en I7: on doit rduire (r3) ssi le lookahead = "#" en I74: on rduit dans tous les cas, et l'erreur (ventuelle) sera dtecte plus tard les tats I3 et I6 peuvent tre fusionns sans conflit car les actions sont "shift". Idem pour I8 et I9

    52. Transparent 52 Tables SLR pour SCC Construction pratique des analyseurs LR() La construction des analyseurs LR() repose sur le calcul de la table d'Actions et de la Table de Transitions pour les tats de l'automate des Prfixes Viables. Quatre classes de grammaires, avec une inclusion stricte: LR(0) ? SLR ? LALR(1) ? LR(1) permettent de raliser cette construction en utilisant l'analyseur gnrique LR prsent prcdemment. La construction SLR est efficace, mais la classe des langages atteints est insuffisante en pratique pour les LP. La construction LR(1) est plus coteuse en mmoire, mais la classe des langages atteints couvre en pratique tous les LP. A titre d'exemple, on peut avoir pour la mme grammaire: N tats dans l'automate des transitions SLR N3 tats dans l'automate des transitions LR les grammaires LALR(1) ralisent un bon compromis complexit/puissance d'expression; c'est la famille qui est supporte par les gnrateurs syntaxiques LR comme YACC ou BISON. Construction pratique des analyseurs LR() La construction des analyseurs LR() repose sur le calcul de la table d'Actions et de la Table de Transitions pour les tats de l'automate des Prfixes Viables. Quatre classes de grammaires, avec une inclusion stricte: LR(0) ? SLR ? LALR(1) ? LR(1) permettent de raliser cette construction en utilisant l'analyseur gnrique LR prsent prcdemment. La construction SLR est efficace, mais la classe des langages atteints est insuffisante en pratique pour les LP. La construction LR(1) est plus coteuse en mmoire, mais la classe des langages atteints couvre en pratique tous les LP. A titre d'exemple, on peut avoir pour la mme grammaire: N tats dans l'automate des transitions SLR N3 tats dans l'automate des transitions LR les grammaires LALR(1) ralisent un bon compromis complexit/puissance d'expression; c'est la famille qui est supporte par les gnrateurs syntaxiques LR comme YACC ou BISON.

    53. Transparent 53 Grammaires LALR(1) Grammaire SCC {S'? S# ; S? CC ; C? cC | d } Fusion des items LR(1) I3= { [ C? c?C , c|d ], [ C? ?cC , c|d ], [ C? ?d , c|d ] } I6= { [ C? c?C , # ], [ C? ?cC , # ], [ C? ?d , # ] } I36= { [ C? c?C , c|d|# ], [ C? ?cC , c|d|# ], [ C? ?d , c|d|# ] } Construction des transitions LALR(1) Principe: On fusionne les tats issus d'ensembles d'items LR(1) dont les ensembles d'items LR(0) ( "cur") sont identiques. Dfinition: On appelle coeur d'un ensemble I d'items LR(1) l'ensemble d'items LR(0) [ A????] pour lesquels I contient un item LR(1) [A? ? ??, ak] (les ak peuvent tre diffrents) Pour tout cur C ditems LR(1) [A? ? ??, ak] , PREVISION( C )= {ak} ? SUIVANT(A) Construction LALR(1) "mthode gourmande": Etant donne une table Action LR(1): la fusion d'tats ayant le mme coeur n'engendre aucun conflit "dcaler/rduire". Dfinition: une grammaire est LALR(1) si la fusion prcdente n'engendre pas de conflit "rduire/rduire". Les conflits "rduire/rduire" crs par cette fusion sont rares en pratique (grammaires LR, non LALR). Remarque: la mthode "gourmande" a peu d'intrt en pratique, puisqu'elle implique la construction des items LR(1). Construction des transitions LALR(1) Principe: On fusionne les tats issus d'ensembles d'items LR(1) dont les ensembles d'items LR(0) ( "cur") sont identiques. Dfinition: On appelle coeur d'un ensemble I d'items LR(1) l'ensemble d'items LR(0) [ A????] pour lesquels I contient un item LR(1) [A? ? ??, ak] (les ak peuvent tre diffrents) Pour tout cur C ditems LR(1) [A? ? ??, ak] , PREVISION( C )= {ak} ? SUIVANT(A) Construction LALR(1) "mthode gourmande": Etant donne une table Action LR(1): la fusion d'tats ayant le mme coeur n'engendre aucun conflit "dcaler/rduire". Dfinition: une grammaire est LALR(1) si la fusion prcdente n'engendre pas de conflit "rduire/rduire". Les conflits "rduire/rduire" crs par cette fusion sont rares en pratique (grammaires LR, non LALR). Remarque: la mthode "gourmande" a peu d'intrt en pratique, puisqu'elle implique la construction des items LR(1).

    54. Transparent 54 Construction LALR(1) Grammaire SCC {S'? S# ; S? CC ; C? cC | d } Noyaux LR(0) + prvision initiale I0= [ S'? ?S , # ] I1= [ S'? S? , # ] I2= [ S? C?C , # ] I3= [ C? c?C , c|d ] I4= [ C? d? , c|d ] I5= [ S? CC? , # ] I6= [ C? c?C , # ] I7= [ C? d? , # ] etc Construction LALR(1) "mthode conomique": On ne construit pas les Items LR(1): On construit seulement les "noyaux" des Items LR(0) On calcule itrativement les symboles de prvision pour chaque noyau LR(0) Dfinition: le noyau d'un ensemble d'items I est le sous-ensemble des items de I qui n'ont pas leur point ?en dbut de partie droite plus l'item initial [S' ? ? S, #] (il s'agit des items obtenus directement par transition et non pas par fermeture) Construction LALR(1) "mthode conomique": On ne construit pas les Items LR(1): On construit seulement les "noyaux" des Items LR(0) On calcule itrativement les symboles de prvision pour chaque noyau LR(0) Dfinition: le noyau d'un ensemble d'items I est le sous-ensemble des items de I qui n'ont pas leur point ?en dbut de partie droite plus l'item initial [S' ? ? S, #] (il s'agit des items obtenus directement par transition et non pas par fermeture)

    55. Transparent 55 Construction LALR(1) Grammaire SGD {S'? S ; S? G = D | D ; G? * D | id ; D? G } Noyaux LR(0) + Passes Prvision I0= [S'? ?S] I1= [S'? S?] I2= [S? G?=D] [D? G?] I3= [S? D?] I4= [G? *?D] I5= [G? id?] I6= [S? G=?D] I7= [G? *D?] I8= [D? G?] I9= [S? G=D?] Dtermination des symboles de prvision partir des noyaux: Soit K le noyau d'un ensemble d'items I X ? (N ? T) # est un symbole de prvision factice pour reprsenter les symboles de prvision pour chaque item [B ? ??? ] ? K, si [A ? ??X?, a] ? ? ({[B ? ??? , #]}) et a ? # alors [A ? ?X??, a] ? TRANS(I,X) (gnration spontane d'un symbole de prvision) si [A ? ??X?, #] ? ? ({[B ? ???, # ]}) alors [A ? ?X??, #] ? TRANS(I,X) (propagation des symboles de prvision) Exemple grammaire SGD ? ({[S' ? ?S, # ]}) = { [S' ? ?S, # ], [S ? ?G=D, # ], [S ? ?D, # ], [G ? ?*D, #/= ], [G ? ?id, # /= ], [D ? ?G, # ] }Dtermination des symboles de prvision partir des noyaux: Soit K le noyau d'un ensemble d'items I X ? (N ? T) # est un symbole de prvision factice pour reprsenter les symboles de prvision pour chaque item [B ? ??? ] ? K, si [A ? ??X?, a] ? ? ({[B ? ??? , #]}) et a ? # alors [A ? ?X??, a] ? TRANS(I,X) (gnration spontane d'un symbole de prvision) si [A ? ??X?, #] ? ? ({[B ? ???, # ]}) alors [A ? ?X??, #] ? TRANS(I,X) (propagation des symboles de prvision) Exemple grammaire SGD ? ({[S' ? ?S, # ]}) = { [S' ? ?S, # ], [S ? ?G=D, # ], [S ? ?D, # ], [G ? ?*D, #/= ], [G ? ?id, # /= ], [D ? ?G, # ] }

    56. Transparent 56 Construction LALR(1) Grammaire SGD {S'? S ; S? G = D | D ; G? * D | id ; D? G } Noyaux LR(0) + Passes Prvision I0= [S'? ?S] I1= [S'? S?] I2= [S? G?=D] [D? G?] I3= [S? D?] I4= [G? *?D] I5= [G? id?] I6= [S? G=?D] I7= [G? *D?] I8= [D? G?] I9= [S? G=D?] Dtermination des symboles de prvision partir des noyaux: Soit K le noyau d'un ensemble d'items I X ? (N ? T) # est un symbole de prvision factice pour reprsenter les symboles de prvision pour chaque item [B ? ??? ] ? K, si [A ? ??X?, a] ? ? ({[B ? ??? , #]}) et a ? # alors [A ? ?X??, a] ? TRANS(I,X) (gnration spontane d'un symbole de prvision) si [A ? ??X?, #] ? ? ({[B ? ???, # ]}) alors [A ? ?X??, #] ? TRANS(I,X) (propagation des symboles de prvision) Exemple grammaire SGD ? ({[S' ? ?S, # ]}) = { [S' ? ?S, # ], [S ? ?G=D, # ], [S ? ?D, # ], [G ? ?*D, #/= ], [G ? ?id, # /= ], [D ? ?G, # ] }Dtermination des symboles de prvision partir des noyaux: Soit K le noyau d'un ensemble d'items I X ? (N ? T) # est un symbole de prvision factice pour reprsenter les symboles de prvision pour chaque item [B ? ??? ] ? K, si [A ? ??X?, a] ? ? ({[B ? ??? , #]}) et a ? # alors [A ? ?X??, a] ? TRANS(I,X) (gnration spontane d'un symbole de prvision) si [A ? ??X?, #] ? ? ({[B ? ???, # ]}) alors [A ? ?X??, #] ? TRANS(I,X) (propagation des symboles de prvision) Exemple grammaire SGD ? ({[S' ? ?S, # ]}) = { [S' ? ?S, # ], [S ? ?G=D, # ], [S ? ?D, # ], [G ? ?*D, #/= ], [G ? ?id, # /= ], [D ? ?G, # ] }

    57. Transparent 57 Classification des Grammaires Algbriques

    58. Transparent 58 Classification des Langages Algbriques

    59. Transparent 59 Quelques Environnements de Compilation (compiler-compiler) Java Compiler Compiler [tm] (JavaCC [tm]) - The Java Parser Generator http://javacc.java.net/ SYNTAX http://syntax.gforge.inria.fr/ Free Compiler Construction Tools http://www.thefreecountry.com/programming/compilerconstruction.shtml ANTLR, ANother Tool for Language Recognition, http://www.antlr.org/ The Compiler Generator Coco/R http://www.ssw.uni-linz.ac.at/Coco/

    60. La Compilation sur le Web http://toutprogrammer.com/ Attribute Grammar Systems Code Generator Kits Socits Compiler Construction Kits Cross Compilers Functional GNU Compiler Collection Lexer and Parser Generators Object-Oriented Procedural Theory Transformation Tools

More Related