of 61
Support de cours
Compilation
2013 - 2014M1 Informatique
Anne BERRY
1
2
Cours de Compilation
Anne BERRY
ENT : M 1_INFO_COMPIL
Bibliographie 1. Cours en ligne Keith Schwarz http://www.stanford.edu/class/cs143/2. Des WATSON - High-Level Languages and Their Compilers - ISBN 0-201-18489-3 3. Daniel I.A. COHEN - Introduction to Computer Theory ISBN 0-471-54841-3 4. John HOPCROFT and Jeffrey ULLMAN - Introduction to Automata Theory, Languages and Computation 5. Alfred AHO, Monica S. Lam, Ravi SETHI and Jeffrey ULLMAN - Compilers, Principles, Techniques and Tools6. Andrew W. APPEL - Modern compiler implementation in C 7. R. WILHELM and D. MAURER - Compiler Design 8. W. WAITE and G. GOOS - Compiler Construction 9. S. MUCHNICK - Advanced Compiler design Implementation 10. D. GRUNE, H. BAL, C. JACOBS et K. LANGENDOEN - Compilateurs
Plan du cours :
1 : Introduction: Qu'est-ce que la Compilation2 : Quelques rappels de thorie des langages3 : L'analyse lexicale4 : L'analyse syntaxique5 : Les fonctions FIRST et FOLLOW6 : L'analyse descendante (langages LL)7 : L'analyse ascendante (langages LR)
(+ Gnration et optimisation de code : quelques notions)
3
4
Tabledesmatires1.Introduction........................................................................................................................................6
1.1.Dfinitiondelacompilation.......................................................................................................61.2.Quelquesproblmesposs........................................................................................................71.3.Unaperudesphasesdelacompilation...................................................................................9
2.Quelquesrappelsdethoriedeslangages(voirAnnexe)......................................................................................................................................12
2.1.Feuilled'exercices1:rvisionsdethoriedeslangages..........................................................133.L'analyselexicale.............................................................................................................................154.L'analysesyntaxique........................................................................................................................165.LesfonctionsFIRSTetFOLLOW...................................................................................................18
5.1.Symbolesnullables...................................................................................................................185.2.DfinitiondeFIRST.................................................................................................................185.3.DfinitiondeFOLLOW...........................................................................................................195.4.CalculduFIRST......................................................................................................................195.5.CalculduFOLLOWdesnonterminaux..................................................................................21
6.L'analysedescendante(topdownparsing)......................................................................................236.1.LeslangagesLL.......................................................................................................................236.2.CaractrisationdesgrammairesLL(1)....................................................................................246.3.L'analyseurLL.........................................................................................................................246.4.Calculdelatabled'analyseLL................................................................................................276.5.Procdsdercritured'unegrammairenonLL(1)...............................................................28
6.5.1.Rcursivit........................................................................................................................28UnegrammairealgbriqueGestditercursivegauche(leftrecursive)sietseulementsiellecontientunnonterminalAtelque...............................................................................................28
6.5.2.Factorisation.....................................................................................................................316.6.Feuilled'exercices2:leslangagesLL....................................................................................33
Procderl'analysedumot =4+5pourlesdeuxgrammaires. .......................................................337.L'analyseascendanteetleslangagesLR..........................................................................................34
7.1.Principedushiftreduceparsing...............................................................................................347.2.LesgrammairesLRetLALR...................................................................................................357.3.L'analyseurLR(1).....................................................................................................................367.4.LesgrammairesLALR.............................................................................................................397.5.Feuilled'exercices3:l'analyseurLALR..................................................................................407.6.Feuilled'exercices4:tudedesconflitsdanslestablesLALR(1).........................................41
8.ConstructiondestablesLALR(1)....................................................................................................458.1.Notationsetdfinitions............................................................................................................458.2.CalculdestablesLR(0)...........................................................................................................468.3.ConstructiondestablesLR(1).................................................................................................478.4.TablesLAR(1).........................................................................................................................498.5.Feuilled'exercices5:constructiondetablesLALR(1)..........................................................51
5
1. Introduction''To all who know more than one language'' (Waite & Goos)Remarque : la plupart des documents sont en anglais, ainsi que des termes techniques utiliss.
1.1. Dfinitiondelacompilation
Un compilateur est un programme de traduction.
De faon gnrale :- On part d'un code source crit dans un 'langage de haut niveau' (langage de programmation, C, C++, Java, LISP...)qui est facile manipuler pour un informaticien.- Le compilateur traduit dans un langage cible (de type Assembleur), facile manipuler pour l'ordinateur. Ce langage cible est ensuite optimis.
Remarque : Il existe d'excellents compilateurs, mais il n'existe pas d'excellent traducteur d'une langue naturelle une autre !
Buts de la compilation : changer la forme tout en conservant la smantique. Signaler les erreurs rencontres et aider l'informaticien les corriger.La traduction s'effectue en plusieurs phases.
Chane de dveloppement d'un programme
Enonc d'un problme rsoudreAnalyse du problme (dcidabilit, classe de complexit)
Algorithme
Analyse de complexit (moyenne, pire cas, exprimentale; recherche de meilleurs algorithmes)
Choix d'un langage de programmation
6
Ecriture d'un code source
dbuggage Compilation
Gnration du code cible
Optimisation 1.2. Quelques problmes poss lechoixdulangage
portabilitlisibilitoptimisation du code
Un mta-langage est un langage utilis pour dfinir un autre langage (par exemple des rgles de grammaire).Le langage peut servir se dcrire lui-mme. "Un des buts de l'tude de la compilation pour un programmeur est de savoir choisir le bon langage." (Watson) La gestion des erreurs Problmes d'IHM (Interface Homme/Machine) : clart des messages d'erreur, aide
efficace au dbuggage. Quelles 'initiatives' peut-on laisser au compilateur ? (reparenthsage, retypage) Quelles erreurs le compilateur peut-il 'ignorer' tout en continuant travailler?
(problmes de 'error recovery')IHM (Interface Homme-Machine) permissivit du langage initiatives que peut prendre un compilateur problmes de 'trade-off' (quilibre entre des compromis)
Exemple : Plus la compilation est rapide, moins l'optimisation du code est facile.
Problme de l'ambigut
7
Une phrase ambigu est une phrase laquelle on peut attribuer plusieurs sens.Exemple : 2 + 3 * 4 s'interprte comme (2 + 3) * 4 ou 2 + (3 * 4)}
A quelle branche appartient la compilation ?C'est une matire fondamentale pour l'informatique Cela met en jeu : - la thorie des langages la programmation l'algorithmique les structures de donnes l'architecture des machines
But de ce cours : Comprendre ce que fait le compilateur (moteur sous-jacent) Savoir crire des grammaires adaptes Apprendre des outils qui permettent d'crire un compilateur (En TP : logiciels LEX
et YACC)
1.3. Unaperudesphasesdelacompilation
Code Source
analyse lexicale
analyse syntaxique
analyse smantique
Reprsentation abstraite
8
gnration de code intermdiaire
optimisation du code intermdiaire
gnration et optimisation du code cible
Diffrentes phases peuvent s'excuter en mme temps (suivant les langages et les compilateurs).
A. La phase d'analyseCette phase traduit le code source en une reprsentation intermdiaire.Elle constitue le "front end".
L'analyse lexicaleC'est la phase la plus simple.But : prendre en entre un flot de caractres et procder la segmentation (sparation en "mots").Outil TP : LEX. On trouve les mots (lexmes, tokens) On vrifie que chaque mot trouv appartient bien au lexique (dictionnaire) On retourne (ventuellement) des messages d'erreur.Ces 3 tapes se font simultanment, en un seul parcours linaire du flot d'entre.Exemple : ltudiantatroischiens l tudiant a trois chiens.les @@2 ERREURles gozbuku ERREURles tudiant OK((1+3*2+4) OK
9
Certains compilateurs acceptent des mots sans dlimiteur :lavoiture : lav lave? la voiture? Ncessite un travail de 'look-ahead' (on regarde ce qui vient aprs)
L'analyse syntaxique(en anglais : parsing) C'est une analyse de la correction de la structure.
Outil TP : YACC.On se donne : un flot de mot et on veut vrifier la consistance de l'assemblage de ces mots en une phrase.On construit un arbre syntaxiqueOn dtecte des erreurs.Exemple : * * 43 - 12 ERREUR : * * est interdit.
L'analyse dite "smantique"C'est l'analyse du "sens", elle gre par exemple les problmes de typage.Certains langages sont capables de convertir automatiquement les types (mcanisme de coercition). On prend en entre un arbre et on procde des vrifications.
B. La phase de synthse (ou gnration de code)Elle constitue le "back end". Elle consiste prendre en entre la reprsentation intermdiaire (de nature arborescente) engendre par la phase d'analyse, pour la traduire en Assembleur ou en code machine spcifique.Elle comporte trois tapes : - gnration d'un code intermdiaire (par exemple en "code 3-adresses") proche de la machine mais "portable" - gnration du code machine spcifique partir de ce code intermdiaire
10
- optimisation du code qui se fait en concurrence avec les phases 1 et 2 (factorisation de variables, de code, "minimisation" du nombre de registres ncessaires, etc)
11
2. Quelquesrappelsdethoriedeslangages(voirAnnexe)
12
2.1. Feuilled'exercices1:rvisionsdethoriedeslangages
Grammaires
1. Soit G la grammaire dfinie comme suit :S bA | aB A bAA | aS | a B aBB | bS | b
Examiner si les mots suivants appartiennent L(G), et si oui, donner une drivation droite, une drivation gauche, et l'arbre syntaxique correspondants : 1 = bbaaba 2 = babbab 3 = bbaaba
2. Montrer que la grammaire : S aS | Sa |a
est ambigu et trouver une grammaire quivalente G' non-ambigu.
3. Soit G la grammaire sur {a,b} dfinie comme suit : S SS | XaXaXa | X bX | Montrer que le mot = abbaba est dans L(G).
4. On considre la grammaire dfinie par :S aB | bA A a | aS | bAA B b | bS | aBB
Examiner si les mots suivants appartiennent L(G), et si oui, donner une drivation droite, une drivation gauche, et l'arbre syntaxique correspondant : 1 = aaabbabbba 2 = babbabExiste-t-il une expression rgulire dcrivant le langage engendr par G ? Pourquoi ?Si oui, donner cette expression rgulire.
5. Quel est le langage engendr par la grammaire : S AA A AAA A bA | Ab | aDterminer si ce langage est rationnel et si oui, donner un automate d'tats finis, une expression rgulire et une grammaire rgulire correspondants.
13
6. Amliorer la grammaire : S aA | bB | cdD A aB | B aB | abB D aD | bS |
Expressions rgulires
7. Montrer que les deux expressions rgulires r et s sont quivalentes :r = (a+b)*a(a+b)*a(a+b)*s = b*ab*a(a+b)*
8. Donner une grammaire engendrant le langage des mots sur {a,b}comportant au moins une occurrence de 'a' et au moins une occurrence de 'b', ainsi qu'une expression rgulire correspondante.
9. Trouver une grammaire G engendrant le langage dcrit par l'expression rgulire r = ab*ab(a+b)*
10. Donner une expression rgulire dcrivant le mme langage que la grammaire :S AaBA bA | B aB | bB |
Automates pile
11. Donner une grammaire et un automate pile pour le langage des mots 'bien parenthss' sur {a,b}.
12. Donner une grammaire et un automate pile pour le langage des palindromes sur {a,b}.
14
3. L'analyselexicaleL'analyse lexicale est un prtraitement trs important :- segmentation des caractres du flot d'entre (sparation des 'mots' ou 'tokens' les uns des autres)- reprage et sparations des mots cls du langage- dtection d'erreurs ( 'syntax error')
En TP, on utilisera l'outil 'LEX' (ou flex)
Transparents : http://www.keithschwarz.com/cs143/WWW/sum2011/lectures/010_Lexical_Analysis.pdfKeith Schwarz
15
4. L'analysesyntaxique
Le procd qui consiste trouver une drivation d'un mot d'un langage algbrique s'appelle l'analyse syntaxique.
Il existe 2 grandes mthodes d'analyse : La mthode ascendante (bottom-top) La mthode descendante (top-to-bottom)
Mthode ascendante Principe : On part d'un mot et on essaye de procder des remplacements successifs qui permettent d'arriver l'axiome S.
Mthode descendante Principe : On part de l'axiome S et on essaye de trouver une drivation qui aboutit .
Exemple 1 : Grammaire G1 :S aA | bA dA | e
B f | gmot analyser : = ade
Analyse descendante :S (r1) aA (r3) ad A (r4) ade
Analyse ascendante :ade (r4) adA (r3) aA (r1) S
Exemple 2 : Grammaire G2 :S ABA BA | aB b
mot : : bbab
Analyse descendante :S (r1) AB (r2) BAB (r4) bAB (r2) bBAB (r4) bbAB (r3) bbaB (r4) bbab
Analyse ascendante :bbab (r4) Bbab (r4) BBab (r3) BBAb (r2) BAb (r2) Ab (r4)AB (r1) S
16
Analyse descendante : on obtiendra une drivation gauche de .
Analyse ascendante : on obtiendra une drivation droite de .
Analyse descendante :S (r1) AB (r2) BAB (r4) bAB (r2) bBAB (r4) bbAB (r3) bbaB (r4) bbabSuite de rgles : (1,2,4,2,4,3,4)
Analyse ascendante :S (r1) AB (r4) Ab (r2) BAb (r2) BBAb (r3)BBab (r4) Bbab (r4)bbabSuite de rgles : (1,4,2,2,3,4,4)
Remarque : l'analyse ascendante marche avec une classe de langages plus restreinte que l'analyse descendante.
Analyse ascendante : langages LRAnalyse descendante : langages LL
17
5. LesfonctionsFIRSTetFOLLOW
Ces fonctions seront ncessaires pour construire les analyseurs tudis.
5.1. Symbolesnullables
Un symbole A N est nullable si A *
Calcul des symboles nullables Initialisation : pour chaque -production A , A est nullable. Rpter jusqu' obtention de stabilit :
Pour chaque rgle de production X Y1Y2 ... Yn, (o chaque Yi est un caractre non-terminal diffrent)si tous les Yi sont nullables, alors X est nullable.
5.2. DfinitiondeFIRST
Soit une chane de caractres ( NT).
FIRST() est l'ensemble de tous les terminaux qui peuvent commencer une chane qui se drive de , avec en plus si est nullable :
FIRST()={x T | * x } { si est nullable}.
Exemple : G3 :E TE'E' +TE' | T FT' T' *FT' | F (E) | n pour =TE' , '(' est dans FIRST ().En effet : TE' (r2) T + TE' (r4) FT'+TE' (r7) (E)T'+TE'.
18
5.3. DfinitiondeFOLLOW
Soit A un symbole non-terminal.
FOLLOW(A) est l'ensemble de tous les terminaux qui peuvent apparatre immdiatement droite de A dans une drivation S * A .
FOLLOW(A)={x T | S * A , avec x FIRST()}.
Remarque : le mot vide n'appartient jamais FOLLOW.
Exemple sur G3 : ')' est dans FOLLOW(E) :en effet, E (r1) TE' (r4) FT'E' (r7) (E)T'E'.
On ajoutera un symbole de fin de mot, $ ; $ sera dans FOLLOW(S).
5.4. CalculduFIRST
On aura besoin de calculer FIRST() pour chaque qui est une partie droite d'une rgle de production de la grammaire considre.
- Pour un caractre terminal x, FIRST(x)={x}.- Pour les caractres non-terminaux X, on calcule FIRST(X). - Pour partie droite d'une rgle on calcule FIRST().
Calcul de FIRST(X), pour tout X N On va construire un graphe d'hritage (orient) dont les sommets sont les lments de N; chaque sommet X aura une tiquette qui contiendra les lments de FIRST(X). Les arcs permettront de faire hriter de symboles terminaux (mais pas de ).Au dpart, le graphe n'a pas d'arc et les tiquettes sont toutes vides.
Pour chaque rgle de production de la forme X Y1Y2 ... Yn, (o chaque Yi est un caractre diffrent de NT) :Soit YK le premier Yi non nullable (si les Yi sont tous nullables, alors k=n)Si YK est terminal, AJOUTER YK FIRST(X); AJOUTER les arcs ( Yi ,X) de i=1 k-1.Sinon (YK est non-terminal), AJOUTER les arcs (Yi ,X) de i=1 k.
Faire hriter. AJOUTER est dans FIRST de tous les non-terminaux nullables.
19
Exemple : reprenons la grammaire G3 :E TE'E' +TE' | T FT' T' *FT' | F (E) | nSommets du graphe d'hritage : E, E', T, T', FSymboles nullables : E', T'.
E TE' : on ajoute l'arc (T,E)E' +TE' : on ajoute '+' dans FIRST(E')T FT' : on ajoute l'arc (F,T)T' *FT' : on ajoute '*' dans FIRST(T')F (E) : on ajoute '(' dans FIRST(F)F n : on ajoute 'n' dans FIRST(F)Graphe : E' {+}, T'{*}, F{(,n}, arcs (T,E), (F,T)T hrite de {(,n} de F, et E hrite de {(,n} de T.On ajoute ensuite aux tiquettes de T' et de E'.A la fin :
FIRST(E)={(,n}, FIRST(E')= { ,+}, FIRST(T)={(,n}, FIRST(T')={ ,*},FIRST(F)={(,n}.
Calcul de FIRST(), pour une partie droite de rgle=Y1Y2 ... Yn, (o chaque Yi est un caractre diffrent de NT) :
Si les Yi sont tous nullables, alors k=n, sinon YK est le premier Yi non nullable.FIRST()= FIRST(Y1) ... FIRST(YK).Si k=n, AJOUTER FIRST ().
Exemple sur G3:E TE'E' +TE' | T FT' T' *FT' | F (E) | n
20
1 = TE' : FIRST(TE') = FIRST(T) = {(,n}.2 = +TE' : FIRST(+TE') = {+}3 = : FIRST() = {}4 = FT' : FIRST(FT' ) = FIRST(F) = {(,n}. 5 = *FT' : FIRST(*FT' ) = {*}6 = : FIRST() = {}7 = (E) : FIRST((E))={(}8= n : FIRST(n)={n}
5.5. CalculduFOLLOWdesnonterminaux
De mme que pour FIRST, on construit un graphe d'hritage, dont les sommets sont les lments de N; chaque sommet X aura une tiquette qui contiendra les lments de FOLLOW(X).
Initialisation : mettre $ dans FOLLOW(S).
On va chercher 3 types de dcomposition des parties droites de rgles pour un symbole non-terminal B de cette partie droite.
1. A B , ( (N T)*, , (N T)+, mais peut tre nullable) : on met FIRST()- dans FOLLOW(B).
2. A B ou B avec nullable ( (N T)*, (N T)*) : ajouter l'arc (A,B) au graphe d'hritage.
Exemple sur la grammaire G3 :
1. rgles de type B ( )
rgle B FIRST() FOLLOW(B)(avant)
FOLLOW(B)(aprs)
E TE' T E' {,+} {+}
E' +TE' T E' idem idem idem
T FT' F T' { ,*} {*}
T' *FT' F T' idem idem idem
F (E) E ) {)} {$} {$,)}
21
rgle B FIRST() FOLLOW(B)(avant)
FOLLOW(B)(aprs)
22
2. rgles de type Brgle B A arc (A,B)
E TE' E' E (E,E')
E' +TE' E' E' rien
T FT' T' T (T,T')
T' *FT' T' T' rien
3. rgles de type B ( nullable)rgle B A arc (A,B)
E TE' T E' E (E,T)
E' +TE' T E' E' (E',T)
T FT' F T' T (T,F)
T' *FT' F T' T' (T',F)
On obtient le graphe o T est initialis {+}, F {*}, E * {$,)}, avec les arcs : (E,E'), (E,T), (E',T), (T,T'),(T,F), (T',F)
On obtient :FOLLOW(E) = { $,)}FOLLOW(E') = {$,) }FOLLOW(T) = { +,$,)}FOLLOW(T') = {+,$,) }FOLLOW(F) = { +, *, $,)}
23
6. L'analysedescendante(topdownparsing)
6.1. LeslangagesLL
Rappels
Principe : on se donne une grammaire G et un mot , et on construit un arbre de drivation en partant de l'axiome.
Exemples :
Grammaire G1 :S aA | bA dA | e
B f B| gmot analyser : = ade
Analyse descendante :S (r1) aA (r3) adA (r4) ade
Grammaire G2 :S ABA BA | aB b
mot : : bbab
Analyse descendante :S (r1) AB (r2) BAB (r4) bAB (r2) bBAB (r4) bbAB (r3) bbaB (r4) bbab
On a construit une drivation gauche de , reprsentable par la suite de rgles (r1,r2,r4,r2,r4,r3,r4), en utilisant un symbole de "look-ahead".
Cette technique est utilise pour des grammaires particulires, appeles LL(k) s'il y a k symboles de "look-ahead" utiliser.
LL(k)="scanning the input from Left to right producing a Leftmost derivation, with k symbols of look-ahead".
- Avantages : cette technique est simple, trs efficace et facile implmenter.
24
- Inconvnient : elle ne fonctionne sans conflits que sur une sous-classe des langages algbriques dterministes.
- On dit qu'un langage L est LL(k) s'il existe une grammaire LL(k) qui engendre L.- Un langage est LL(k) si il est LL(1).- On parlera de la classe des langages LL.
Exemple de grammaire LL(1) : la grammaire G3 est une version LL de la grammaire LALR(1) des expressions arithmtiques simples.G3 :E TE'E' +TE' | T FT' T' *FT' | F (E) | n
6.2. CaractrisationdesgrammairesLL(1)
Rappel : on dit qu'un symbole non-terminal A est nullable si A * , on dit qu'une chane de caractres est nullable si * .
Pour dfinir une grammaire LL(1), on utilise les fonctions FIRST et FOLLOW, qui permettront de choisir la rgle de grammaire appliquer.
Caractrisation Une grammaire algbrique G est dite LL(1) si A N, associ aux rgles de production A 1 | 2 | .... | non a, i,j , i j,- FIRST(i) FIRST(j) = - et, pour tout i nullable : FIRST(j) FOLLOW(A) =
Cette dfinition peut s'tendre aux grammaires LL(k).FIRST et FOLLOW serviront construire la table d'analyse LL.
6.3. L'analyseurLL
On utilise encore une fois une table d'analyse, et la grammaire est LL(1) si et seulement si la table est sans conflit. Une case vide correspond un 'reject'.
25
Exemple : voici la table d'analyse de la grammaire G3 :
G3 :E TE'E' +TE' | T FT' T' *FT' | F (E) | n
non-tre n (nombre) + * ( ) $E r1E TE' r1E TE'E' r2E'
+TE'r3E' r3E'
T r4T FT' r4T FT' T' r6T' r5T'
*FT' r6T' r6 T'
F r8F n r7F (E)
colonnes : les symboles terminaux et $lignes : les symboles non-terminauxcases : les rgles de production
On utilise une pile initialise Z0, S, et un symbole de "look-ahead" p qui pointe sur le caractre courant du mot analyser.
Etape d'analyse :On compare le symbole de haut de pile X avec p.
1er cas : X est un symbole terminal (X T)- si X = p, on dpile X et on dcale p.- sinon, REJECT.
2e cas : X est un symbole non-terminal (X N)- si [X,p] est une rgle X , on dpile X (et on n'empile rien).- si [X,p] est une rgle X Y1Y2 ... Yn, (o chaque Yi est un caractre diffrent), on dpile X et on empile Yn....Y1 (sauf ).- si [X,p] est une case vide : REJECT.
26
3e cas : X=Z0- si p=$, ACCEPT.- sinon, REJECT.
Exemple : on va analyser le mot = 2 + 3 * 4.
Pile p caseZ0,E 2 [E,n] r1: E TE'Z0, E', T 2 [T,n] r4 : T FT' Z0, E', T',F 2 [F,n] r8 : F n
Z0, E', T',n 2 n=2 dcalageZ0, E', T' + [T',+] r6 : T'
Z0, E' + [E',+] r2 : E' +TE'
Z0, E',T,+ + + = + dcalageZ0, E',T 3 [T,n] r4 : T FT' Z0, E',T',F 3 [F,n] r8 : F n
Z0, E',T',n 3 n=3 dcalageZ0, E',T' * [T',*] r5 : T' *FT'
Z0, E',T',F,* * * = * dcalageZ0, E',T',F 4 [F,n] r8 : F n
Z0, E',T',n 4 n = 4 dcalageZ0, E',T' $ [T',$] r6 : T' Z0, E' $ [E',$] r3 : E'
Z0 $ [Z0,$] ACCEPT
Suite de rgles : (r1, r4, r8, r6, r2, r4, r8, r5, r8, r6, r3).Drivation gauche correspondante :
E (r1)TE' (r4) FT'E' (r8)nT'E' (r6) nE' (r2) n+TE' (r4) n+FT'E' (r8) n+nT'E' (r5) n+n*FT'E'(r8) n+n*nT'E' (r6) n+n*nE' (r3) n+n*n
27
6.4. Calculdelatabled'analyseLL
On peut vrifier que G3 est bien une grammaire LL(1) :
Rgle de production factorise
FIRST(i) FIRST(j)
j nullables si oui, FOLLOW(A)FIRST
(j) E TE' rien rien
E' +TE' | FIRST(+TE')={+}, FIRST()={}OK
FOLLOW(E')= {$,) }OK
T FT' rien rien
T' *FT' | FIRST(*FT')={*}, FIRST()={}OK
FOLLOW(T')= {+,$,) }OK
F (E) | n FIRST((E))={(}, FIRST(n)={n}OK
rien
Construction de la table d'analyse LL(1)
Pour chaque rgle de production A Pour chaque a dans FIRST()
Mettre A dans la case [A,a] Si en plus est nullable, pour chaque b FOLLOW(A)
Mettre A dans a case [A,b]
Exemple sur la grammaire G3 :E TE'E' +TE' | T FT' T' *FT' | F (E) | n
28
FOLLOW(E) = { $,)}FOLLOW(E') = {$,) }FOLLOW(T) = { +,$,)}FOLLOW(T') = {+,$,) }FOLLOW(F) = { +, *, $,)}
1 = TE' : FIRST(TE') = FIRST(T) = {(,n}.2 = +TE' : FIRST(+TE') = {+}3 = : FIRST() = {}4 = FT' : FIRST(FT' ) = FIRST(F) = {(,n}. 5 = *FT' : FIRST(*FT' ) = {*}6 = : FIRST() = {}7 = (E) : FIRST((E))={(}7 = n : FIRST(n)={n}
Rgle r1 : E TE' : FIRST(TE')={(,n} : on met r1 dans [E,(] et dans [E,n]Rgle r2 : E' +TE' : FIRST(+TE')={+} : on met r2 dans [E',+] Rgle r3 : E' : FIRST( )={ } ; est nullable ; FOLLOW(E')={$,) } ; on met r3 dans [E',$] et dans E',)]Rgle r4 : T FT' : FIRST(FT')={(,n} ; on met r4 dans [T,(] et dans [T,n].Rgle r5 : T' *FT' ; FIRST(*FT') = {*} ; on met r6 dans [T'*].Rgle r6 : T' : est nullable ; FOLLOW(T') = {+,$,) } ; on met r6 dans [T', +], [T',$ ] et dans [T', )].Rgle r7 : F (E) ; FIRST((E)) = {(} ; on met r7 dans [F,)].Rgle r8 : F n ; FIRST(n)={n} ; on met r8 dans [F,n].On retrouve la table utilise ci-dessus.
6.5. Procdsdercritured'unegrammairenonLL(1)
Rappel : on dit que l'on rcrit une grammaire G si on calcule une grammaire G' quivalente G.
6.5.1. Rcursivit
Une grammaire algbrique G est dite rcursive gauche (left recursive) si et
29
seulement si elle contient un non-terminal A tel que A * A , NT.
Exemple :G1 : E E+T | TT T*F | FF (E) | nG1 est rcursive gauche.
Proprit :Une grammaire rcursive gauche n'est pas LL(1).On peut parfois liminer la rcursivit en rcrivant la grammaire.On distingue : La rcursivit gauche immdiate Il existe une rgle de type A A .Elimination de la rcursivit gauche immdiate : pour chaque non-terminal A, on remplace A A 1 | .... | A m | 1 |... | npar :A 1 A' | .... |n A'A' 1 A' | .... | m A'| On obtient une grammaire quivalente.Exemple :G1 : E E+T | TT T*F | FF (E) | nTraitement de E E+T | T :A A 1 | 1
30
on remplace par :E TE'E' +TE' | .Traitement de T T*F | Fon remplace par :T FT'T' *FT' | On obtient la grammaire G3 :E TE'E' +TE' | T FT' T' *FT' | F (E) | n
La rcursivit gauche non immdiate Une grammaire est rcursive gauche (non immdiatement) si elle contient un non-terminal A tel que A + A , NT.
Exemple : GS Aa | bA Ac | Sd |
On a : S Aa Sda , donc G est rcursive gauche mais non immdiatement.Elimination de la rcursivit gauche :
1. Attribuer un ordre arbitraire aux non-terminaux : (X1, X2, .....Xn)2. Pour i=1 n faire
Pour j=1 i-1 faire Remplacer chaque production de la forme Xi Xj , avec Xj 1 | .... |r
par :Xi 1 |.... | r Eliminer les rcursivits gauches immdiates pour Xi.
31
On obtient une grammaire quivalente.
Exemple :S Aa | bA Ac | Sd | i=1 : Xi = S : pas de rcursiviti=2 et j=1 : Xi = A et Xj = S : remplacer A Sd, o S Aa | b par : A Aad | bdEliminons ensuite la rcursivit gauche immdiate de :A Ac| Aad | bd | on remplace par :A bdA' | A'A' cA' | adA' | On obtient finalement :S Aa | bA bdA' | A'A' cA' | adA' | Remarque : ce procd de rcriture ne supprime pas toujours la rcursivit, par exemple pour :S Sa | Tsc | dT TbT |
6.5.2. FactorisationFactorisation gaucheOn dit qu'un grammaire algbrique G est non factorise gauche si elle contient un non-terminal A dont l'ensemble des parties droites de productions est de la forme A 1 | 2....|1|....|p
Proprit : Une grammaire non factorise gauche n'est pas LL(1).
32
Procd de factorisation gauche Pour chaque non-terminal A, trouver un plus long prfixe commun plusieurs parties droites de production dont A est partie gauche.A 1 | 2....| n|1|....|pRemplacer par :A A' | 1|....|pA' 1 | 2....| nRecommencer jusqu' ce qu'il n'y ait plus de prfixe propre commun.
On obtient une grammaire quivalente.
Exemple : Voici une grammaire G4 (encore une version de la grammaire G1 des expressions arithmtiques simple)G4 :E T + E | TT F* T | FF (E) | nRcriture de la rgle :E T + E | T :on obtient :E TE'E' +E | Rcriture de la rgle :T F* T | Fon obtient :T FT'T' *T | Soit globalement, la grammaire quivalente :E TE'E' +E | T FT'T' *T | F (E) | n
33
34
6.6. Feuilled'exercices2:leslangagesLL
1. Calculer la table d'analyse LL(1) pour :S iBaeB TB | T [eD] | diD ed |
2. Calculer la table d'analyse LL(1) pour (aprs avoir factoris) :S aB | bAA a | aS | bAAB b | bS | aBB
3. Considrons la grammaire G2 :E E+E | E*E | (E) | n
1. Montrer que G2 est rcursive gauche et non factorise gauche.2. Rcrire G2 en commenant par la factoriser, puis en traitant la rcursivit,
obtenant la grammaire G'2.3. Rcrire G2 en commenant par traiter la rcursivit, puis en factorisant, obtenant
la grammaire G2.4. Construire les deux tables d'analyse. G'2 et G2 sont-elles LL(1)?
Procder l'analyse du mot = 4+5 pour les deux grammaires.
35
7. L'analyseascendanteetleslangagesLR
7.1. Principedushiftreduceparsing
Principe : On se donne un mot , on le lit caractre par caractre et on tente dereconstituer une drivation.
On va utiliser une pile qui va aider reprer des parties droites de rgles. On va donc empiler jusqu' ce qu'on trouve une partie droite, puis on va dpiler cette partie droite ( l'envers) et rempiler la partie gauche sa place.
On utilise 2 oprations lmentaires :
- L'opration de dcalage (shift) qui consiste empiler le caractre courant, puis lire le caractre suivant du mot analyser.
- L'opration de rduction (reduce), qui consiste remplacer la partie droite d'une rgle par sa partie gauche (on dpile la partie droite de rgle correspondante et on rempile la partie gauche).
Exemple : Grammaire G3 :S aABeA Abc | bB d
mot = abbcde
abbcde (shift a) abbcde (shift b) abbcde (red 3 : A b) aAbcde (shift b) aAbcde(shift c) aAbcde(red 2 : A Abc) aAde (shift d) aAde (red 4 : B d)aABe (shift e) aABe (red 1 : S aABe) S
On a construit la drivation droite :S (r1)aABE (r4)aAde (r2) aAbcde (r3)abbcde
mot driv. pile_avt action pile aprsabbcde$ abbcde [ shift (a) [aabbcde$ abbcde [a shift (b) [a,babbcde$ abbcde [a,b red 3 A b [a,Aabbcde$ aAbcde [a,A shift (b) [a,A,b
36
abbcde$ aAbcde [a,A,b ???? CONFLIT!ON NE SAIT PAS SI ON shift (pour aller vers Abc) ou si red 3 (A b)ON CHOISIT SHIFT shift (c) [a,A,b,cabbcde$ aAbcde [a,A,b,c red 2 : A Abc [a,Aabbcde$ aAde [a,A shift (d) [a,A,dabbcde$ aAde [a,A,d red 4 : B d [a,A,Babbcde$ aAde [a,A,B shift (e) [a,A,B,eabbcde$ aAde [a,A,B,e red 1 : S aABe [S
On a S et $ : on a gagn !
On a dfini par l'analyse une suite de rgles qui dfinit la drivation droite obtenue.Cette mthode d'analyse s'appelle le 'shift-reduce parsing'.
Lorsque l'on ne sait pas s'il faut choisir un shift ou un reduce, on rencontre un conflit shift-reduce ; lorsqu'on a les choix entre l'applications de plusieurs rgles, on rencontre un conflit reduce-reduce.
7.2. LesgrammairesLRetLALR
Le shift-reduce parsing peut se faire sans conflit pour les grammaires LR(k).
LR(k)=Left-to-Right scan of the input producing a Rightmost derivation using k symbols of look-ahead.
Dfinition :On appelle grammaire LR(k), une grammaire algbrique G qui permet, en connaissant les k caractres suivants du mot analyser, de dcider (de faon dterministe) quelle opration appliquer pour arriver la drivation d'un mot de L(G).
Dfinition :On appelle langage LR(k) un langage algbrique tel qu'il existe une grammaire LR(k) qui l'engendre.
Thorme :Tout langage LR(k) est aussi LR(1).
On appelle LR un langage qui est LR(1).
37
Thorme :Un langage est LR si et seulement si il est algbrique et dterministe.
Pour dcider si un mot appartient au langage dfini par une grammaire LR, on utilise un automate pile dterministe particulier (analyseur LR) prsent sous forme d'une table d'analyse.
- Une table LR(k) est de dimension k+1.- Dans la pratique, on n'utilise que les tables LR(1), qui sont des tables double entre.
La classe des langages LL est strictement incluse dans la classe des langages LR :
langages rationnels langages LL langages LR = langages algbriques dterministes langages algbriques
7.3. L'analyseurLR(1)
On se donne :
- une table d'analyse- une pile, qui contient une alternance d'tats numrots et de caractres de N T- un mot analyser - un pointeur p sur la lettre courante de
Initialisation :On empile 0 et p pointe sur le premier caractre de .
Etape d'analyse :On lit le haut de la pile (1 ou 2 caractres), et avec p, on en dduit une case de la table qui va contenir des instructions.
1er cas :Le symbole de haut de pile est un non-terminal F, on lit les 2 caractres de haut de pile [i,F] qui donne un tat j, que l'on empile. 2e cas :Le symbole de haut de pile est un tat i, on lit la case [i,p] de l'analyseur.
38
cas 2.1 : T[i,p]=rj (une rgle de la forme A ), on dpile jusqu' obtenir ( l'envers) tous les caractres conscutifs de , puis on empile A.
cas 2.2 : T[i,p]=$sj$, on va effectuer un shift : on dcale p; on empile l'ancien p; on empile l'tat j.
cas 2.3 : T[i,ps] est vide : REJECT : le mot n'appartient pas au langage.
cas 2.4 : T[i,ps] = ACCEPT, le mot est accept, et on obtient une drivation droite de ce mot en reprenant ( l'inverse) la suite des rgles utilises.
Exemple : Grammaire G1 des expressions arithmtiques :r1 : E E + Tr2 : E Tr3 : T T * Fr4 : T Fr5 : F (E)r6 : F 0|1|2|3|4|5|6|7|8|9ou : r6 : F nb
Table d'analyse : Etat nb + * ( ) $ E T F0 s5 s4 1 2 31 s6 ACC2 r2 s7 r2 r23 r4 r4 r4 r44 s5 s4 8 2 35 r6 r6 r6 r66 s5 s4 9 37 s5 s4 108 s6 s119 r1 s7 r1 r110 r3 r3 r3 r311 r5 r5 r5 r5
39
mot analyser : 3+4*2$
Pile p case action0 3 0,nb s50,3,5 + 5,+ r6 : F nb0,F + 0,F 30,F,3 + 3,+ r4 : T F0,T + O,T 20,T,2 + 2,+ r2 : E T0,E + 0,E 10,E,1 + 1,+ s60,E,1,+,6 4 6,nb s50,E,1,+,6,4,5 * 5,* r6 : F nb0,E,1,+,6,F * 6,F 30,E,1,+,6,F,3 * 3,* r4 : T F0,E,1,+,6,T * 6,T 90,E,1,+,6,T,9 * 9,* s70,E,1,+,6,T,9,*,7 2 7,nb s50,E,1,+,6,T,9,*,7,2,5 $ 5,$ r6 : F nb0,E,1,+,6,T,9,*,7,F $ 7,F 100,E,1,+,6,T,9,*,7,F,10 $ 10,$ r3 :T T * F 0,E,1,+,6,T $ 6,T 90,E,1,+,6,T,9 $ 9,$ r1 : E E + T0,E $ 0,E 10,E,1 $ 1,$ ACCEPT
Suite de rgles utilises : r6,r4,r2,r6,r4,r6,r3,r1
40
Drivation droite correspondante :(1,3,6,4,6,2,4,6)
7.4. Les grammaires LALR
On a vu le fonctionnement de l'analyseur LR(1).Dans la pratique, on utilise des tables LALR(1), qui sont obtenues en contractant certains tats de la table LR(1) correspondante.
Avantages :- La table obtenue est nettement plus petite : on gagne du temps.- Ces grammaires 'marchent' de faon satisfaisante.
Inconvnients :- Les langages LALR sont une classe restreinte de langages LR.- On peut introduire des conflits alors que la grammaire de dpart tait bien LR(1).
YACC construit des tables LALR(1).
Gestion des conflits par YACC
conflit shift/reduce : YACC choisit le shift
conflit reduce/reduce : YACC choisit de rduire par la rgle de plus petit numro
Remarque : la faon de grer les conflits correspond des interprtations diffrentes du flot d'entre.
41
7.5. Feuilled'exercices3:l'analyseurLALR
Voici des grammaires avec pour chacune un mot analyser. Vous trouverez les excutions YACC dans l'annexe 3. Pour chaque grammaire, construire la table d'analyse. Pour chaque mot analyser, signaler les ventuels conflits et la faon dont ils ont t rsolus, donner la suite de rgles obtenue, ainsi que la drivation droite et l'arbre syntaxique correspondant.
1. Grammaire G1 des expressions arithmtiques : mot (2+3)
2. Grammaire rgulire engendrant le langage (aa + bb)+ : mot bbaabb
3. Mots bien parenthss sur {a,b} : mot aababb
4. Langage 'EQUAL' (autant de 'a' que de 'b') : mot abba
5. Grammaire de anbn : mot aaabbb
6. Trailing Count : mot : abaaaa
7. Even-Even (un nombre pair de 'a' et un nombre pair de 'b') version rgulire : mot abbabb
8. Even-Even (un nombre pair de 'a' et un nombre pair de 'b') version non rgulire : mot abbabb
42
7.6. Feuilled'exercices4:tudedesconflitsdanslestablesLALR(1)On va comparer deux grammaires des expression algbriques simples suivantes (n est un nombre). La sortie YACC pour G2 est donne la fin. G1 : E E+T | TT T*F | FF (E) | nG2 : E E+E | E*E | (E) | n
Question 1 - Pour les mots 1= 1+2+3 et 2 = 4+5*6, donner tous les arbres syntaxiques possibles. Que remarque-t-on?- Pour chaque arbre syntaxique, donner la drivation droite ainsi que l'interprtation correspondante. (Rappel : l'interprtation est le parenthsage de l'expression).
Question 2 Justifiez vos rponses aux questions suivantes :- G1, G2 sont-elles ambigus ?- G1 et G2 sont-elles quivalentes?- G1 et G2 sont-elles LALR(1)? LR(1)?- Quels sont les avantages et les inconvnients de G1 et de G2 ?
Question 3 Interprtations des formules incompltement parenthses :Rappels : associativit droite de + : 1+2+3 s'interprte comme (1+(2+3))associativit gauche de + : 1+2+3 s'interprte comme ((1+2)+3)prcdence de + sur * : 4+5*6 s'interprte comme ((4+5)*6)prcdence de * sur + : 4+5*6 s'interprte comme (4+(5*6))Quelle est la prcdence entre + et * dfinie par G1 ? G1 utilise-t-elle l'associativit gauche ou droite? Comment pourrait-on modifier ces paramtres?
43
Question 4 On va maintenant tudier la prcdence et l'associativit pour G2. En se servant de la question 1, donner la suite de rgles attendue dans une analyse syntaxique du mot 1= 1+2+3 pour que + soit associative gauche, droite? Et de mme, donner la suite de rgles attendue dans une analyse syntaxique du mot 2 = 4+5*6, pour que * ait prcdence sur +, ou que + ait prcdence sur *?
Question 5 Rsolutions de conflits dans G2Comment doit-on rsoudre les conflits dans G2 (tats 9 et 10) pour que :- * ait prcdence sur +- + ait prcdence sur *- + soit associatif gauche- + soit associatif droite.Dcrire les 8 cas rencontrs pour les 4 conflits dcalage/rduction , et expliquer quel choix sur la prcdence ou l'associativit ils correspondent.
Question 6 Gestion des erreursDans quelles cases vides de la table d'analyse de G2 pourrait-on mettre les messages d'erreurs suivants :- err 1 : 'oprande manquant'- err 2 : 'parenthse ouvrante manquante'- err 3 : 'oprateur manquant'- err 4 : 'parenthse fermante manquante'Expliquez pourquoi.
44
Sortie YACC pour G2 0 $accept : E $end
1 E : E '+' E
2 | E '*' E
3 | '(' E ')'
4 | 'n'
state 0
$accept : . E $end (0)
'(' shift 1
'n' shift 2
. error
E goto 3
state 1
E : '(' . E ')' (3)
'(' shift 1
'n' shift 2
. error
E goto 4
state 2
E : 'n' . (4)
. reduce 4
state 3
$accept : E . $end (0)
E : E . '+' E (1)
E : E . '*' E (2)
$end accept
45
'+' shift 5
'*' shift 6
. error
state 4
E : E . '+' E (1)
E : E . '*' E (2)
E : '(' E . ')' (3)
'+' shift 5
'*' shift 6
')' shift 7
. error
state 5
E : E '+' . E (1)
'(' shift 1
'n' shift 2
. error
E goto 8
state 6
E : E '*' . E (2)
'(' shift 1
'n' shift 2
. error
E goto 9
state 7
E : '(' E ')' . (3)
. reduce 3
8: shift/reduce conflict (shift 5, reduce 1) on '+'
46
8: shift/reduce conflict (shift 6, reduce 1) on '*'
state 8
E : E . '+' E (1)
E : E '+' E . (1)
E : E . '*' E (2)
'+' shift 5
'*' shift 6
$end reduce 1
')' reduce 1
9: shift/reduce conflict (shift 5, reduce 2) on '+'
9: shift/reduce conflict (shift 6, reduce 2) on '*'
state 9
E : E . '+' E (1)
E : E . '*' E (2)
E : E '*' E . (2)
'+' shift 5
'*' shift 6
$end reduce 2
')' reduce 2
State 8 contains 2 shift/reduce conflicts.
State 9 contains 2 shift/reduce conflicts.
7 terminals, 2 nonterminals
5 grammar rules, 10 states
47
8. ConstructiondestablesLALR(1)
8.1. Notationsetdfinitions
Dans toute la suite, on considrera une grammaire G=(N,T,P,S).Une rgle de P sera dsigne par :A ou bien par : A X1X2...Xn , o chaque Xi est un caractre de NT .
ItemsEtant donne un rgle A X1X2...Xn , un item est cette rgle avec un point insr dans la partie droite. Par exemple, A X1 X2...Xn est un item.Ce point peut aussi tre positionn au dbut ou la fin de la chane.A X1X2...Xn et A X1X2...Xn sont des items.Le point symbolise la pile : ce qui est gauche du point est empil.Le but est d'empiler une partie droite de rgle, pour pouvoir procder une rduction.
Grammaire augmenteOn ajoute une rgle fictive S' S G.
On va construire un automate (un graphe de transitions) dont les sommets sont des tats et o les arcs d'un sommet vers un autre sont tiquets par des transitions.
Les tats contiennent des items.
Principe gnral : On dfinit un procd de fermeture dun tat On initialise avec un tat I0. On ferme I0. On dfinit les transitions partir de I0, crant de nouveaux tats. On ferme chaque nouvel tat et on dfinit les transitions dont il est l'origine. et ainsi de suite...
48
8.2. Casparticulier:lestablesLR(0)
Etat initial : I0= S' S
Procd de fermeture d'un tat
Pour chaque rgle de type A X1 X2...Xi Xi+1 ...Xn (le point n'est pas la fin) telle que Xi+1 est dans N, pour chaque rgle de type Xi+1 , on ajoute l'item Xi+1 .
On recommence sur les nouveaux items jusqu stabilit.
Transition de l'tat Ii l'tat IjPrincipe : on cre un nouvel item en dcalant le point d'un cran vers la droite.Par exemple, A X1 X2...Xn devient A X1 X2. X3..Xn La transition associe est tiquete par X2
Exemple (extrait du cours de Keith Schwarz) : G :E' EE TE E+TT intT (E)
49
Construction de la table partir de l'automate : Si S' > S est dans l'tat Ii : Action[i,$] = ACCEPT Si A (A S) est dans l'tat Ii : Action[i,a] = reduce avec A pour tout
a. Si A X1 X2...Xi Xi+1 ...Xn est dans l'tat Ii et qu'il y a une transition vers l'tat Ij
par le terminal Xi+1 : Action[i,Xi+1] = shift j Si A X1 X2...Xi Xi+1 ...Xn est dans l'tat Ii et qu'il y a une transition vers l'tat Ij
par le non-terminal Xi+1 : Goto (i,Xi) = j
Sur l'exemple :
+ ( ) int $ E TI0 s3 s4 1 2
I1 s5 ACCEPTI2 r1 r1 r1 r1 r1
I3 s3 s4 6 2I4 r3 r3 r3 r3 r3
50
I5 s3 s4 8
I6 s5 s7I7 r4 r4 r4 r4 r4
I8 r2 r2 r2 r2 r2
Le langage est LR(0) si sa table LR(0) est sans conflit.
Malheureusement, la classe des langages LR(0) est trs limite. (par exemple, une partie droite ne doit pas tre prfixe d'une autre partie droite ; deux parties droites ne doivent pas tre identiques, etc.)
8.3. ConstructiondestablesLR(1)
On va insrer un caractre de 'look-ahead' pour passer la classe LR(1).Pour cela, on va ajouter chaque item une liste de terminaux qui indiqueront quelles sont les transitions autorises lors d'une opration de rduction (reduce).
Notation : A X1 X2...Xi Xi+1 ...Xn , [a1, a2, ....]X1 X2...Xi Xi+1 ...Xn s'appelle le coeur de l'item ; on appellera [a1, a2, ....] le look-ahead de l'item.Abus de langage : on dira que A X1 X2...Xi Xi+1 ...Xn , ai est un item.
Etat initial : I0= S' S , [$]
Procd de fermeture d'un tat
Pour chaque item de type A B , a (avec B dans N) pour chaque rgle de type B , pour chaque terminal b dans FIRST (a) ,on ajoute l'item B , b
51
Exemple sur G (extrait du cours de Keith Schwarz) :
Calcul de la table LR(1) : Comme pour les tables LR(0) sauf que Si A , x (A S) est dans l'tat Ii : Action[i,x] = reduce avec A
Sur l'exemple :
52
8.4. Tables LAR(1)
Inconvnient : les tables LR(1) peuvent tre normes.Souvent, l'automate comporte des tats presque identiques.Exemple :
Seule diffrence : le look-ahead.
53
On va fusionner les tats qui ont le mme cur, et on fera l'union des look-aheads correspondants.Cette fusion peut engendrer des conflits supplmentaires de type reduce/reduce.
54
Exemple 1 : langage (aa + bb) +G1 : S aA | bB A aS | a B bS | b
graphe de transitions LALR(1) de G1 :
55
Sortie YACC pour G1 : 0 $accept : S $end 1 S : 'a' A 2 | 'b' B 3 A : 'a' S 4 | 'a' 5 B : 'b' S 6 | 'b'state 0
$accept : . S $end (0)'a' shift 1'b' shift 2. errorS goto 3
state 1S : 'a' . A (1)'a' shift 4. errorA goto 5
state 2S : 'b' . B (2)'b' shift 6. errorB goto 7
state 3$accept : S . $end (0)$end accept
state 4A : 'a' . S (3)A : 'a' . (4)'a' shift 1'b' shift 2$end reduce 4S goto 8
state 5S : 'a' A . (1). reduce 1
state 6B : 'b' . S (5)B : 'b' . (6)
56
'a' shift 1'b' shift 2$end reduce 6S goto 9
state 7S : 'b' B . (2). reduce 2
state 8A : 'a' S . (3). reduce 3
state 9B : 'b' S . (5). reduce 5
4 terminals, 4 nonterminals7 grammar rules, 10 states
57
Exemple 2 : langage 'trailing count'G2 : S aSb | bSb |
graphe de transitions LALR(1) de G2 :
58
Sortie YACC pour G2 : 0 $accept : S $end 1 S : 'a' S 'b' 2 | 'b' S 'b' 3 |state 0
$accept : . S $end (0)S : . (3)'a' shift 1'b' shift 2$end reduce 3S goto 3
1: shift/reduce conflict (shift 2, reduce 3) on 'b'state 1
S : 'a' . S 'b' (1)S : . (3)'a' shift 1'b' shift 2S goto 4
2: shift/reduce conflict (shift 2, reduce 3) on 'b'state 2
S : 'b' . S 'b' (2)S : . (3)'a' shift 1'b' shift 2S goto 5
state 3$accept : S . $end (0)$end accept
state 4S : 'a' S . 'b' (1)'b' shift 6. error
state 5S : 'b' S . 'b' (2)'b' shift 7. error
state 6S : 'a' S 'b' . (1). reduce 1
59
state 7S : 'b' S 'b' . (2). reduce 2
State 1 contains 1 shift/reduce conflict.State 2 contains 1 shift/reduce conflict.
4 terminals, 2 nonterminals4 grammar rules, 8 states
60
8.5. Feuille d'exercices 5 : construction de tables LALR(1)Construire les tables LALR(1) pour :
1. Le langage anbn : S aSb | abPuis vrifier partir de l'xcution donne en annexe.
2. Le langage S iSeS | iS | a
3. Le langage des mots bien parenthss S aSb | SS | Puis vrifier partir de l'xcution donne en annexe.
61
1. Introduction1.1. Dfinition de la compilation1.2. Quelques problmes poss1.3. Un aperu des phases de la compilation
2. Quelques rappels de thorie des langages (voir Annexe)2.1. Feuille d'exercices 1 : rvisions de thorie des langages
3. L'analyse lexicale4. L'analyse syntaxique5. Les fonctions FIRST et FOLLOW5.1. Symboles nullables5.2. Dfinition de FIRST5.3. Dfinition de FOLLOW5.4. Calcul du FIRST5.5. Calcul du FOLLOW des non-terminaux
6. L'analyse descendante (top-down parsing)6.1. Les langages LL6.2. Caractrisation des grammaires LL(1)6.3. L'analyseur LL6.4. Calcul de la table d'analyse LL6.5. Procds de rcriture d'une grammaire non LL(1)6.5.1. Rcursivit
Une grammaire algbrique G est dite rcursive gauche (left recursive) si et seulement si elle contient un non-terminal A tel que6.5.2. Factorisation
6.6. Feuille d'exercices 2: les langages LL
Procder l'analyse du mot = 4+5 pour les deux grammaires.7. L'analyse ascendante et les langages LR7.1. Principe du shift-reduce parsing7.2. Les grammaires LR et LALR7.3. L'analyseur LR(1)7.4. Les grammaires LALR7.5. Feuille d'exercices 3 : l'analyseur LALR7.6. Feuille d'exercices 4 : tude des conflits dans les tables LALR(1)
8. Construction des tables LALR(1)8.1. Notations et dfinitions8.2. Cas particulier: les tables LR(0)8.3. Construction des tables LR(1)8.4. Tables LAR(1)8.5. Feuille d'exercices 5 : construction de tables LALR(1)
