Compilateurs et interprètes - Documentations et Commandes LINUX

Compilateurs
et interprètes
Jerzy Karczmarczuk
Departement d’Informatique, Université de Caen
Caen, Janvier 2002

2
Copyright c Jerzy Karczmarczuk, 2001/2002

Table des matières
1 Introduction 7
1.1 Objectif du cours : Pourquoi apprendre la compilation? . . . . . . . . . . . . . . . . . . . . . 7
1.2 Exercices ............................................. 8
2 Classification générale des langages : survol de la tour Babel 11
2.1 Catégoriesclassiques....................................... 11
2.2 Programmationimpérative .................................... 11
2.2.1 Co-procédures et quasi-parallélisme . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.2.2 Exemples......................................... 14
2.3 Programmation fonctionnelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.3.1 Programmation paresseuse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.3.2 Continuations....................................... 16
2.4 Programmationlogique...................................... 17
2.4.1 Exemples des programme en Prolog . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.4.2 Programmation par contraintes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.5 Programmationparobjets..................................... 20
2.5.1 Quelquesexemples.................................... 20
2.6 Programmation pilotée par les événements . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.7 Dataflow et langages graphiques/visuels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.8 Autres schémas de classification et paradigmes de programmation . . . . . . . . . . . . . . . 23
2.8.1 Types........................................... 24
2.9 Notrelangagedetravail...................................... 25
2.10Exercices ............................................. 25
3 Machines virtuelles et exécution des programmes par l’ordinateur 33
3.1 Entre compilation et interprétation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.2 Expressions fonctionnelles et évaluation récursive . . . . . . . . . . . . . . . . . . . . . . . . 33
3.2.1 Interprète descendant en Scheme ............................ 33
3.3 Linéarisation du code et machines à pile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.3.1 Cahierdescharges .................................... 36
3.3.2 Codagedelamachine .................................. 38
3.3.3 Mécanismes décisionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
3.4 Gestion explicite de la pile des retours . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
3.4.1 Omissionimportante................................... 45
3.4.2 Conseils pour les irrécupérables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
3.5 Variante : Indirect threaded code ................................. 46
3.5.1 Co-procédures ...................................... 50
3.6 Le compilateur : première tentative . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.7 Exercices ............................................. 52
3

4 TABLE DES MATIÈRES
4 Les tâches et la structure d’un compilateur 59
4.1 Un peu d’anatomie et de physiologie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
4.1.1 Lelexique......................................... 60
4.1.2 Syntaxe et Sémantique : introduction . . . . . . . . . . . . . . . . . . . . . . . . . . 62
4.1.3 Lex et Yacc – premiers commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . 63
4.1.4 Qu’est-ce que l’optimisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
4.2 Intégration d’un compilateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
4.2.1 Intégrationprocédurale.................................. 65
4.2.2 Transducteurs de flux, ou «pipelining» . . . . . . . . . . . . . . . . . . . . . . . . . . 65
4.3 Organisation de la table des symboles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
4.3.1 Techniquesdehachage.................................. 67
4.4 Exercices ............................................. 68
5 Analyse syntaxique I – Techniques fonctionnelles 71
5.1 Grammaires et parsing ...................................... 71
5.1.1 Exemple ......................................... 71
5.2 Stratégiesduparsing ....................................... 73
5.2.1 Stratégiedescendante................................... 73
5.2.2 Techniquesascendantes ................................. 74
5.3 Philosophie du parsing fonctionnel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
5.3.1 Qu’est-ce qu’un parseur? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
5.3.2 Objectifsfinaux...................................... 75
5.4 Composition des parseurs fonctionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
5.4.1 Premierspas ....................................... 77
5.4.2 Séquences, filtres, alternatives, itérations . . . . . . . . . . . . . . . . . . . . . . . . 78
5.4.3 Sérialisation sans mémoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
5.4.4 Encore un exemple : listes Prolog . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
5.5 Exercices ............................................. 82
6 Analyse syntaxique II – développement et optimisation 85
6.1 Analyse des expressions algébriques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
6.1.1 Premier essai, opérations Booléennes . . . . . . . . . . . . . . . . . . . . . . . . . . 85
6.1.2 Arithmétique et problèmes avec la récursivité à gauche . . . . . . . . . . . . . . . . . 87
6.1.3 Quelquesoptimisations.................................. 89
6.2 Opérateurs de précédence et associativité quelconques . . . . . . . . . . . . . . . . . . . . . 89
6.3 Exercices ............................................. 92
7 Informations complémentaires sur les parseurs descendants 94
7.1 Diagrammessyntaxiques..................................... 94
7.2 Optimisation classique des parseurs descendants . . . . . . . . . . . . . . . . . . . . . . . . . 94
7.2.1 Élimination de la récursivité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
7.2.2 Tableaux PREMIER et SUIVANT . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
7.3 Exercices ............................................. 97
8 Stratégie ascendante d’analyse syntaxique 99
8.1 Idéegénérale ........................................... 99
8.2 Grammairesd’opérateurs..................................... 100
8.3 ParseursLR............................................ 101
8.3.1 Construction des tableaux de parsing . . . . . . . . . . . . . . . . . . . . . . . . . . 103
8.4 Exercices ............................................. 103

TABLE DES MATIÈRES 5
9 Sémantique 105
9.1 Grammaires attribuées et décorées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
9.1.1 Valeursdesnombres ................................... 105
9.1.2 Constance......................................... 106
9.1.3 Tempsdevie ....................................... 107
9.1.4 Formatage 2-dimensionnelle des formules mathématiques . . . . . . . . . . . . . . . 107
9.2 Exercices ............................................. 109
10 Les types 110
10.1 Qu’est-ce qu’un type et quel est son rôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
10.1.1 Inférence automatique des types, système H-M . . . . . . . . . . . . . . . . . . . . . 111
10.1.2 Structurescomposites .................................. 111
10.1.3 Quelques généralisations possibles . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
11 Deux mots sur l’analyse lexicale 113
11.1Qu’est-cequ’unlexème...................................... 113
11.1.1 Catégorieslexicales ................................... 113
11.2Expressionsrégulières ...................................... 114
11.2.1 Automates ........................................ 114
12 Gestion de mémoire dynamique 116
12.1Allocationdutas ......................................... 116
12.2Compteursderéférences ..................................... 117
12.3 Ramasse-miettes «marquage et balayage» . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
12.3.1 Optimisation de Schorr-Waite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
12.3.2 Problèmes avec le compactage de la mémoire . . . . . . . . . . . . . . . . . . . . . . 120
12.4Ramasse-miettescopieur ..................................... 120
12.4.1 Ramasse-miettes générationnel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
12.4.2 GC pour les données «binaires» . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
12.4.3 GC en temps réel : ramassage incrémental . . . . . . . . . . . . . . . . . . . . . . . . 122
12.4.4 AlgorithmedeBaker................................... 123
13 Macros et pre-traitement 124
13.1 Transformations source – source . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
13.2Macrosetlangages-amibes.................................... 126
13.3Exercices ............................................. 126
14 Modèles de code plus sophistiqués 128
14.1Évaluateureval-apply....................................... 128
14.2MachineSECD.......................................... 129
14.3Exercices ............................................. 131
15 Omissions 133
15.1Généralités ............................................ 133
15.2Grammairesetparsing ...................................... 133
15.3 Sémantique et génération du code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
15.4Modèlesd’exécution ....................................... 134
15.5 Run-time etl’interfaçage ..................................... 135
15.6 Varia ................................................ 135
A Introduction à la véritable programmation fonctionnelle et à Haskell 136
A.1 Pratique de la programmation en Haskell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
A.2 L’essentiel............................................. 138
A.2.1 Récursivité et processus itératifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
A.2.2 Évaluationparesseuse .................................. 141
A.2.3 Déstructuration automatique des arguments . . . . . . . . . . . . . . . . . . . . . . . 142
A.2.4 Quelques exemples de programmes en Haskell ..................... 142