Cours de compilation

1. Cours de compilation Analyse lexicale Analyse syntaxique (intro) Cours de compilation 3 - Intranet

2. Les grandes lignes du cours • Définitions de base • Composition de compilateurs • L’environnement d’un compilateur • Evaluation partielle et compilation • Analyses lexicales et syntaxiques • Techniques d’analyse descendantes • Techniques d’analyse ascendantes • YACC • Analyse sémantique • Environnement d’exécution • Génération de code • Optimisation de code Cours de compilation 3 - Intranet

3. Les constituants d’un compilateur---------------------------------------------------------------- } Analyse lexicale Analyse syntaxique Analyse du texte source Analyse sémantique } Allocation mémoire Génération de code Génération du texte de sortie Optimisation de code Cours de compilation 3 - Intranet

4. Les constituants d’un compilateur---------------------------------------------------------------- } Analyse lexicale Ces phases sont réalisées en même temps : nous reconnaissons des mots, jusqu’à obtenir une phrase, que nous vérifions pour le typage et nous passons à la suite. Analyse syntaxique Analyse sémantique Allocation mémoire Génération de code Optimisation de code Cours de compilation 3 - Intranet

5. Les constituants d’un compilateur---------------------------------------------------------------- Analyse lexicale Analyse syntaxique Analyse sémantique } Allocation mémoire Ces phases sont souvent réalisées simultanément. Génération de code Optimisation de code C’est presqu’un compilateur à part. Cours de compilation 3 - Intranet

6. Principe de l’analyse lexicale---------------------------------------------------------------- • Il s’agit de traduire une suite de caractères en une suite de « lexèmes » (mots, token). • Nous devons donc reconnaître les séparateurs explicites (espace, passage à la ligne, . . .) et implicites (rien) qui séparent les entités. • Nous déterminons la catégorie d’appartenance (mot réservé, nombre, opérateur, . . .) de chaque lexème. if A = 1 then . . . fi Mot_réservé_if Var ( A ) Oprel ( = ) Entier ( 1 ) Mot_réservé_then . . . Mot_réservé_fi Cours de compilation 3 - Intranet

7. Principe de l’analyse syntaxique---------------------------------------------------------------- • Il s’agit de reconnaître la structure du programme. • Nous allons construire une représentation structurée (sous forme d’arbre de syntaxe abstraite) du programme. • Pour l’analyse, nous nous appuyons sur une grammaire du langage à analyser. MR_if Var( A ) Oprel( = ) Entier( 1 ) MR_then . . . MR_fi Si_alors Test Bloc Cours de compilation 3 - Intranet

8. Principe de l’analyse syntaxique---------------------------------------------------------------- • Il s’agit de reconnaître la structure du programme. • Nous allons construire une représentation structurée (sous forme d’arbre de syntaxe abstraite) du programme. • Pour l’analyse, nous nous appuyons sur une grammaire du langage à analyser. Var( A ) Oprel( = ) Entier( 1 ) . . . Si_alors Arbre de syntaxe abstraite Test Bloc Cours de compilation 3 - Intranet

9. Principe de l’analyse sémantique---------------------------------------------------------------- • Nous devons maintenant vérifier le sens du programme. • Nous collectons les déclarations des variables et fonctions dans la table des symboles et nous nous assurons que tout est déclaré et utilisé conformément aux déclarations. • Nous opérons peut-être des petites transformations et nous explicitons des conversions de types implicites : 2 * A => A + A add_float add 1.5 int_to_float int x x 1.5 x Cours de compilation 3 - Intranet

10. L ‘ A N A L Y S E L E X I C A L E Cours de compilation 3 - Intranet

11. L’analyse lexicale---------------------------------------------------------------- • Nous découpons le programme en lexèmes. Nous déterminons leurs classes d’appartenance : • Mots clefs : if while . . . • Opérateurs : + == = . . . • Nombres : 100 100.08 . . . • Séparateurs : ; , «  » . . . • Variables : « les autres » • Les lexèmes sont reconnus par la grammaire du langage. • Ce sont presque toujours des expressions régulières qui peuvent donc être reconnues par un automate. Cours de compilation 3 - Intranet

12. L’analyse lexicale---------------------------------------------------------------- • Petit rappel sur les expressions régulières : • Tout caractère isolé est régulier. • Toute séquence finie d’expressions régulières est régulière. • Un choix fini entre expressions régulières est régulier comme [ a-d | h-p ]. • u*, c’est-à-dire la répétition du motif « u » n fois, avec n >= 0, est régulier. • u+, c’est-à-dire la répétition du motif « u » n fois, avec n > 0, est régulier. Cours de compilation 3 - Intranet

13. L’analyse lexicale---------------------------------------------------------------- • L’automatisation de l’analyse lexicale : • « lex » ou « flex » prennent des fichiers d’expressions régulières et les actions associées et construisent l’automate d’analyse. • Nous aurons donc les commandes : lex fichier_lex cc -ll lex.y.cc a.out < fichier_source • Format d’un fichier lex : %% mot_à_reconnaître action_en_C . . . %% Ce qui n'est pas reconnu est rendu tel quel ! Cours de compilation 3 - Intranet

14. L’analyse lexicale---------------------------------------------------------------- • Attention aux cas ambigus : : := = • L’ordre des lexèmes donne la priorité : %% . . . := : = • De même, est-ce que « ifabc » signifie « ifabc » ou bien « if » suivi de « abc » ? • La règle veut que lex reconnaisse le mot le plus long ! Cours de compilation 3 - Intranet

15. L’analyse lexicale---------------------------------------------------------------- si var(ab56) rel(=) ent(5) alors var(abc) affect ent(113) add alors add ent(12) var(ab) finsi • Exemple : %% if printf(« si\n »); then printf(« alors\n »); fi printf(« finsi\n »); = printf(« rel(%s)\n » , yytext); := printf(« affect\n»); + printf(« add\n »); [a-z][a-z0-9]* printf(« var(%s)\n » , yytext); [0-9]* printf(« ent(%s)\n » , yytext); \ printf(«  »); \n printf(«  »); %% if ab56 = 5 then abc := 113 + then + 12ab fi Cours de compilation 3 - Intranet

16. Le voilà ! ! ! L’analyse lexicale---------------------------------------------------------------- si var(ab56) rel(=) ent(5) alors var(abc) affect ent(113) add alors add ent(12) var(ab) finsi • Exemple : %% if printf(« si\n »); then printf(« alors\n »); fi printf(« finsi\n »); = printf(« rel(%s)\n » , yytext); := printf(« affect\n»); + printf(« add\n »); [a-z][a-z0-9]* printf(« var(%s)\n » , yytext); [0-9]* printf(« ent(%s)\n » , yytext); \ printf(«  »); \n printf(«  »); %% if ab56 = 5 then abc := 113 + then + 12ab fi Cours de compilation 3 - Intranet

17. L’analyse lexicale---------------------------------------------------------------- si var(ab56) rel(=) ent(5) alors var(abc) affect ent(113) add alors add ovni(12ab) finsi • Exemple : %% if printf(« si\n »); then printf(« alors\n »); fi printf(« finsi\n »); = printf(« rel(%s)\n » , yytext); := printf(« affect\n»); + printf(« add\n »); [a-z][a-z0-9]* printf(« var(%s)\n » , yytext); [0-9]* printf(« ent(%s)\n » , yytext); [a-z0-9]* printf(« ovni(%s)\n » , yytext); \ printf(«  »); \n printf(«  »); %% if ab56 = 5 then abc := 113 + then + 12ab fi Cours de compilation 3 - Intranet

18. L ‘ A N A L Y S E S Y N T A X I Q U E Cours de compilation 3 - Intranet

19. L’analyse syntaxique---------------------------------------------------------------- • Nous allons reconnaître le langage à l’aide d’une grammaire non ambiguë. • Rappels sur les grammaires : Une grammaire est une suite de règles de l’une des formes suivantes : A ::= a • A ::= a | a | . . . | a • Les NON-TERMINAUX : C’est l’ensemble N des symboles qui apparaissent au membre gauche d’une règle au moins. • Nous utilisons des lettres latines majuscules. 1 2 n Cours de compilation 3 - Intranet

20. L’analyse syntaxique---------------------------------------------------------------- • Nous allons reconnaître le langage à l’aide d’une grammaire non ambiguë. • Rappels sur les grammaires : Une grammaire est une suite de règles de l’une des formes suivantes : A ::= a • A ::= a | a | . . . | a • L’AXIOME : C’est un non-terminal distingué à partir duquel nous allons démarrer. • Nous utiliserons la lettre S (comme « start »). 1 2 n Cours de compilation 3 - Intranet

21. L’analyse syntaxique---------------------------------------------------------------- • Nous allons reconnaître le langage à l’aide d’une grammaire non ambiguë. • Rappels sur les grammaires : Une grammaire est une suite de règles de l’une des formes suivantes : A ::= a • A ::= a | a | . . . | a • Les TERMINAUX : C’est l’ensemble V des symboles qui n’apparaissent qu’aux membres droits des règles. • Nous utilisons des lettres latines minuscules, du début de l’alphabet. 1 2 n Cours de compilation 3 - Intranet

22. L’analyse syntaxique---------------------------------------------------------------- • Nous allons reconnaître le langage à l’aide d’une grammaire non ambiguë. • Rappels sur les grammaires : Une grammaire est une suite de règles de l’une des formes suivantes : A ::= a • A ::= a | a | . . . | a • Une suite, éventuellement vide, de terminaux est notée comme lettre latine minuscule de la fin de l’alphabet. • Une suite, éventuellement vide, de non-terminaux et de terminaux est notée comme lettre grecque minuscule. 1 2 n Cours de compilation 3 - Intranet

23. L’analyse syntaxique---------------------------------------------------------------- • Une dérivation est une suite d’application de règles qui part de l’axiome S : S -> a-> . . .-> a-> a-> . . .-> a • encore notéeS ->> a • dans laquelle a et a sont respectivement de la forme • b Cd et b g d • et qu’il existe une règle de la forme C ::= . . . | g | . . . • La dérivation est « gauche » si, à chaque étape, C est le non-terminal le plus à gauche, c’est-à-dire si b e V*. 1 i i+1 k k i i+1 Cours de compilation 3 - Intranet

24. L’analyse syntaxique---------------------------------------------------------------- • A toute dérivation S ->> a correspond au moins une dérivation gauche. • Une dérivation S ->> a est terminéelorsquean’est constitué que de lettres terminales. • A une grammaire G , c’est-à-dire un ensemble de règles, nous associons le langage L ( G ) des mots terminaux dérivables en partant de l’axiome S : u e L ( G )  S -> . . . -> u  S -> . . . -> u , par une dérivation gauche. • Une grammaire G est non ambiguë, si pour tout mot terminal il existe au plus une dérivation gauche. k k k Cours de compilation 3 - Intranet

25. L’analyse syntaxique---------------------------------------------------------------- • A chaque dérivation correspond un arbre de dérivation. S ::= a B C B ::= b C ::= c S -> a B C -> a b C -> a b c C'est bien une dérivation gauche ! S a B C b c Cours de compilation 3 - Intranet

26. L’analyse syntaxique---------------------------------------------------------------- • Voici une grammaire ambiguë : S ::= a B C B ::= b C ::= c B ::= b c C ::= e S -> a B C -> a b c C -> a b c Cette dérivation est elle aussi une dériavtion gauche ! S a B C b c e Cours de compilation 3 - Intranet

27. L’analyse syntaxique---------------------------------------------------------------- • Il existe deux types de dérivations. • Descendante (LL) : . . . de la racine vers les feuilles . . . • Ascendante (LR) : . . . des feuilles vers la racine . . . Cours de compilation 3 - Intranet

28. L’analyse syntaxique---------------------------------------------------------------- • Une dérivation descendante (et gauche) : S Analyse de la racine vers les feuilles ! a B C ??? a b c Depuis la gauche ! Cours de compilation 3 - Intranet

29. L’analyse syntaxique---------------------------------------------------------------- • Une dérivation descendante (et gauche) : S a B C b ??? a b c Cours de compilation 3 - Intranet

30. L’analyse syntaxique---------------------------------------------------------------- • Une dérivation descendante (et gauche) : S a B C b c a b c Cours de compilation 3 - Intranet

31. L’analyse syntaxique---------------------------------------------------------------- • Une dérivation ascendante (et gauche) : • Tant que nous n’avons pas reconnu le membre droit d’une règle nous avançons, sinon nous remplaçons par le membre gauche. S ::= a B C B ::= b C ::= c a a b c Depuis la gauche ! Cours de compilation 3 - Intranet

32. L’analyse syntaxique---------------------------------------------------------------- • Une dérivation ascendante (et gauche) : • Tant que nous n’avons pas reconnu le membre droit d’une règle nous avançons, sinon nous remplaçons par le membre gauche. S ::= a B C B ::= b C ::= c a B a b c Cours de compilation 3 - Intranet

33. L’analyse syntaxique---------------------------------------------------------------- • Une dérivation ascendante (et gauche) : • Tant que nous n’avons pas reconnu le membre droit d’une règle nous avançons, sinon nous remplaçons par le membre gauche. S ::= a B C B ::= b C ::= c a B C a b c Cours de compilation 3 - Intranet

34. L’analyse syntaxique---------------------------------------------------------------- • Une dérivation ascendante (et gauche) : • Tant que nous n’avons pas reconnu le membre droit d’une règle nous avançons, sinon nous remplaçons par le membre gauche. S ::= a B C B ::= b C ::= c Analyse des feuilles vers la racine ! a B C a b c Cours de compilation 3 - Intranet

35. L’analyse syntaxique---------------------------------------------------------------- • Une dérivation ascendante (et gauche) : • Tant que nous n’avons pas reconnu le membre droit d’une règle nous avançons, sinon nous remplaçons par le membre gauche. S ::= a B C B ::= b C ::= c S Analyse des feuilles vers la racine ! a B C a b c Cours de compilation 3 - Intranet

36. L’analyse syntaxique---------------------------------------------------------------- • Une analyse ascendante est plus puissante qu’une analyse descendante, mais aussi plus lourde à mettre en oeuvre. • LL ou LR réussit S ->> u existe • Le problème de la « fin du fichier » : Si le fichier contient « u v » et que « u » appartient au langage, alors la partie « v » du fichier ne sera pas lue. • Nous matérialisons la fin de fichier par le nouveau caractère « # ». Le contenu du fichier devient «  u v # ». • Nous prenons comme nouvel axiome Z ::= S # . • Il faudra donc la dérivation Z ->> u v # . => / <= Cours de compilation 3 - Intranet