- Titre : Comment créer un compilateur C#

- Auteur : Jean-Michel Ormes

- Parution : 15 avril 2013

- Mise à jour : 15 avril 2013

- Licence : Les sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre cette page de présentation de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2013 Jean-Michel Ormes. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 € de dommages et intérêts. Cette page est déposée à la SACD.

Sommaire

- I. Introduction

- II. Interface graphique

- III. Implémentation du code

- III-A. Présentation de la classe CSharpCodeProvider

- III-B. Compilation du code

- III-C. Exécution du code

- IV. Conclusion

- V. Remerciements

I - Introduction

Le framework .NET expose des classes permettant d'accéder au compilateur C#. Au cours de cet article, nous verrons comment utiliser ces classes afin de créer notre propre compilateur C#.

II - Interface graphique

Nous allons commencer par réaliser l'interface graphique de notre application en WPF. Ouvrez Visual Studio et sélectionnez Fichier - Nouveau projet, puis choisissez Application WPF et appelez le « Compilateur » :

Nous allons ensuite ajouter une TextBox dans notre fenêtre principale. Celle-ci nous servira à écrire le code qui devra être compilé. Puis nous ajouterons un TabControl contenant deux TabItem. Ces deux TabItem serviront à afficher le résultat de la compilation et la liste des erreurs relatives au code. Nous ajouterons également un Button afin de générer le code et l'exécuter si la génération s'est déroulée avec succès. Votre fenêtre devrait normalement (ou à peu de choses près) ressembler à ceci :

A présent, nous pouvons passer au chapitre suivant ;)

III - Implémentation du code

III-A - Présentation de la classe CSharpCodeProvider

Comme je vous le disais en introduction, le framework .NET contient des classes permettant d'accéder aux instances du générateur de code et donc de pouvoir créer son propre compilateur. Dans le cadre de cet article, nous allons nous intéresser de plus près à la classe CSharpCodeProvider.

Cette classe est une classe dérivée de la classe de base CodeDomProvider et fournit l'accès au compilateur de code C#.

L'équivalent existe pour les langages VB et JScript.

III-B - Compilation du code

En premier lieu, nous allons ajouter au code behind, les instructions using suivantes :

1. using System.CodeDom.Compiler;
2. using Microsoft.CSharp;

Nous allons ensuite créer l'événement Click du Button Build en double-cliquant sur celui-ci depuis le fichier .xaml puis implémenter sa logique. Tout d'abord, nous allons effacer le contenu des TextBox des onglets :

1. // Cleaning txtItemOutput and txtItemErrors
2. txtItemOutput.Text = "";
3. txtItemErrors.Text = "";

On va ensuite créer une instance de CodeDomProvider pour le langage C# :

1. // Create instance of CodeDomProvider
2. CodeDomProvider provider = CSharpCodeProvider.CreateProvider("CSharp");

La prochaine étape sera de préciser que nous souhaitons générer un fichier exécutable et spécifier son nom. Pour y parvenir, nous devons utiliser la classe CompilerParameters représentant la liste des paramètres d'un compilateur :

1. // Name of .exe file
2. string Output = "MyProgram.exe";
3.
4. CompilerParameters parameters = new CompilerParameters();
5.
6. // Specify we want an .exe file instead of a .dll
7. parameters.GenerateExecutable = true;
8. // Name of output assembly
9. parameters.OutputAssembly = Output;

On passe maintenant à la partie « Compilation » en utilisant la méthode CompileAssemblyFromSource de l'objet provider. Cette méthode permet de compiler un assembly et renvoie un objet de type CompilerResults contenant le résultat de la compilation. Elle prend deux objets en paramètres. Tout d'abord un objet de type CompileParameters que nous avons créé précédemment puis un tableau de string contenant les sources à compiler.

1. CompilerResults results = provider.CompileAssemblyFromSource(parameters, txtCodeSource.Text);

La dernière étape consiste à vérifier si l'objet results contient des erreurs de compilation et le cas échéant, à l'indiquer dans l'onglet Output et afficher le détail dans l'onglet Errors :

1. if (results.Errors.Count > 0)
2. {
3.     txtItemOutput.Text = results.Errors.Count + " error(s). See Errors Menu.";
4.
5.     foreach (CompilerError CompErr in results.Errors)
6.     {
7.         txtItemErrors.Text = txtItemErrors.Text +
8.         "Line number " + CompErr.Line +
9.         ", Error Number: " + CompErr.ErrorNumber +
10.         ", '" + CompErr.ErrorText + ";" +
11.         Environment.NewLine + Environment.NewLine;
12.     }
13. }

III-C - Exécution du code

Afin de pouvoir exécuter votre code, une nouvelle instruction using doit être ajouté à votre fichier .xaml :

1. using System.Diagnostics;

Cette instruction nous permet d'accéder à la classe Process, Nous allons ajouter une condition else gérant le cas où la compilation s'est déroulée sans erreurs :

1. else
2. {
3.     //Successful Compile
4.     txtItemOutput.Text = "Compile successful!";
5.     Process.Start(Output);
6. }

C'est aussi simple que ça :)

Voici le programme complet :

1. private void Build_Click(object sender, RoutedEventArgs e)
2. {
3.     // Cleaning txtItemOutput and txtItemErrors
4.     txtItemOutput.Text = "";
5.     txtItemErrors.Text = "";
6.
7.     // Create instance of CodeDomProvider
8.     CodeDomProvider provider = CSharpCodeProvider.CreateProvider("CSharp");
9.
10.     // Name of .exe file
11.     string Output = "MyProgram.exe";
12.
13.     CompilerParameters parameters = new CompilerParameters();
14.
15.     // Specify we want an .exe file instead of a .dll
16.     parameters.GenerateExecutable = true;
17.
18.     // Name of output assembly
19.     parameters.OutputAssembly = Output;
20.
21.     CompilerResults results = provider.CompileAssemblyFromSource(parameters, txtCodeSource.Text);
22.
23.     if (results.Errors.Count > 0)
24.     {
25.         txtItemOutput.Text = results.Errors.Count + " error(s). See Errors Menu.";
26.
27.         foreach (CompilerError CompErr in results.Errors)
28.         {
29.             txtItemErrors.Text = txtItemErrors.Text +
30.             "Line number " + CompErr.Line +
31.             ", Error Number: " + CompErr.ErrorNumber +
32.             ", '" + CompErr.ErrorText + ";" +
33.
34.             Environment.NewLine + Environment.NewLine;
35.         }
36.     }
37.     else
38.     {
39.         //Successful Compile
40.         txtItemOutput.Text = "Compile successful!";
41.         Process.Start(Output);
42.     }
43. }

Allez ! On se fait le classique Hello World ? :)

Exécutez votre programme et copier coller le code suivant dans la TextBox source :

1. using System;
2.
3.
4.
5. namespace HelloWorld
6. {
7.     class HelloWorld
8.     {
9.         static void Main(string[] args)
10.         {
11.             Console.WriteLine("Hello World!");
12.             Console.ReadLine();
13.         }
14.     }
15. }

Normalement, vous devriez obtenir ceci :

La compilation et l'exécution se sont bien déroulées et en vérifiant dans le dossier bin/Debug de votre projet, un fichier .exe a bien été généré. Vous pouvez également modifier le code source de façon à générer une erreur et voir comment se comporte le programme.

IV - Conclusion

Dans cet article, nous avons vu qu'il n'était pas bien compliqué de réaliser un compilateur C#. Il ne vous reste plus qu'à l'améliorer à votre sauce en ajoutant d'autres fonctionnalités telles que la coloration syntaxique, la gestion des tabulations, etc..

V - Remerciements

Je tiens à remercier xxx et xxx pour la relecture attentive de cet article ainsi que les corrections apportées.

Comment créer un compilateur C#

Auteur

Jean-Michel Ormes