TD cours de Compilateur

Chapitre 1
1. Quelle est la différence (s) entre un compilateur et un interpréteur?
2. Compilateur natif, compilateur croisé, assembleur, et compilateur source à source: Expliquer
chacun d’eux ajoutant un schéma.
3. Qu’est-ce que le « re-ciblage » ? Pourquoi est-il si important ? Comment est-il réalisé?
4. Pourquoi le Bootstrapping est-il important dans la conception du compilateur ?
5. Donnez la structure des compilateurs, en expliquant le rôle de chaque phase et sous-phase.

Chapitre 2
Quelle est la différence (s) entre le scanner et le screener?
Qu’est-ce qu’un lexème? Citez les types typiques de lexèmes.

Exercice 2.1. Donner une définition régulière des Identificateurs, qui doivent être formés selon
les règles suivantes :
1. Les identificateurs sont des chaînes (de longueur arbitraire) qui se composent de lettres, de
chiffres et de « _ » (soulignement).
2. Les identifiants commencent par une lettre.
3. Un soulignement ne doit pas être le début ou la fin d’un identifiant, et ne peut pas se produire
à côté d’un autre soulignement dans un identifiant.
Exemples: x, Bonjour_Monde, Identificateur_assez_long
Contre-exemples: 1x, H_e_l_l o__W_o_r_l_d, Name_

Exercice 2.2. Donner une définition régulière pour les chaines littérales, qui doivent être définie
comme suit:
1. Les chaines littérales sont délimitées dans des côtes "".
2. Elles se composent d’un nombre arbitraire de caractères imprimables.
3. Elles ne doivent pas contenir un caractère de nouvelle ligne.
4. Si une côte doit faire partie d’une chaîne littérale, elle doit apparaître deux fois dans la chaine.
Exemples: Les chaines littérales « », « Bonjour, Monde! », et """Bonjour, Monde!"""
contiennent respectivement 0, 12 et 14 caractères.
Conseils
L’expression régulière "\n" représentera le caractère newline.
L’expression régulière " [c1, …, cn ]" doit désigner l’ensemble des caractères qui contient tous
les caractères imprimables (y compris la nouvelle ligne), sauf les caractères c1 à cn ; c’est-à-
dire, l’ensemble PrintableChar \ { c1, …, cn }.

Exercice 2.3. Les côtés droits de la règle de transformation pour R+ dans la figure 1 peuvent
sembler trop compliqués à première vue, avec toutes les transitions vides autour (ce qui rend
l’automate non déterministe).

Figure 1. Règles de transformation des expressions régulières en AFN

1. Les paires (s, m), (n, t) de nœuds dans la règle pourraient-elles être identifiées, et les transitions
entre elles pourraient-elles être enlevées?
Si ce n’est pas le cas, construisez un exemple où la règle «simplifiée» détruit l’équivalence.
2. La paire (m, n) de nœuds dans la règle pourrait-elle être identifiée et la transition entre eux
pourrait-elle être supprimée?
Pourquoi? Ou pourquoi pas ?

Exercice 2.4. Construire des automates finis déterministes pour les définitions régulières des
identificateurs et des chaines littérales données dans l’exercice 2.1 et l’exercice 2.2 comme suit :
1. Générer un AFN selon la définition 2.6 du support de cours,
2. Construire l’automate déterministe équivalent, par l’algorithme de construction de l’ensemble
de quotient (Algo 2.1 du support de cours), et
3. construire l’automate déterministe minimal selon la définition 2.7 du support de cours.
Définition 2.6 (NFA of Regular Expression). La figure 2.4 du support de cours montre les règles
de transformation des graphiques NFA sur les graphiques de transition abstraits. Ils sont
appliqués en faisant correspondre un bord abstrait de l’un des côtés gauches dans un graphique
source G, en enlevant le bord, et en collant des nœuds et t sur le côté droit de cette règle avec les
nœuds correspondants de la correspondance, produisant un graphique cible H.

Exercice 2.5. Utilisez l’algorithme 2.2 du support de cours pour construire un AFD pour les
chaines littérales telles que définies dans l’exercice 2.2.

Exercice 2.6. Utilisez l’algorithme 2.2 du support de cours pour construire des AFD pour les
définitions régulières des chaines littérales données dans l’exercice 2.2.

Exercice 2.7. Les commentaires doivent être compris dans /* et */; ils peuvent inclure des
nouvelles lignes.
1. Définir les commentaires par définition régulière.
2. Construire un automate fini minimal pour les commentaires de cette définition.
Vous pouvez le faire "intuitivement", sans prendre les mesures formelles discutées à la section 2.4
du support de cours.
3. Vérifiez si votre définition devient plus simple si vous utilisez un opérateur lookahead R1/R2
mentionné dans l’exemple 2.14 du support de cours.

Exercice 2.8. Construire un AFD pour ˂number˃ tel que défini dans l’exemple 2.13.
Vous pouvez le faire de l’une des façons dont il est question :
1. Utilisez l’algorithme 2.2 sur la définition régulière de ˂number˃.
2. Appliquer l’algorithme 2.1 à l’AFN obtenu en collant l’état de départ des AFD pour les
littérales entiers dans la figure 2.5, les littérales fractionnés de la figure 2.8 et les littérals flottants
de la figure 2.9 du support de cours.

Exercice 2.9. Le langage LOOP, qui est utilisé dans le compilateur, a les lexèmes suivants:
• Séquences non vides de caractères de mise en page, espaces, tabulation, et nouvelle ligne,
 • Les commentaires, qui peuvent s’étendre sur plusieurs lignes, sont inclus (*et*)
• Les identificateurs,
• Les entiers littéraux,
• Les chaines littérales,
• Les délimiteurs , ,:, ;, (, et ),
• Les symboles opérateurs <=, >=, :=, *, /, +, -, =, #, <, >, et ., ainsi que
• Les mots-clés AND, ATTRIBUTE, BEGIN, CLASS, ELSE, ELSEIF, END, EXTENDS,
IF, IS, METHOD, MOD, NEW, NOT, OR, OVERRIDE, READ, RETURN, THEN, WITH,
WHILE, et WRITE.
Tâches
1. Définir le scanner pour la LOOP en lex. Ici, nous ne sommes pas intéressés par la traduction
des lexèmes en jetons, de sorte que les instructions return peuvent être omises.
Les définitions régulières développées dans le cours peuvent être utilisées pour les lexèmes.
2. Produire deux versions du scanner: l’une sans mots clés, et l’autre les incluant (Puis leurs
définitions devraient précéder celle des identificateurs.)
3. Comparez la taille des tables de scanner.
Les mots-clés devraient-ils plutôt être reconnus par le screener ?

Chapitre 3
Que signifie LL, LR, SLL (1), LL(1), CLR?
Quelle est la différence entre Top Down Parsers et Bottom up Parsers?

Exercice 3.1. En considérant les règles suivantes d’une grammaire hors contexte, dans laquelle
les terminaux sont soulignés, et R est le symbole de départ:
R →R|R
|RR
|R+ | R* | R?
|(R)
|a|b|c
Tâches
1. Quel est le langage définie ici?
2. Montrez que la grammaire est ambiguë.
3. Lever l’ambiguïté. Les dérivations et les arbres de dérivation respecteront que les priorités des
opérateurs allant du haut vers bas. Les opérateurs, * , + et ? ont la même priorité.

Exercice 3.2. La définition (non révisée) d’Algol-60 contient des règles pour les commandes
conditionnelles comme suit :
C ≜ r | if E then C | if E then C else C
E≜e
Ici, les terminaux r et e abstrait des règles respectivement pour les commandes restantes et pour
les expressions.
Tâches
1. Montrez que la grammaire est ambiguë.
2. Lever l’ambiguïté. Les dérivations et les arbres de dérivation doivent regrouper une autre
partie « balançant » entre deux parties précédantes puis avec la partie la plus proche
précédente :
If E then if E then C else C= if E then (if E then C else C)

Exercice 3.3. Que la syntaxe des commandes soit définie comme suit :
program ≜ statement □
statements ≜ statement
| statement ; statements
statement ≜ if expression then statements end if
| if expression then statements else statements end if
| while expression do statements end while
| id:= expression
| id
expression ≜ e

Tâches
1. Vérifiez si la grammaire satisfait l’état SLL(1).
2. Déterminer les ensembles First et Follower à cette fin.
3. Si la condition est violée, transformez la grammaire par factorisation gauche jusqu’à ce qu’elle
la satisfasse.

Exercice 3.4. Considérez la syntaxe SLL(1) pour les commandes de l’exercice précédent.
Tâches
1. Générer un analyseur de descente récursif.
2. Construire une syntaxe abstraite pour les commandes.
3. Ajouter les instructions de construction d’arbres de parsing.
4. Intégrer la manipulation d’erreur dans le parseur, en fonction de la suppression et de l’insertion
de symboles.
5. Montrez que la grammaire est ambiguë.

Exercice 3.5 : Déterminez les premiers ensembles et Suivez les grammaires suivantes et déduisez
les tables de parsing respectives.
Et→ E+E S→ aBDh
| E*E B→ cC
| E-E C→ bC|ε
| E/E D→ EF
| id Et→ g|ε
F→ f|ε

Exercice 3.6 : Proposer une mise en œuvre du parser de descente récursive pour la grammaire
suivante
E→ iE’
E’→ +E'/-iE'/ε