Ada est un langage de programmation algorithmique qui possède une certaine similarité avec Pascal.
Le code écrit par un programmeur est constitué d’unités de bibliothèque (U de B) qui doivent être placés dans des fichiers sources. Ces fichiers ont un suffixe obligatoire qui est :
Pour la partie spécification --> nomFichier.ads Pour la partie corps (body) --> nomFichier.adb
Le point d’entrés d’un programme Ada est la procédure principale par laquelle doit commencer l’exécution. Cette procédure peut porter un nom quelconque (contrairement au C où elle doit s’appeler main) mais ne doit pas avoir d’arguments (paramètres).
Exemple :
with Ada.Text_io; -- la clause with permet d'utiliser toute autre U de C
procedure hello is begin
Ada.Text_io.put_line ("hello word"); end hello;
Ce programme sera stocké dans un fichier hello.adb pour être ensuite compilé.
7.2Compilation et édition de liens
Nous utiliserons le compilateur GNAT Ada 95 Compiler.
7.2.1Unité de Bibliothèque et programme objet
Une Unité de Bibliothèque peut être :
• un sous-programme (au sens Pascal),
• la spécification d’un paquetage (équivalant d’un module C : nomFichier.h) : contenant la déclaration d’un type et de la signature des sous programmes exportés.
• le corps d’un paquetage (équivalant en C du : nomFichier.c) : contenant le corps des sous programmes
exportés et des sous programmes internes.
Le résultat d'une compilation est un fichier appelé programme objet : nomFichier.o et un fichier texte contenant les informations de dépendance : nomFichier.ali (ali : Ada Library Information)
Compilation :
> gcc –c hello.adb
L'option de compilation "-c" indique au compilateur d'exécuter uniquement la compilation. Cette option est obligatoire pour compiler un fichier car gcc ne sait pas enchaîner directement les étapes en Ada.
La compilation en généré un fichier hello.o qui contient la traduction binaire du fichier hello.adb ainsi qu'un fichier hello.ali qui contient des informations supplémentaires vérifiant la validité du programme compilé. Pour pouvoir obtenir un fichier exécutable, l'étape suivante sera d'exécuter :
> gnatbind hello[.ali] puis
> gnatlink hello[.ali]
Mais il existe une manière plus simple et directe d'obtenir le même résultat : > gnatmake hello.adb
Le résultat est un programme exécutable appelé "hello" qui peut être exécuté par :
> hello (ou ./hello si le path ne contient pas le '.')7.2.2Compilation dans le cas où le programme est composé de plusieurs unités
Considérons un programme plus complexe constitué d'un fichier contenant la procédure principale (que nous appellerons programme principal) et de deux autres fichiers contenant la spécification et le corps d'un paquetage. fichier : greetings_p.ads package greetings_p is procedure hello; procedure goodbye; end greetings_p; fichier : greetings_p.adb with Ada.Text_io;
package body greetings_p is procedure hello is begin Ada.Text_io.put_line("hello word"); end hello; procedure goodbye is begin Ada.Text_io.put_line("goodbye word"); end greetings_p; end greetings_p; fichier : souhaits.adb with greetings_p; procedure souhaits is begin greetings_p.hello; greetings_p.goodbye; end souhaits;
Pour construire un fichier exécutable à partir de ce programme : > gcc –c souhaits.adb
> gcc –c greetings_p.adb > gnatbind souhaits > gnatlink souhaits Remarque :
1. Il n'y a pas d'ordre particulier requis pour la compilation des U de C
2. Il n'est pas nécessaire de compiler la spécification dans le cas où il existe un fichier séparé contenant le corps du paquetage. Seul le .adb a besoin d'être compilé.
3. Pour tester la sémantique d'un fichier de spécif il est possible de lancer : > gcc –c greetings_p.ads –gnatc
En pratique il sera plus direct de compiler l'ensemble des modules par : > gnatmake souhaits.adb
7.3Organisation des fichiers
La commande > gnatmake toto.adb, bien qu'ayant l'avantage d'effectuer une compilation complète peut s'avérer insuffisante quand on veut organiser ses fichiers dans différents répertoires.
En effet, après utilisation du gnatmake, tous les fichiers, spécification, bodies, binaires, exécutables se retrouveront dans le même répertoire. Ceci peut être source d'un certain fouillis!
Deux solutions sont possibles :
1. utiliser un fichier Makefile dans lequel on donnera les différents commandes à effectuer pour que l'organisation des répertoires soit reconnue et maintenue.
7.3.1Répertoires
Une manière classique d'organiser ses fichiers est de créer les répertoires suivants :
src : tous les .adb (bodies)
inc : tous les .ads (spécifications)
bin : tous les .o et les .ali (binaires générés à la compilation) exe : tous les exécutables
7.3.2 Utilisation d'un Makefile
Un fichier Makefile (ici simplifié) va regrouper les commandes que l'on souhaite enchaîner à la compilation pour maintenir l'organisation des fichiers. Il doit se trouver dans le répertoire src et porter le nom de Makefile (avec le 'M' majuscule !) :
MAKEFILE bdir=../bin edir=../exe rdir=../inc ddir=../doc # '#' est un commentaire
# TARGET = nom du fichier a compiler (essai est un exemple) TARGET= testerRomains
$(TARGET) :
rm -f $(bdir)/$(TARGET).ali
gnatmake -aI../inc -aO../bin -aL../bin $(TARGET) mv *.o $(bdir) mv *.ali $(bdir) mv $(TARGET) $(edir) clean: rm -f $(edir)/* rm -f $(bdir)/*
Le Makefile va lancer la commande de compilation : gnatmake avec en paramètre le fichier dont le nom a été donné comme cible (TARGET).
Le gnatmake suivra toutes les dépendances et ira chercher les fichiers dont il a besoin (spécifications et binaires dans les répertoires donnés par –aI –aO et –aL).
Une fois la compilation terminée, tous les fichiers générés se trouvent dans src. Il faut donc effectuer les mv pour les mettre là où il doivent être.
Pour changer de fichier à compiler, il suffit de changer le nom de fichier associé à TARGET dans le Makefile.
Pour exécuter le Makefile, taper en ligne de commande : > make <rc>
En cas de dépendances qui ne s'effectuent pas correctement (gnatmake n'arrive pas à recompiler les corps de packages dont l'application est cliente par exemple), il peut être nécessaire de recompiler tous les fichiers. Pour cela il faut d'abord détruire les binaires générés afin que la recompilation soit lancée.
Pour détruire les binaires taper en ligne de commande : > make clean <rc>
Puis recompiler avec > make <rc>
7.3.3Utilisation des variables d'environnement
gnatmake utilise des variables d'environnement pour savoir où aller chercher les fichiers binaires et les fichiers de spécification.
Pour qu'il prenne en compte les répertoires bin et inc, il faut placer ces deux lignes dans le fichier .cshrc et ensuite exécuter la commande :
> source .cshrc
pour que la modification soit prise en compte.
setenv ADA_INCLUDE_PATH ${ADA_INCLUDE_PATH}:/marine4/linfg/linfgxx/Ada95/inc setenv ADA_OBJECTS_PATH ${ADA_OBJECTS_PATH}:/marine4/linfg/gaildrat/Ada95/bin Une fois les variables d'environnement positionnées il suffit de faire :
> gnatmake essai.adb pour compiler essai et pile_p.
Mais là, tous les fichiers générés resteront dans le répertoire src. Il faudra donc ensuite faire les mv à la main !