Analyse syntaxique (intro) Cours de compilation Analyse lexicale Analyse syntaxique (intro) 24 septembre 2007 Cours de compilation 3 - Intranet

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 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L E S C O N S T I T U A N T S D ‘ U N C O M P I L A T E U R 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet Les constituants d’un compilateur ---------------------------------------------------------------- C O M P I L A T E U R 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet Les constituants d’un compilateur ---------------------------------------------------------------- Analyse lexicale Analyse syntaxique Analyse sémantique Allocation mémoire Génération de code Optimisation de code 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet Les constituants d’un compilateur ---------------------------------------------------------------- Découpage du fichier source en mots, séparateurs, . . . Analyse lexicale Analyse syntaxique Analyse sémantique Allocation mémoire Génération de code Optimisation de code 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet Les constituants d’un compilateur ---------------------------------------------------------------- Analyse lexicale Analyse syntaxique Reconnaissance de la structure du programme : instructions, fonctions, . . . Analyse sémantique Allocation mémoire Génération de code Optimisation de code 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet Les constituants d’un compilateur ---------------------------------------------------------------- Analyse lexicale Analyse syntaxique Analyse sémantique Vérification du sens des phrases. Allocation mémoire Génération de code Optimisation de code 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet Les constituants d’un compilateur ---------------------------------------------------------------- Analyse lexicale Analyse syntaxique Analyse sémantique Décision des adresses mémoire pour certaines données. Allocation mémoire Génération de code Optimisation de code 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet Les constituants d’un compilateur ---------------------------------------------------------------- Analyse lexicale Analyse syntaxique Analyse sémantique Allocation mémoire Génération de code Création d’un programme de sortie correct, mais non optimisé. Optimisation de code 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet Les constituants d’un compilateur ---------------------------------------------------------------- Analyse lexicale Analyse syntaxique Analyse sémantique Allocation mémoire Génération de code Optimisation du code de sortie, si c’est du code assembleur. Optimisation de code 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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. 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet Les constituants d’un compilateur ---------------------------------------------------------------- Analyse lexicale Analyse syntaxique Analyse sémantique Les entêtes de chapitre seront . . . Allocation mémoire Génération de code Optimisation de code 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet Principe de l’analyse lexicale ---------------------------------------------------------------- Il s’agit de traduire une suite de caractères en une suite de « lexèmes » (mots, token). 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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. 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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. 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet Principe de l’analyse syntaxique ---------------------------------------------------------------- Il s’agit de reconnaître la structure du programme. 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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. 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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. 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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. if A = 1 then . . . fi 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 if A = 1 then . . . fi 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 if A = 1 then . . . fi 24 septembre 2007 L'analyse lexicale Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 Test 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 Test Bloc 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 Arbre de syntaxe Test Bloc 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 Arbre de syntaxe abstraite Test Bloc 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet Principe de l’analyse sémantique ---------------------------------------------------------------- Nous devons maintenant vérifier le sens du programme. 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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. 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 : 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L ‘ A N A L Y S E L E X I C A L E 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse lexicale ---------------------------------------------------------------- Nous découpons le programme en lexèmes. Nous déterminons leurs classes d’appartenance : 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse lexicale ---------------------------------------------------------------- Nous découpons le programme en lexèmes. Nous déterminons leurs classes d’appartenance : Mots clefs : if while . . . 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse lexicale ---------------------------------------------------------------- Nous découpons le programme en lexèmes. Nous déterminons leurs classes d’appartenance : Mots clefs : if while . . . Opérateurs : + == = . . . 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 . . . 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 : ; , «  » . . . 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 » 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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. 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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. 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse lexicale ---------------------------------------------------------------- Petit rappel sur les expressions régulières : 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse lexicale ---------------------------------------------------------------- Petit rappel sur les expressions régulières : Tout caractère isolé est régulier. 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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. 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 ]. 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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. 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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. 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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. 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 . . . 24 septembre 2007 Cours de compilation 3 - Intranet

reconnu est rendu tel quel ! 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 ! 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse lexicale ---------------------------------------------------------------- Attention aux cas ambigus : : := = 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse lexicale ---------------------------------------------------------------- Attention aux cas ambigus : : := = L’ordre des lexèmes donne la priorité : %% . . . := : = 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 » ? 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 ! 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse lexicale ---------------------------------------------------------------- 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(«  »); 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse lexicale ---------------------------------------------------------------- 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(«  »); Des mots et opérateurs fixés ! 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse lexicale ---------------------------------------------------------------- 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(«  »); Nous avons différents symboles de relation ! 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse lexicale ---------------------------------------------------------------- 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(«  »); Les variables ! 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse lexicale ---------------------------------------------------------------- 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(«  »); Les entiers ! 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse lexicale ---------------------------------------------------------------- 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(«  »); Nous supprimons les espaces et retours à la ligne superflux ! 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse lexicale ---------------------------------------------------------------- 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 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse lexicale ---------------------------------------------------------------- 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 si var(ab56) rel(=) ent(5) alors var(abc) affect ent(113) add ent(12) var(ab) finsi 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet Trouvez le problème ! ! ! L’analyse lexicale ---------------------------------------------------------------- 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 si var(ab56) rel(=) ent(5) alors var(abc) affect ent(113) add ent(12) var(ab) finsi 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet Le voilà ! ! ! L’analyse lexicale ---------------------------------------------------------------- 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 si var(ab56) rel(=) ent(5) alors var(abc) affect ent(113) add ent(12) var(ab) finsi 24 septembre 2007 Cours de compilation 3 - Intranet

les mélanges de lettres L’analyse lexicale ---------------------------------------------------------------- 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(«  »); Ici, nous récupérons les mélanges de lettres et chiffres illégaux ! 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse lexicale ---------------------------------------------------------------- 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 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse lexicale ---------------------------------------------------------------- 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 si var(ab56) rel(=) ent(5) alors var(abc) affect ent(113) add ovni(12ab) finsi 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse lexicale ---------------------------------------------------------------- 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 si var(ab56) rel(=) ent(5) alors var(abc) affect ent(113) add ovni(12ab) finsi Elle est triviale grâce à (f)lex ! ! ! 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L ‘ A N A L Y S E S Y N T A X I Q U E 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse syntaxique ---------------------------------------------------------------- Nous allons reconnaître le langage à l’aide d’une grammaire non ambiguë. 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse syntaxique ---------------------------------------------------------------- Nous allons reconnaître le langage à l’aide d’une grammaire non ambiguë. Rappels sur les grammaires : 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 1 2 n 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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. 1 2 n 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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. 1 2 n 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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. 1 2 n 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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. 1 2 n 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 a , b e V u , v e V* ( e est le mot vide ) a , b e ( N v V )* 1 2 n 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse syntaxique ---------------------------------------------------------------- Une dérivation est une suite d’application de règles qui part de l’axiome S : 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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ée S ->> a 1 i i+1 k k 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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ée S ->> a dans laquelle a et a sont respectivement de la forme b C d et b g d et qu’il existe une règle de la forme C ::= . . . | g | . . . 1 i i+1 k k i i+1 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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ée S ->> a dans laquelle a et a sont respectivement de la forme b C d 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 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse syntaxique ---------------------------------------------------------------- A toute dérivation S ->> a correspond au moins une dérivation gauche. k 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse syntaxique ---------------------------------------------------------------- A toute dérivation S ->> a correspond au moins une dérivation gauche. Une dérivation S ->> a est terminée lorsque a n’est constitué que de lettres terminales. k k k 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse syntaxique ---------------------------------------------------------------- A toute dérivation S ->> a correspond au moins une dérivation gauche. Une dérivation S ->> a est terminée lorsque a n’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. k k k 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse syntaxique ---------------------------------------------------------------- A toute dérivation S ->> a correspond au moins une dérivation gauche. Une dérivation S ->> a est terminée lorsque a n’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 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse syntaxique ---------------------------------------------------------------- A chaque dérivation correspond un arbre de dérivation. 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse syntaxique ---------------------------------------------------------------- A chaque dérivation correspond un arbre de dérivation. S ::= a B C B ::= b C ::= c 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 S a B C 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 S a B C b 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 S a B C b c 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 S C'est bien une dérivation gauche ! a B C b c 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse syntaxique ---------------------------------------------------------------- Voici une grammaire ambiguë : S ::= a B C B ::= b C ::= c B ::= b c C ::= e 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 S a B C 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 S a B C b c 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 S a B C b c e 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse syntaxique ---------------------------------------------------------------- Il existe deux types de dérivations. 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse syntaxique ---------------------------------------------------------------- Il existe deux types de dérivations. Descendante (LL) : . . . de la racine vers les feuilles . . . 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 . . . 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse syntaxique ---------------------------------------------------------------- Une dérivation descendante (et gauche) : 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse syntaxique ---------------------------------------------------------------- Une dérivation descendante (et gauche) : S ??? a b c 24 septembre 2007 Cours de compilation 3 - Intranet

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

Cours de compilation 3 - Intranet 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 ! 24 septembre 2007 Cours de compilation 3 - Intranet

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

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

Cours de compilation 3 - Intranet L’analyse syntaxique ---------------------------------------------------------------- Une dérivation ascendante (et gauche) : 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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. 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 ! 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet L’analyse syntaxique ---------------------------------------------------------------- Une analyse ascendante est plus puissante qu’une analyse descendante, mais aussi plus lourde à mettre en oeuvre. 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 => <= / 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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. => <= / 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 # ». => <= / 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 # . => <= / 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet 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 # . => <= / 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet Résumé ---------------------------------------------------------------- Analyse lexicale Analyse syntaxique (début) 24 septembre 2007 Cours de compilation 3 - Intranet

Cours de compilation 3 - Intranet C ’ e S t L a F i N ! ! ! b O n N e J o U r N é E ! ! ! 24 septembre 2007 Cours de compilation 3 - Intranet