Fiche synoptique
Stéphane Caron — Victor Poulain
Conception d'un langage de programmation
Introduction
De nos jours, la conception de programmes informatiques se fait à l'aide de langages de programmation, intermédiaires de dialogue entre l'homme et la machine. Il existe des milliers de langages différents, chacun conçu pour une utilisation précise. La majorité de ces langages reposent sur des symboles et des mots clefs en anglais : pourtant, il est plus intuitif pour un développeur de pouvoir s'exprimer directement dans sa langue maternelle.
Partant de ce principe, nous nous sommes lancés dans la réalisation d'un langage de programmation simple à utiliser, portable sur différentes architectures d'ordinateurs, et aisément traductible dans n'importe quel idiome, et notamment en français.
Spécification du langage
Dans un premier temps, il nous a fallu définir rigoureusement notre langage, sa syntaxe, ses fonctionnalités.
Dans les grandes lignes, nous souhaitions un langage impératif d'une utilisation simple et intuitive, nécessitant relativement peu de symboles et avec des mots clefs français, traductibles aisément dans n'importe quelle langue. Notre langage devait également proposer la plupart des fonctionnalités traditionnelles des langages de programmation : calculs, variables, conditions, boucles, fonctions, récursivité, etc.
Pour pouvoir mener à bien un tel travail, nous avons d'abord dû assimiler les notions mathématiques de langage, de grammaire ou encore d'automate. Ceci fait, nous avons défini ensemble la grammaire qui engendre notre langage, c'est à dire un ensemble de règles de construction sur lequel nous nous sommes basés pour mettre au point l'interpréteur futur.
Une fois le langage spécifié, nous nous sommes réparti les tâches pour le développement du programme qui permettrait son utilisation : l'interpréteur.
Mise au point de l'interpréteur
En effet, un problème de cette ampleur ne peut pas être traité d'un seul tenant, nous avons donc choisi de le découper en plusieurs sous-problèmes : l'auto-complétion, l'analyse lexicale, l'analyse syntaxique et l'exécution du programme.
Afin de pouvoir hiérarchiser les instructions du code par l'indentation, nous avons mis au point une première étape d'auto-complétion chargée de distinguer ces instructions et les liens entre elles. Il s'agit d'un pré-traitement avant l'analyse lexicale qui récupère également quelques informations utiles pour le debug (numéros de lignes, etc.)
La deuxième étape du processus est le lexeur - ou analyseur lexical - que nous avons construit à l'aide de l'outil ocamllex, partie intégrante de la distribution d'Objective Caml. Ce programme crée un jeu de fonctions qui convertissent le flot de caractères en entrée — le code source — en une liste d'entités du langage, les lexèmes, indispensables à l'analyse syntaxique.
Nous avons alors conçu un parseur - ou analyseur syntaxique - à l'aide de l'outil ocamlyacc, lui aussi distribué avec Objective Caml. À partir d'une spécification un peu particulière de notre grammaire et de consignes supplémentaires, ce programme nous a permis de générer les fonctions de construction de l'arbre de syntaxe, une forme hiérarchisée du programme d'entrée.
La structure particulière de cet arbre permet de l'évaluer de façon récursive : pour comprendre le sens d'un noeud de l'arbre, il suffit d'avoir considéré ces descendants. Nous avons alors implémenté un ensemble de méthodes récursives qui exécutent le programme d'entrée en évaluant l'arbre dans un ordre approprié.
Une fois tous les sous-problèmes résolus, la mise en commun de nos productions a donné le jour à un programme unique : l'interpréteur du langage Flip Flap.
Conclusion
Au cours de ce TIPE, nous avons appréhendé des notions mathématiques nouvelles et passionnantes, et nous avons été confrontés à divers problèmes techniques propres aux langages de programmation : analyse syntaxique, choix et implémentation des structures de données, etc. In fine, cette expérience nous a apporté de nombreuses connaissances, qui nous seront sans doute utiles dans nos travaux futurs.
Quelques chiffres sur notre projet :
- 977 lignes de code.
- 33.976 caractères.
- Au moins 64 heures de labeur.
- Près de 1.024 jurons proférés.
Bibliographie
- Compilateurs : principes, techniques et outils, A. Aho / R. Sethi / J. Ullman, Dunod (2000).
- Langages algébriques, J.-M. Autebert, Masson (1987).
- Techniques de Compilation, H. Gallaire, Cepad (1989).
- Nouveaux exercices d'algorithmique, M. Quercia, Vuibert (2000).
- http://quincy.inria.fr/data/courses/itlp : polycopiés de M. Mauny.
- http://pauillac.inria.fr/~quercia/ : livre de M. Quercia.
- http://www.enseignement.polytechnique.fr/profs/informatique/Francois.Pottier/compil : cours de F. Pottier.
- http://pauillac.inria.fr/~levy/x/m2 : Cours Langages et compilation de J.-J. Lévy.
-
http://plus.kaist.ac.kr/~shoh/ocaml/ocamllex-ocamlyacc/ocamlyacc-tutorial : Document de référence sur
ocamlyacc. - http://caml.inria.fr/pub/docs/manual-ocaml : Documentation officielle de Objective Caml.
- http://fr.wikipedia.org : Wikipédia, l'encyclopédie libre.