Le support Ada a été supprimé des ports FreeBSD 13.1 car il était obsolète. En effet, le port gcc6-aux a été déclaré obsolète et a expiré le 28 Février 2022. Il n'y a aucune indication sur une solution de remplacement et l'utilisation d'Ada pour FreeBSD est cela reste un défi mais ce n'est pas impossible. Cet article propose un certain nombre d'étapes et de commandes qui m'ont aidé à configurer un nouveau compilateur Ada basé sur GCC 12 sur une nouvelle installation de FreeBSD 13.1.

Attention : cette description contient quelques hacks et je ne prétends pas fournir des étapes complètes détaillées et complètement reproductibles pour obtenir un nouveau compilateur Ada.

Avant de continuer, assurez-vous que gmake est installé car le make BSD utilise une ancienne syntaxe Makefile et n'est pas capable de gérer les Makefiles spécifiques à GNU.

pkg install gmake

Obtenez gcc6-aux à partir d'une ancienne installation FreeBSD

La première étape consiste à récupérer le port gcc6-aux tel quel à partir d'une ancienne installation FreeBSD. Fondamentalement, un tar-gz de l'arborescence du répertoire /usr/local/gcc6-aux est suffisant. En fait, ce que j'ai fait est d'exécuter un tar cf /tmp/gcc.tar /usr/local/gcc6-aux sur un ancien FreeBSD puis extraire ce tar tel quel sur le système FreeBSD 13.1 (bien sûr, il doit s'agir de la même architecture).

Construire gcc 12

Obtenez les sources de GCC 12 sur https://gcc.gnu.org et faire l'extraction :

tar xzf gcc-12.1.0.tar.xz

La construction de GCC doit être faite dans un autre répertoire et nous devons également configurer le PATH pour donner accès à l'ancien compilateur Ada. Vous devez configurer et exécuter le script de configuration gcc comme suit :

export PATH=/usr/local/gcc6-aux/bin:$PATH
mkdir build
cd build
../gcc-12.1.0/configure --disable-nls --enable-gnu-indirect-function \
  --enable-host-shared --with-as=/usr/local/bin/as --with-gmp=/usr/local \
  --with-ld=/usr/local/bin/ld --with-system-zlib --without-zstd --enable-libada \
  --localstatedir=/var --prefix=/build/gcc-12.1 --build=x86_64-portbld-freebsd13.0 \
  --enable-languages=c,ada,c++

Les commandes --with-as et --with-ld sont importantes pour utiliser les commandes as et ld correctes. Un sous-ensemble de la commande configure ci-dessus provient de la commande configure que les ports FreeBSD utilisent pour construire GCC 12.

Après la configuration, exécutez la commande gmake :

gmake

ou pour lancer plusieurs compilations en parallèle utilisez :

gmake -j4

Lors de la construction, le compilateur est construit une première fois avec gcc6-aux et une autre fois avec lui-même. La construction des bibliothèques Ada a échoué pour moi avec :

/home/ciceron/src/build/./gcc/xgcc -B/home/ciceron/src/build/./gcc/ \
-B/build/gcc-12.1/x86_64-portbld-freebsd13.0/bin/ -B/build/gcc-12.1/x86_64-portbld-freebsd13.0/lib/ \
-isystem /build/gcc-12.1/x86_64-portbld-freebsd13.0/include \
-isystem /build/gcc-12.1/x86_64-portbld-freebsd13.0/sys-include   -fchecking=1 \
-c -g -O2 -m32 -fpic  -W -Wall -gnatpg -nostdinc -m32  s-exnllf.adb -o s-exnllf.o
s-exnllf.ads:38:04: warning: in instantiation at s-dorepr.adb:82 [enabled by default]
s-exnllf.ads:38:04: warning: in instantiation at s-exponr.adb:54 [enabled by default]
s-exnllf.ads:38:04: warning: "Temp" overlays smaller object [enabled by default]
s-exnllf.ads:38:04: warning: program execution may be erroneous [enabled by default]
s-exnllf.ads:38:04: warning: size of "Temp" is 96 [enabled by default]
s-exnllf.ads:38:04: warning: size of "Rep64" is 64 [enabled by default]
gmake[9]: *** [../gcc-interface/Makefile:301: s-exnllf.o] Error 1

Cette erreur est causée par une incohérence entre la taille de la mantisse à virgule flottante renvoyée par le prédicat Ada Machine_Mantissa et la taille du nombre à virgule flottante. Après avoir hacké le gcc/ada/libgnat/s-dorepr.adb j'ai réussi à construire les bibliothèques Ada.

Après une construction réussie, l'installation dans /build/gcc-12.1 se fait avec :

gmake install

Construire gprbuild

Un autre défi consiste à construire gprbuild. Tout d'abord, obtenez les sources suivantes :

git clone https://github.com/AdaCore/xmlada.git
git clone https://github.com/AdaCore/gprconfig_kb
git clone https://github.com/AdaCore/gprbuild.git

Exécutez ensuite le script boostrap à partir de gprbuild et assurez-vous de configurer votre PATH pour utiliser le nouveau compilateur GCC Ada :

export PATH=/build/gcc-12.1/bin:/sbin:/bin:/usr/sbin:/usr/bin:/usr/local/sbin:/usr/local/bin
cd gprbuild
./bootstrap.sh --with-xmlada=../xmlada --with-kb=../gprconfig_kb --prefix=./bootstrap

Ensuite, compilez à nouveau et installez au même emplacement que GCC :

export PATH=/build/gcc-12.1/bin:/sbin:/bin:/usr/sbin:/usr/bin:/usr/local/sbin:/usr/local/bin
cd gprbuild
./bootstrap.sh --with-xmlada=../xmlada --with-kb=../gprconfig_kb --prefix=./bootstrap

Ne vous arrêtez pas à construire uniquement gprbuild car vous aurez probablement besoin de la bibliothèque libgpr (si vous voulez construire Ada Web Server qui dépend maintenant de GNAT libcoll qui a besoin de libgpr).

gmake libgpr.build
gmake libgpr.install

Installation de vscode

Il est possible d'utiliser vscode et le plugin Ada pour le développement sous FreeBSD. Le plugin vscode Ada contient le binaire ada_language_server qui est exécuté en tant que serveur de langage pour vscode. Aucun binaire n'est fourni pour FreeBSD mais puisque le binaire est fourni pour Linux, nous pouvons l'utiliser en utilisant le support Linux dans FreeBSD. Tout d'abord, installez vscode avec :

pkg install vscode

ensuite, lancez-le et installez l'extension Language Support for Ada. Lorsque l'extension est activée, vous verrez un message indiquant que le serveur de langue ne peut pas être démarré. Il y a deux choses à faire :

• créer un répertoire freebsd avec le binaire ada_language_server,
• activer et configurer le support Linux dans FreeBSD

Pour la première partie, copiez

cd ~/.vscode-oss/extensions/adacore.ada-23.0.8
cp -rp linux freebsd

Nous devons maintenant configurer le support Linux dans FreeBSD, et suivre le FreeBSD Chapter 10. Linux Binary Compatibility.

Ajoutez dans /etc/rc.conf :

linux_enable="YES"

et lancez le service Linux avec :

sudo service linux start

Installez debootsrap :

sudo pkg install debootstrap
sudo debootstrap focal /compat/ubuntu.

Ajoutez la ligne dans /etc/sysctl.conf :

compat.linux.emul_path="/compat/ubuntu"

et configurer avec :

sudo sysctl -f /etc/sysctl.conf

Marquez le binaire comme Linux :

brandelf -t Linux ~/.vscode-oss/extensions/adacore.ada-23.0.8/freebsd/ada_language_server

Remplacez le lien symbolique /compat/ubuntu/lib64/ld-linux-x86-64.so.2 par un vrai fichier sinon le lien Linux n'est pas trouvé par le noyau.

Maintenant, redémarrez vscode et le serveur de langage Ada devrait être démarré.

La description sur la façon de construire ada_language_server pour FreeBSD est laissée comme exercice au lecteur :-)

Et maintenant Alire

Alire est l'outil de gestion de librairies Ada. Il peut être utilisé facilement sous FreeBSD ce qui donne accès à un bon nombre de librairies et programmes Ada. Pour obtenir Alire, vous devez partir des sources git, les compiler et faire l'installation manuellement:

git clone --recurse-submodules https://github.com/alire-project/alire.git
cd alire
gprbuild -j0 -P alr_env
cp bin/alr /build/gcc-12.1/bin

Alire utilise des indexs pour référencer les librariries Ada. Il est possible d'avoir plusieurs indexs mais l'index principal le Community index peut être initialisé avec la commande:

alr init --reset-community

Cette commande est en fait executée automatiquement la première fois si l'index principal n'est pas trouvé. Vous pouvez faire des recherches de librairie en utilisant la commande search. Par exemple

alr search --list
alr search xml

Alire sait gérer plusieurs compilateurs et la sélection se fait avec la commande alr toolchain. Si un compilateur n'est pas installé, Alire est capable de l'installer et dans ce cas vous trouverez les binaires dans le répertoire ~/.config/alire/cache/dependencies. Grace au support Linux de FreeBSD, les compilateurs croisés ARM, AVR et RISC-V sont utilisables. Par exemple, on peut récupérer les exemples Ada pour carte Microbit, récupérer le compilateur Ada ARM et compiler ces exemples avec:

alr get microbit_examples
cd microbit_examples_0.1.0_a926cc69
alr build

Vers une installation plus simple pour FreeBSD

Maintenant que nous savons qu'Alire fonctionne et qu'il est capable d'installer le compilateur Ada, il est beaucoup plus simple de n'installer qu'alire et ne plus compiler GCC comme décrit en début d'article. Cette solution semble bien fonctionner, vous n'avez qu'à prendre le binaire alr de GNU/Linux et l'utiliser sous FreeBSD après avoir activé le support Linux dans FreeBSD.

Ada France sera de nouveau présent au village associatif du salon Open Source Experience les 8 et 9 Novembre prochain au Palais des Congrès à Paris. Vous pouvez être volontaire pour tenir le stand quelques heures, ou simplement venir visiter le salon et nous dire bonjour. Nous communiquerons le numéro du stand dès qu'il nous aura été attribué...

Cet événement est gratuit et vous pouvez obtenir votre badge d'accès sur le site Open Source Experience.

Venez discutez avec nous des dernières évolutions du langage Ada 2022, voir quelques démonstrations et en apprendre un peu plus sur ce langage!

A bientot au salon!

King est le nom d'un nouveau langage de programmation qui fait rare n'est pas dérivé d'un langage basé sur une syntaxe délimitée par des accolades ouvrantes et fermantes ;-) mais proche d'Ada. Il apparaît pour la première fois en octobre 2021 sous la forme d'un manifeste publié sur Github.

En savoir plus -> voir plus.

Pourquoi j'ai tout de suite adoré King :

• les nombres entiers et réels nativement disponibles pouvant être d'étendue non limitée
  

   type Factorial is range <> with Default_Value => 0;

   type Rational is digits <> with Default_Value => 0;

• les caractères et les chaines de caractères nativement en Unicode et de taille non limitées pour les chaines
  

   type String is sequence of Unicode;

• les containers vecteur, map, set nativement accessibles très simplement par mots clés

   type Stack is sequence of Message;

   type Store is map Part_Key => Stock_Info;

   type File_Mask is set of File_Mode;

• une syntaxe particulière innovante avec l'identifiant en premier ce qui force la réflexion à en trouver en premier lieu avant de partir sur une déclaration   
  

use King.IO.Text;
Hello_World : procedure body is
   
Message = "Hello, World!"; -- This is a named string
Hello_World : begin

   King.IO.Text.Put_Line (Line => Message); -- Implicitly converted to String
Hello_World : exception
when others =>
   raise;
Hello_World : end procedure;

• la gestion de la mémoire n'est plus à la charge du programmeur
  
• une programmation modulaire et paramétrable avec des macro-modules
  
• une programmation par contrat
  
• une programmation concurrente
  
• une interface avec le système avec KILLAR ou Ada (!)
  
• et bien d'autres particularités bienvenues mais qui parfois apparaissent contraignantes au premier abord.
  

En conclusion, King nous emmène vers une nouvelle façon de programmer qui pourrait bien inspirer Ada.

Pour aller plus loin, la syntaxe du langage est en cours de formalisation sur Wikibooks.