Gérer des projets Ada avec Eclipse

Installer Eclipse :

La première chose à faire est, bien sûr, d'installer Eclipse.

Pour cela, on commencera par télécharger l'installeur sur le site d'Eclipse. Le fichier est nommé eclipse-inst-jre-win64.exe. Lancer l'installeur et choisir la version Eclipse IDE for Embedded C/C++ Developers

J'ai gardé le chemin d'installation par defaut : C:\eclipse\embedcpp-2023-06.

Au moment de l'écriture de ces lignes, l'installeur d'Eclipse a un bug [1] qui fait qu'un fichier interne à Eclipse n'est pas installé. Ce fichier étant nécessaire pour ce que nous voulons faire, il nous faut trouver un moyen pour le récupérer.

Mais tout d'abord, nous allons vérifier si le bug est présent sur la version d'Eclipse que nous venons d'installer. Pour cela, lancer Eclipse et afficher la boite de dialogue des préférences (Window/Preferences).

Si, comme dans l'image ci-dessus, le sous-menu Language Configuration est manquant, alors nous devons installer le plugin TextMate manuellement. Pour cela :

• Aller dans le menu Help / Install New Software...
• Cliquer sur Add...

• Dans le champ Name, saisir TextMate
• Dans le champ Location, saisir https://download.eclipse.org/tm4e/snapshots/
• Valider en cliquant sur le bouton Add.

• Cocher les cases Dependencies, Samples, Sources, TextMate [2]
• Cliquer sur le bouton Next...
• Cliquer sur le bouton Next...
• Sélectionner I accept the terms of the license agreement
• Cliquer sur le bouton Finish

La boite de dialogue des préférences doit maintenant contenir le sous-menu Language Configuration.

Pour finir, pour contourner un bug d'un plugin d'Eclipse, nous allons

créer le fichier .pkglist dans le dossier C:\Users\xxx\ où xxx est le nom d'utilisateur courant.

Si ce fichier existe déjà, ne pas y toucher. Sinon, créer le fichier (vide).

Récupérer les fichiers du Language Server :

Pour arriver à nos fins, Eclipse n'est pas suffisant, nous avons également besoin de fichiers venant du projet Ada Language Server.

Nous pouvons compiler ce projet nous même à l'aide du Crate Alire correspondant ou récupérer un exécutable directement dans les releases du projet github. Allons au plus simple, utilisons la deuxième méthode. Téléchargeons la version la plus récente pour Windows. Au moment de l'écriture de cet article, il s'agit de la version 23.0.21 : als-23.0.21-Windows_amd64.zip. L'archive contient un unique exécutable, ada_language_server.exe, que nous allons copier dans un dossier dédié. Sur ma machine, j'ai choisi Z:\ada\language_server\.

Nous aurons également besoin de fichiers annexes. Pour cela, nous allons télécharger une archive des sources du projet.

Dans l'archive, déroulons le path suivant : ada_language_server-master\integration\vscode\ada\ . Les fichiers suivants seront copiés dans le même dossier que le fichier ada_language_server.exe (on ne reproduit pas l'arborescence) :

• language-configuration.json
• gpr-language-configuration.json
• syntaxes\ada.tmLanguage.json
• syntaxes\gpr.tmLanguage.json
• syntaxes\ali.tmLanguage.json

Quelques modifications sont nécessaires.

Dans le fichier ali.tmLanguage.json, remplacer la ligne suivante...

"name": "ALI",

...par ces lignes :

 "name": "ali",
 "comment": "Ada ali grammar file",
 "scopeName": "source.ali",
 "fileTypes": [
     "ali"
 ],

Dans le fichier gpr.tmLanguage.json, après la ligne suivante ...

"name": "gpr",

...ajouter ces lignes :

 "comment": "Ada project grammar file",
 "scopeName": "source.gpr",
 "fileTypes": [
     "gpr"
 ],

Cette fois, nous avons tous les éléments nécessaires à la configuration d'Eclipse.

Configuration d'Eclipse :

Une partie de la configuration se fait au niveau workspace. L'autre partie se fait au niveau projet.

Commençons par la configuration du workspace. Pour cela, nous allons créer un dossier pour l'expérimentation. Dans mon cas : Z:\ada\eclipse-test\ . Démarrer Eclipse et ouvrir un workspace dans le dossier que nous venons de créer.

Une fois Eclipse lancé, nous pouvons fermer la fenêtre Welcome.

Content Types :

Nous allons maintenant associer des Content types à des extensions de fichiers. Pour cela, ouvrir la boite de dialogue des préférences (menu Window/Preferences) et aller dans le menu General/Content Types. Nous allons ajouter des enfants à l'entrée Text :

• Cliquer sur Text
• Cliquer sur Add Child...
• Saisir Ada et valider
• Dans la zone File associations, ajouter *.adb and *.ads
• Dans la zone Default encoding, saisir utf-8
• Recommencer avec Ada_ALI (*.ali)
• Recommencer avec Ada_GPR (*.gpr)
• Cliquer Apply

Note : Il est important que les entrées ajoutées soient des enfants de Text.

File Associations :

Pour compléter ce que nous venons de faire, nous allons indiquer quel type d'éditeur utiliser avec les extensions de fichier qui nous intéressent. Pour cela, ouvrir la boite de dialogue des préférences (menu Window/Preferences) et aller dans le menu General/Editors/File Associations.

• Cliquer sur le boutton Add...
• Saisir *.ads et valider
• Dans la zone Associated editors, cliquer sur Generic Text Editor
• Cliquer sur le bouton Default
• Recommencer avec *.adb
• Recommencer avec *.gpr
• Recommencer avec *.ali
• Cliquer sur Apply and Close

Language Server :

Nous allons commencer par créer une configuration de lancement du Language Server. Ouvrir la boite de dialogue de lancement des outils externes : Menu Run/External Tools/External Tools Configurations.

• Créer une nouvelle configuration de lancement en cliquant sur l'icone New launch configuration.

• Dans l'onglet Main :

  • Dans la zone de saisie Name entrer Language Server
  • Dans la zone de saisie Location entrer Z:\ada\language_server\ada_language_server.exe
  • Dans la zone de saisie Working Directory entrer ${project_loc}

• Dans l'onglet Build :

  • Décocher Build before launch

• Dans l'onglet Common :

  • Dans la zone Standard Input and Output

    • Cocher Allocate console (necessary for input)

• Dans l'onglet Environment :

  • Cliquer sur Add...

    • Dans le champ Name, saisir PATH
    • Dans le champ Value, saisir C:/Program Files/Alirebin;${env_var:PATH}

• Cliquer le bouton Apply
• Cliquer le bouton Close

Nous devons maintenant associer des Content-type au language server que nous venons de configurer. Ouvrir la boite de dialogue des préférences (menu Window/Preferences) et aller dans le menu Language Servers.

• Cliquer sur le bouton Add...
• Dans la zone Associate content-type..., sélectionner Text/Ada
• Dans la zone ... with Language Server Launch Configuration, sélectionner Program/Language Server
• Valider en cliquant le bouton OK
• Recommencer avec Text/Ada_ALI
• Recommencer avec Text/Ada_GPR
• Cliquer sur le bouton "Apply"

TextMate :

TextMate est un plugin gérant la tokenisation du code ce qui permet d'ajouter la coloration syntaxique, le ctrl+click, l'auto-completion...

Ouvrir la boite de dialogue des préférences (menu Window/Preferences) et aller dans le menu TextMate/Grammar.

• Cliquer sur le bouton Add...
• Cliquer sur le bouton Browse Filesystem...
• Sélectionner *.json en bas à droite de la boite de dialogue
• Aller dans le dossier où se trouvent les fichiers du language server et sélectioner ada.tmLanguage.json
• Cliquer sur le bouton Ouvrir
• Cliquer sur le bouton Finish
• Recommencer avec ali.tmLanguage.json
• Recommencer avec gpr.tmLanguage.json
• Cliquer Apply

Aller dans le menu TextMate/Language Configuration

• Cliquer sur le bouton New
• Cliquer sur le bouton Browser Filesystem...
• Sélectionner language-configuration.json
• Cliquer sur le bouton Ouvrir
• Dans la zone Content Type sélectionner Text/Ada
• Cliquer sur le bouton Finish
• Recommencer avec gpr-language-configuration.json (Text/Ada_GPR)
• Cliquer Apply

Error parser :

Chaque compilateur affiche les erreurs/warnings à sa manière. Nous allons maintenant faire en sorte que Eclipse comprenne le format de sortie du compilateur ada.

Dans la boite de dialogue des préférences, aller dans le menu C/C++/Build/Settings

• Dans l'onglet Error Parsers, cliquer sur le bouton Add
• Saisir GNAT et valider
• Dans la zone Error Parser Options, cliquer sur le bouton Add

• Une ligne est ajoutée à la liste

  • Dans la colonne Severity, choisir Error
  • Dans la colonne Pattern, saisir (.+):(\d+):(\d+): (error): (.*)
  • Dans la colonne File, saisir $1
  • Dans la colonne Line, saisir $2
  • Dans la colonne Description, saisir $5 (col $3)
  • Dans la colonne Consume, laisser vide (ne pas sélectionner No)

• Dans la zone Error Parser Options, cliquer à nouveau sur le bouton Add

• Une ligne est ajoutée à la liste

  • Dans la colonne Severity, choisir Warning
  • Dans la colonne Pattern, saisir (.+):(\d+):(\d+): (warning): (.*)
  • Dans la colonne File, saisir $1
  • Dans la colonne Line, saisir $2
  • Dans la colonne Description, saisir $5 (col $3)
  • Dans la colonne Consume, laisser vide (ne pas sélectionner No)

• Dans la zone Error Parser Options, cliquer à nouveau sur le bouton Add

• Une ligne est ajoutée à la liste

  • Dans la colonne Severity, choisir Info
  • Dans la colonne Pattern, saisir (.+):(\d+):(\d+): (\(style\)) (.*)
  • Dans la colonne File, saisir $1
  • Dans la colonne Line, saisir $2
  • Dans la colonne Description, saisir $5 (col $3)
  • Dans la colonne Consume, laisser vide (ne pas sélectionner No)

• Dans l'onglet Error Parsers, désellectionner tout sauf GNAT
• Cliquer Apply And Close

Création de projet :

La création d'un projet se fait en deux étapes :

• Création du projet Alire.
• Création du projet Eclipse.

Tout d'abord, nous allons créer des outils pour faciliter l'accès à un terminal Alire [3].

1 - Premier outil : un terminal Alire au niveau workspace qui nous permettra de créer des projets Alire.

• Ouvrir la boite de dialogue de lancement des outils externes : Menu Run/External Tools/External Tools Configurations
• Créer une nouvelle configuration que l'on appellera Alire - Manage Projects

• Dans l'onglet Main :

  • Dans la zone Location, saisir C:WindowsSystem32WindowsPowerShellv1.0powershell.exe
  • Dans la zone Working Directory, saisir ${workspace_loc}
  • Dans la zone Arguments, saisir -NoExit -Command clear-host

• Dans l'onglet Build

  • Décocher Build before launch

• Dans l'onglet Environment, cliquer sur Add...

  • Dans le champ Name, saisir PATH
  • Dans le champ Value, saisir ${env_var:PATH};C:/Program Files/Alire\bin
  • Valider

• Dans l'onglet Common :

  • Dans la zone Display in Favorite Menu, cocher External Tools
  • Cocher Allocate console (necessary for input)
  • Cliquer sur le bouton Apply.

2 - Deuxième outil : un terminal Alire au niveau projet qui nous permettra de gérer des projets.

• Dupliquer la configuration précédente et la nomer Alire - Manage Current Project
• Dans la zone Working Directory, saisir ${project_loc}
• Cliquer sur le bouton Apply

3 - Troisième outil : un raccourci pour créer un projet Alire.

• Dupliquer la configuration Alire - Manage Projects et la nomer Alire - Create Binary Project

• Dans l'onglet Main :

  • Dans la zone Location, saisir C:\Program Files\Alire\bin\alr.exe
  • Dans la zone Arguments, saisir init --bin ${string_prompt}

• Cliquer sur le bouton Apply
• Cliquer sur le bouton Close

On peut aussi ajouter une configuration pour créer une librairie Alire. Pour cela, dupliquer la configuration Alire - Create Binary Project et remplacer --bin par --lib dans la zone Arguments.

Création du premier projet (enfin) :

Nous allons commencer par créer un projet Alire :

• Cliquer sur la flèche, à droite de l'icone External Tools
• Cliquer sur Alire - Create Binary Project
• Saisir hello
• Valider

Un message s'affiche dans la console : Success: hello initialized successfully.

Ensuite, nous allons créer un projet Eclipse :

• Dans le menu File sélectionner New puis C/C++ Project
• Sélectionner C Managed Build et cliquer sur Next
• Dans Project name, saisir hello (le nom doit être le même que celui utilisé lors de la création du projet Alire)
• Dans la section Project type, sélectionner Empty Project
• Dans la section Toolchains, sélectionner Cross GCC
• Cliquer Next
• Cliquer Next
• Cliquer Finish

L'architecture du projet apparait dans le panneau Project Explorer.

Configuration du projet :

Pour pouvoir compiler et exécuter notre programme, nous devons configurer le projet.

Pour cela, sélectionner le projet en cliquant sur son icone et ouvrir le menu Project/Properties.

• Sélectionner C/C++ Build

• Dans l'onglet Builder Settings :

  • Décocher Use default build command
  • Dans le champ Build Command, saisir C:\Program Files\Alire\bin\alr.exe
  • Décocher Generate Makefiles automatically
  • Dans le champ Build directory, supprimer ce qui se trouve après le caractère }

• Dans l'onglet Behavior :

  • Cocher Use custom build arguments
  • Dans le champ Build arguments, ne rien mettre.
  • Dans le champ Build, saisir build
  • Dans le champ Clean, saisir clean

Nous allons maintenant configurer le Error Parser.

• Sélectionner C/C++ Build / Settings

• Dans l'onglet Error Parsers :

  • Cocher GNAT
  • Décocher les autres Parsers

Note : Tout ce que nous venons de faire l'a été pour la configuration par défaut, debug. On peut la reproduire pour la configuration release.

Dernière étape, la création d'une configuration de lancement.

• Sélectionner Run/Debug Settings
• Cliquer sur le bouton New...
• Sélectionner C/C++ Application et valider.

• Dans l'onglet Main :

  • Dans le champ C/C++ Application, saisir C:\Program Files\Alire\bin\alr.exe
  • Cocher Disable auto build

• Dans l'onglet Arguments :

  • Dans la zone Program Arguments, saisir run

• Cliquer sur le bouton OK
• Cliquer sur le bouton Apply & Close

Il nous reste à modifer le fichier hello.gpr pour que les noms de fichiers affichés lors des erreurs soit absolus. Pour cela, il faut ajouter l'option -gnatef aux paramètres de compilation. Comme ceci :

package Compiler is
   for Default_Switches ("Ada") use Hello_Config.Ada_Compiler_Switches & ("-gnatef");

Nous pouvons maintenant éditer / compiler / exécuter notre code. Un double click sur hello.adb ouvre un éditeur avec le code. On constate immédiatement la coloration syntaxique.

Un survol de hello (le nom de la procédure) montre la définition de la procédure.

Taper CTRL+B au clavier déclenche une compilation du projet. On peut voir le résultat dans la console.

Nous allons maintenant modifier le programme comme suit pour générer des erreurs / warnings lors de la compilation :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

with Ada.Text_IO; use Ada.Text_IO;

procedure Hello is
   good_init : Natural := 0;
   bad_init  : Natural := -1;
begin
   -- Missing space
   Put ("Hello world");
   bad_assignment := 1;
end Hello;

On notera au passage que la completion automatique fonctionne. Le CTRL+Click sur un "objet" aussi.

Le résultat de compilation donne ceci :

C'est intéressant, on y voit les erreurs, les warnings et les erreurs de style. Mais on ne peut pas cliquer dessus. Pour résoudre ce problème, rendez-vous dans l'onglet Problems. Dans cet onglet, il est possible de double-cliquer sur les éléments de la liste pour aller directement au fichier et à la ligne concernés.

De même, dans le code source, les lignes concernées sont annotées.

Il ne reste plus qu'à exécuter le programme compilé. Pour cela :

• Cliquer sur la flèche à droite de l'icone pour ouvrir le menu contextuel.
• Cliquer sur Run Configurations...
• Sélectionner Hello Debug et cliquer sur Run

Il est possible de passer des arguments au programme exécuté à l'aide de l'onglet Arguments.

Pour exécuter le programme les fois suivantes, cliquer directement sur l'icone

Copie de la configuration :

Nous avons maintenant une configuration fonctionnelle qui permet d'éditer du code Ada et de l'exécuter. Mais il est très fastidieux de mettre en place toute cette configuration pour chaque workspace Eclipse et chaque projet utilisé pour gérer du code Ada.

Un moyen de partiellement résoudre le problème est d'utiliser la fonctionnalité d'import / export de la configuration d'Eclipse. Rendez-vous dans la boite de dialogue des préférences (Window/Preferences) : En bas à gauche se trouvent 2 icônes. Une pour l'export et une pour l'import.

La configuration des projets ne peut pas être exportée/importée.

Conclusion :

• Complexité de mise en place
• A chaque mise à jour d'Eclipse ou d'un des outils associés, des problèmes peuvent apparaitre. Ou disparaitre.
• Dans l'éditeur, la mise en évidence des doubles cotes (utilisées pour les chaines de caractères) ne fonctionne pas correctement
• Le client language server intégré fonctionne mal (double instantiation, blocage...).

L'intérêt de cette configuration se trouve dans la gestion multi-projets intégrée (pas seulement Ada), une liste de plugins étendue, un comparateur de sources plutôt performant...

Chacun se fera une idée de l'utilité de cette solution en l'essayant. A condition d'en avoir le courage bien sûr ;)