Un compilateur simple en Java

Lab-8 : Un compilateur simple en Java (Originally prepared by  Abdelilah Maach and Alan Williams; revised 2009 by G.v.B. )

Nous avons vu le language VSPL dans le laboratoire 7. Pendant ce laboratoire, nous allons apprendre comment écrire un compilateur pour ce langage en Java en suivant la méthodologie de la descente récursive.

Partie préliminaire: Étude d'un compilateur donné pour VSPL

Le développement d'un compilateur pour VSPL en Java est décrite ici.

1. Svp., étudiez les explications données et le code Java
   • pour l'analyeur lexical
   • pour l'analyseur syntaxique, et
   • pour l'évaluation (ex/cution) des expressions, code qui est inclu dans l'analyseur syntaxique.
2. Exécutez le compilateur avec quelques programmmes exemples. Note: Vous trouvez quelques exemple de programmes ici.
3. Quand vous comprendrez le programme Java, allez à la partie B.

Devoir 3 - 2016:

Donné: le 14 mars - Remise du rapport pendant la classe du 30 mars au professeur (nouveau) -- fichiers Java dans un fichier zip a envoyer dans un courriel au TA - Vous pouvez travailler en groups de deux.

Modifier le compilateur VSPL donné pour supporter ce qui suit:

(A) Votre compilateur devrait supporter le langage suivant:

1. Le langage VSPL, mais sans l'opérateur moins.
2. Les extensions suivantes devraient être supportées:
• Un énoncé supplémentaire: un énoncé IF sans partie ELSE avec une syntaxe comme en Java où les énoncés entre les parenthèses {} sont en forme d'une <statement list> comme défini en VSPL.
• Une expression booléenne qui est utilisée dans l'énoncé IF. Elle a la syntaxe suivante: un identificateur suivi par "=" ou "!=", suivi par un autre identificateur.

(B) Votre compilateur devrait pas seulement vérifier la syntaxe du langage, mais aussi faire certains traitements sémantiques, similaires à ce que fait le compilateur VSPL donné. Cela veut dire que le compilateur devrait évaluer les expressions des énoncés d'affectation (comme le compilateur VSPL). Mais l'expression d'un énoncé d'affectation qui ne sera pas exécuté, parce que l'énoncé se trouve dans le corps d'un énoncé IF dont l'expression booléenne est faux, ne devrait pas être évaluée. En plus, le compilateur devrait imprimer un message d'erreur si une variable est utilisée dans une expression avant qu'une valeur lui serait affectée (c'est-à-dire, que l'identificateur n'est pas encore entré dans la table des symbôles. Alors, il est suggéré d'utiliser les attributs sémantiques suivantes:

Les attributs sémantiques suivants devraient être utilisés dans le compilateur. Une explication des attributs sémantique synthétisés et hérités est donnée sous le titre "Exemple: les expressions - différentes grammaires et règles pour l'évaluation des attributs sémantiques" dans les notes de cours dans la section sur les attributs sémantiques.

• Une expression arithmétique devrait avoir un attribut synthétisé de type entier qui représente la valeur de l'expression (comme dans le compilateur VSPL).
• Pour savoir, à chaque moment lors de l'analyse du programme, si l'énoncé en cours devrait être exécuté ou non, l'énoné devrait avoir un attribut hérité de type booleén qui indique si l'énoncé en question devrait être exécuté. Cet attribut peut être réalisé par un paramètre de la procédure récursive représentant l'énoncé. La valeur de cet attribut devrait être déterminée quand la procédure est appelée, par exemple pendant l'analyse du corps d'un énoné IF, ou quand l'énoncé fait partie d'un <statement list> à l'intérieur du corps d'un énoncé IF..
• La détection de variables non initialisées devrait se faire seulement quand l'énoncé qui contient l'expression est à exécuter. C'est pourquoi il est suggéré que les valeurs des expressions devraient être évaluées seulement dans les énoncés à exécuter. Donc, les expressions devraient aussi avoir un attribut hérité qui indique si l'expression devrait être évaluée ou non.

Rapport

Votre rapport devrait couvrir les étapes suivantes du processus de développement. Notez que le travail principal pour les étapes 1 et 2 a déjà été fait dans le laboratoire 7.

1. Changer la grammaire d'après la nouvelle syntaxe définie ci-haut.
2. Vérifier que votre grammaire proposée est LL(1). Sinon, appliquer certaines transformations pour obtenir une grammaire équivalente. Repéter jusqu'à obtenir une grammaire LL(1).
3. Ecrivez (dessinez) les automates récursifs pour les règles syntaxique étendues, d'une manière similaire qu'expliqué pour VSPL.
4. Écrivez les procédures récursive en Java pour les non-terminaux de la grammaire.
5. Revisez l'analyseur lexical pour inclure les nouveaux unités lexicales qui sont requises pour l'extension du langage.
6. Intégrer des règles d'évaluation sémantiques appropriés pour calculer les valeurs des expressions pendant la phase de compilation (similairement que fait dans le compilateur donné pour VSPL).
7. "Debug" votre programme de compilateur en l'exécutant avec quelques programme exemples. Voici un exemple de programme.