Licence CC BY-NC-SA

Notre premier programme en Ada

Publié :

Bon, nous avons installé notre IDE, Adagide, notre compilateur, GNAT. Je sens que vous commencez à perdre patience. Nous allons immédiatement pouvoir nous atteler à notre premier programme en Ada. Il s'agira de créer un programme qui nous salue. Bon, ce n'est sûrement pas folichon comme objectif, mais c'est un début. Voyons ici la démarche que nous allons suivre.

  1. Tout d'abord, nous allons faire un petit tour d'horizon des logiciels Adagide et GPS. Je vous rassure, ce sera rapide.
  2. Puis nous écrirons notre premier programme et nous le testerons.
  3. Enfin, nous essaierons de décrypter notre premier programme
  4. Avant de commencer le prochain chapitre je vous proposerai quelques petits suppléments et exercices pour vous entraîner.

Toujours pas découragé ? Alors au travail !

Découvrir son IDE en quelques secondes

Soyons rapide avec Adagide

Pour pouvoir programmer, nous avons déjà expliqué que nous aurons besoin de l'IDE Adagide. Donc, lancez Adagide ! Vous voilà donc face à une fenêtre (voir la figure suivante) tout ce qu'il y a de plus… austère. :( Mais cela n'a que peu d'importance pour nous.

Votre IDE : Adagide

Tout d'abord, nous allons créer un nouveau document. Pour cela, cliquez sur File > New ou sur l'icône «Nouveau» indiqué sur la figure précédente. Vous pourrez également à l'avenir ouvrir un document existant en cliquant sur File > Open ou sur l'icône «Ouvrir».

Pour l'heure, nous allons enregistrer notre document. Cliquez sur File > Save as ou sur l'icône «enregistrer». Je vous conseille de créer un répertoire que nous nommerons «Hello», et dans ce répertoire nous allons enregistrer notre document (appelons-le également «Hello»). Vous remarquerez que l'extension proposée est adb. Notre code en Ada portera le nom de Hello.adb ; par la suite nous verrons à quoi peut servir l'extension ads qui est également proposée.

Bien entendu, il est possible d'écrire dans la fenêtre principale, la taille du texte pouvant être modifiée en cliquant sur le bouton «taille». En revanche, il est impossible d'écrire dans la partie basse de la fenêtre, celle-ci étant réservée au compilateur. C'est ici que le compilateur affichera les informations qui vous seront nécessaires : échec de la compilation, réussite de la compilation, lignes inutiles …

Pour les utilisateurs de GPS (plus long)

Le logiciel GPS est un peu plus compliqué que Adagide. Il est toutefois mieux adapté à de gros projets, ce qui explique qu'il soit plus complexe et donc moins adapté pour ce cours. Lorsque vous lancez GPS, une fenêtre devrait vous demander ce que vous souhaitez faire.

Fenêtre d'accueil du logiciel GPS

Pour l'heure, choisissez «Create new project with wizard» et cliquez sur «OK». Choisissez l'option «Single project» puis cliquez sur «Forward». Choisissez un nom pour votre projet (j'ai choisi «HelloWorld») et précisez un répertoire où l'enregistrer (je vous conseille de créer un répertoire spécifique par projet). Cliquez ensuite sur «Apply» sans renseigner les autres informations. Vous devriez arriver à l'écran suivant :

Fenêtre de projet avec GPS

La fenêtre est découpée en quatre zones. La première ne nous intéresse pas pour l'instant. La seconde, juste en dessous, affichera les fichiers et programmes de votre projet. Pour l'heure vous n'aurez qu'un seul fichier donc cela ne comportera pas d'intérêt pour les premiers cours. Son utilité se révèlera à partir de la Partie III. La troisième zone de la fenêtre est la zone principale, celle où vous rédigerez votre programme. Enfin, la quatrième zone est celle réservée au compilateur et à la console. Vous comprendrez son utilité bientôt.

Commençons donc par créer un nouveau fichier en cliquant sur l'icône «Nouveau» ou sur File > New. Sauvegardez tout de suite votre fichier en cliquant soit sur l'icône «Enregistrer» soit sur File > Save As. Votre fichier devra s'appeler «Hello.adb» (même si vous n'avez pas besoin d'écrire l'extension). Comme je vous le disais plus haut, il existe également un fichier .ads que nous verrons plus tard et que le logiciel GPS gère aussi. Pour ouvrir un document, vous pourrez utiliser l'icône «Ouvrir» ou sur File > Open.

Voila pour l'essentiel, toutefois, je vais vous demander d'effectuer deux petites manipulations avant d'aller plus loin afin d'ajouter deux icônes importantes. Cliquez sur le menu Build > Settings > Targets. Une fenêtre devrait s'ouvrir (voir la figure suivante).

Fenêtre de configuration

À gauche, dans la section Project, cliquez sur Build <current file=""></current> et cochez la case In the toolbar. Puis, dans la section Run, cliquez sur Custom et cochez la case In the toolbar. Enfin, cliquez sur le bouton Apply. Deux icônes devraient s'ajouter, comme celles des figures suivantes (retenez-les bien).

Construire

Exécuter

Notre premier programme

Un petit copier-coller !

Maintenant que nous avons rapidement pris connaissance du logiciel, il est temps de nous lancer corps et âme dans la création de notre magnifique programme «Hello» ! Nous allons pour cela effectuer une opération de haute voltige : un copier-coller ! Voici le code d'un programme. Ne cherchez pas à comprendre pour l'instant, je vous expliquerai par la suite. Pour l'heure, sélectionnez le texte, copiez-le et collez-le dans votre fichier Hello.adb sans poser de questions.

1
2
3
4
5
6
7
8
with ada.text_io ; 
use ada.text_io ; 

procedure Hello is
--partie réservée aux déclarations
begin
put("Salut tout le monde !") ; --on affiche un message
end Hello ;

Vous remarquerez que certains mots sont automatiquement colorés, je vous en ai déjà parlé, c'est la coloration syntaxique. Elle permet de faire ressortir certains mot-clés (Adagide colore par défaut en bleu les mots réservés au langage Ada) ou certains types de texte.

Avant d'aller plus loin, si vous êtes sous Adagide (GPS effectuera cette manœuvre tout seul le moment venu), il serait bon de cliquer sur l'icône «Reformat», il est simple à trouver, c'est celui avec un grand R dessiné dessus. Cela va mettre votre code en forme : la ligne entre is et begin et la ligne entre begin et end vont être «avancées» à l'aide d'une tabulation (trois espaces sous adagide). On appelle ça l'indentation. Ca n'a l'air de rien mais c'est très important car à l'avenir votre code pourra s'étendre sur plusieurs pages, il est donc important qu'il soit le plus lisible possible. Lorsque l'on rédige un roman, on crée des paragraphes, des chapitres… en programmation on indente son texte.

Compiler, créer… lancer !

Maintenant que votre texte est écrit et mis en forme, il est temps de le faire fonctionner. Nous allons donc utiliser le compilateur. Pour cela, rien de plus simple, cliquez sur l'icône «Compiler» (ou appuyer sur F2 avec Adagide, ou encore Compile > Compile File). Le compilateur vérifiera la syntaxe de votre code. S'il n'y a pas d'erreur (et il ne devrait pas y en avoir), le compilateur devrait vous indiquer (dans la fenêtre du bas) «Completed successfully».

Mais à ce stade, votre programme n'existe pas encore, vous devez construire l'exécutable. Pour cela cliquez sur l'icône «construire» (ou appuyez sur F3 avec Adagide ou cliquez sur Compile > Build).

Pour les utilisateurs de GPS, les manipulations étant un peu longues, je vous conseille d'utiliser les icônes (c'est bien pour cela que je vous ai fait faire une petite manipulation préliminaire). Lorsque vous cliquerez sur l'icône «Construire», une fenêtre peut s'ouvrir. Ne vous souciez pas des paramètres et cliquez sur OK.

Votre fichier exécutable est désormais créé. Vous pouvez soit aller le chercher dans le répertoire Hello que vous avez créé tout à l'heure, soit cliquer sur l'icône «Exécuter» (ou appuyer sur F4 avec Adagide ou cliquer sur Run > Execute). Sous GPS, une fenêtre s'ouvrira. Ne cochez aucune case et, si la barre de texte est vide, écrivez-y le nom de votre programme : Hello (sans extension !). Puis cliquez sur OK.

Avec Adagide, vous devriez ainsi obtenir une magnifique fenêtre noire vous indiquant :

1
Salut tout le monde !

(Sous GPS, ces actions apparaîtront dans la fenêtre du compilateur, c'est-à-dire la quatrième zone de la fenêtre)

Euh… comment dire…, c'est tout ? J'ai lu tous ces chapitres pour voir ça ?! :colere:

Ne perdez pas patience. Le chemin sera long avant que vous ne puissiez créer un programme digne d'intérêt. :ange: Prenons le temps de décortiquer ce que nous avons copié pour mieux comprendre.

Mon dieu, qu'ai-je fait ?

Si nous jetons un œil à notre code nous pouvons nous rendre compte qu'il peut se décomposer en deux parties majeures : une sorte de titre (avec with et use) et un gros paragraphe (commençant par le mot procedure).

Organisation de votre code

Le corps du programme : la procédure Hello

Le titre étant un peu compliqué à expliquer, nous allons commencer par nous intéresser au «gros paragraphe» : la procédure appelée Hello. Elle peut se décomposer elle-même en deux parties comme sur la figure précédente.

Les trois bornes de la procédure

Pour l'instant, disons que le terme de «procédure» est un synonyme de «programme». Notre paragraphe commence donc par l'introduction suivante : PROCEDURE Hello IS. Cette phrase permet de donner un nom à notre procédure et indique le début du texte la concernant. Remarquez que les mots procedure et is sont colorés en bleu : ce sont des mots réservés par le langage Ada, ils ont donc un sens très précis et ne peuvent être utilisés n'importe comment.

Deuxième «borne» de notre procédure : le terme begin. C'est lui aussi un mot réservé. Il indique au compilateur le début des instructions que l'ordinateur devra exécuter.

Troisième «borne» : le mot end, ou plus exactement la phrase : «END Hello ;». Cette phrase indique au compilateur la fin de la procédure Hello. À noter que contrairement aux deux bornes précédentes, cette phrase se termine par un point-virgule. Si vous oubliez de l'écrire, le compilateur vous avertira : missing ";" ! Notez que les points virgule indiquent au compilateur la fin d'une instruction : ici, c'est la fin de votre procédure.

La partie Déclaration

Les trois bornes vues précédemment délimitent deux zones. La première, celle comprise entre is et begin, est réservée aux déclarations. Nous verrons dans les prochains chapitres de quoi il retourne. Sachez pour l'instant que votre programme peut avoir besoin de mémoire supplémentaire pour fonctionner (et nous aurons très vite besoin de davantage de mémoire) et que c'est dans cette partie que s'effectueront les demandes de réquisition de mémoire. Pour l'heure, il n'y a rien.

Comment ça il n'y a rien ? Il y a bien quelque chose d'écrit : «--partie réservée aux déclarations»

Eh bien non. Pour le compilateur, il n'y a rien ! :p Cette ligne verte commence par deux tirets. Cela signifie qu'il s'agit d'un commentaire, c'est-à-dire d'un texte qui ne sera pas pris en compte par le compilateur. Quel intérêt d'écrire du texte s'il n'est pas pris en compte par le compilateur ? Eh bien cela permet d'apporter des annotations à votre code. Si vous relisez un code écrit par quelqu'un d'autre ou par vous même il y a longtemps, vous risquez d'avoir du mal à le comprendre. Les commentaires sont donc là pour expliquer ce que fait le programme, à quoi servent telle ou telle ligne, etc. Un bon code est déjà un code bien commenté (et bien indenté également).

La partie Action et notre première instruction

Puis, après le BEGIN, vient la partie la plus intéressante, celle où l'on indique au programme ce qu'il doit faire, autrement dit, c'est là que nous écrirons les différentes instructions.

L'instruction citée ici est : «Put("Salut tout le monde!") ;». C'est assez simple à comprendre : l'instruction Put() indique à l'ordinateur qu'il doit afficher quelque chose. Et entre les parenthèses, on indique ce qu'il faut afficher. Il est possible d'afficher un nombre (par exemple, «Put(13) ;» affichera le nombre 13) comme du texte, mais le texte doit être écrit entre guillemets.

Remarquez là encore que l'instruction se termine par un point-virgule. D'ailleurs, toutes les instructions devront se terminer par un point virgule, à quelques exceptions près (souvenez-vous de IS et BEGIN). Le texte qui suit est bien entendu un commentaire et tout ce qui suit les double-tirets ne sera pas pris en compte par le compilateur.

Il est bien sûr possible d'afficher autre chose que "salut tout le monde !" ou d'effectuer d'autres actions. Toutefois, lorsque toutes vos actions ont été écrites, n'oubliez pas d'indiquer au compilateur que vous avez atteint la fin du programme en utilisant le mot-clé END.

Les Packages avec With et Use

Le mot-clé WITH

Revenons maintenant au titre. Pourquoi cet intitulé ? Et d'ailleurs pourquoi l'écrire deux fois ? Je vous propose de le supprimer pour mieux comprendre. Compiler à nouveau votre code.

:waw: Argh ! ! Ça ne marche plus ! J'ai pleins de messages rouge ! Tout est fichu !

En effet, le code n'est plus correct et ce n'est pas la peine d'essayer de reconstruire notre programme. Mais lisons tout d'abord les avertissements du compilateur : «Put» is undefined.

Cela signifie tout simplement que le compilateur ne connaît plus l'instruction Put() ! En effet, le compilateur ne connaît que très peu de mots et d'instructions : les mots réservés et puis, c'est presque tout. Pour aller plus loin, il a besoin de fichiers qui contiennent d'avantage d'instructions comme l'instruction Put() par exemple, qui se situe dans un fichier appelé Ada.Text_IO. Ces fichiers portent le nom de package en Ada (paquetages en français). Dans d'autres langages, on parlerait de librairies.

Nous reviendrons plus en détail sur les packages durant la troisième et la quatrième partie de ce tutoriel. Donc si cette sous-partie vous semble compliquée, rassurez-vous, je vous indiquerai toujours les packages à écrire en début de code.

Le compilateur nous dit également : possible missing «WITH Ada.Text_IO ; USE Ada.Text_IO ;». Traduction : ce serait bien de remettre les lignes que vous avez supprimé tout à l'heure ! Écoutons-le mais ne réécrivons que la première ligne (au tout début) :

1
WITH Ada.Text_IO ;

Le mot-clé USE

Réessayons de compiler.

J'ai un nouveau problème. Le compilateur m'indique : «Put» is not visible, plus plein d'autres insultes incompréhensibles. Apparemment, il connait mon instruction Put() mais il n'arrive plus à la voir ?!

Exactement. Et les lignes qui suivent indiquent que dans le package ada.Text_IO, il y a plusieurs références à l'instruction Put(). En fait, il est possible après l'instruction with d'écrire de nombreux packages, autant que vous voulez même (nous verrons un exemple juste après). Mais il peut exister (et il existe) plusieurs instructions portant le nom Put(), du coup le compilateur ne sait pas d'où vient cette instruction. De laquelle s'agit-il ? Une solution est de remplacer Put() par Ada.Text_IO.Put() ! C'est compliqué, c'est long à écrire et nous aurons tout le loisir de comprendre tout cela plus tard. Donc une façon de s'épargner ces difficultés, c'est d'écrire notre instruction Use au tout début, juste après l'instruction with.

Ces deux lignes (appelées Context Clause en Ada ou Clauses de contexte en Français) sont donc indispensables et vous serez souvent amenés à réécrire les mêmes (vous bénirez bientôt l'inventeur du copier-coller). Ne croyez pas que cette lourdeur soit spécifique à Ada. Tout langage a besoin de packages ou librairies annexes, tout n'est pas prédéfini et heureusement pour nous : c'est ce que l'on appelle la modularité. Au final, voici la structure de notre programme et de tout programme Ada (voir la figure)

La structure du programme

Avec plusieurs packages

J'ai essayé de bidouiller le code pour qu'il affiche 13 comme tu le disais dans un exemple. Mais le compilateur râle encore : warning : no entities of «Text_Io» are referenced, no candidate match the actuals :… Bref, rien ne va plus. Faut-il un autre package ?

Exactement ! Ada.Text_IO est un package créé pour gérer le texte comme son nom l'indique (Text = texte et IO = In Out, entrée et sortie). Pour afficher un nombre entier (ici 13), il faut utiliser le package Ada.Integer_Text_IO. Par exemple :

1
2
WITH Ada.Text_IO,Ada.Integer_Text_IO ; 
USE Ada.Text_IO,Ada.Integer_Text_IO ;

Les instructions WITH et USE sont terminées par un point-virgule, en revanche les deux packages sont simplement séparés par une virgule !

Pour plus de clareté, il est également possible d'écrire ceci :

1
2
3
4
WITH Ada.Text_IO,
   Ada.Integer_Text_IO ; 
USE Ada.Text_IO,
   Ada.Integer_Text_IO ;

ou ceci :

1
2
WITH Ada.Text_IO ;           USE Ada.Text_IO ; 
WITH Ada.Integer_Text_IO ;   USE Ada.Integer_Text_IO ;

Et oui ! Bien Présenter son code, c'est très important !

Une dernière remarque qui a son importance

Vous devez savoir avant de vous lancer à l'aventure que le langage Ada n'est pas «case sensitive», comme diraient nos amis anglais. Cela signifie qu'il ne tient pas compte de la casse. Autrement dit, que vous écriviez en majuscule ou en minuscule, cela revient au même : BEGIN, Begin, begin ou bEgIn seront compris de la même manière par le compilateur. Toutefois, Ada sait faire la différence lorsqu'il faut. Si vous modifiez la casse dans la phrase à afficher "Salut tout le monde !", l'affichage en sera modifié.

De même, une tabulation ou un espace seront pris en compte de la même façon. Et que vous tapiez un, deux ou trois espaces ne changera rien.

Exercices

Exercice 1

Ce premier programme est peut-être simple, mais voici quelques exercices pour nous amuser encore. Nous avons vu l'instruction Put() qui affiche du texte, en voici maintenant une nouvelle : New_line. Elle permet de retourner à la ligne. N'oubliez pas le point virgule à la fin.

Énoncé

Écrire un programme affichant ceci :

1
2
3
4
Coucou
tout le
monde
! ! !

Solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
With ada.text_io ; 
use ada.text_io ; 

procedure Hello2 is

begin
   Put("Coucou") ; New_line ; 
   Put("tout le") ; New_line ; 
   Put("monde") ; New_line ; 
   Put("! ! !") ; 
end Hello2 ;

Exercice 2

Troisième instruction : Put_line(). Elle fonctionne comme Put(), sauf qu'elle crée automatiquement un retour à la ligne à la fin.

Énoncé

Même exercice que précédemment, mais sans utiliser New_line.

Solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
With ada.text_io ; 
use ada.text_io ; 

procedure Hello3 is

begin
   Put_line("Coucou") ; 
   Put_line("tout le") ; 
   Put_line("monde") ; 
   Put("! ! !") ;           --pas besoin de put_line ici, on est arrivé à la fin
end Hello3 ;

Exercice 3

Énoncé

Pourquoi ne pas créer des programmes affichant autre chose que "coucou tout le monde !".

Attention, vous n'avez pas le droit aux caractères accentués. Uniquement les caractères anglo-saxons si vous ne voulez pas avoir de drôles de surprises. Donc pas de é, è, à, ù, ê, ë, ö…

Vous avez désormais créé votre premier programme. Certes, il n'est pas révolutionnaire, mais c'est un début. Nous allons pouvoir quitter la première partie de ce tutoriel et entrer dans les bases de la programmation en Ada. La prochaine partie nous permettra de manipuler des nombres, d'effectuer des opérations, de saisir des valeurs au clavier … peu à peu nous allons apprendre à créer des programmes de plus en plus complexes.


En résumé :

  • Tout programme débute par les clauses de contexte : à l'aide des mots clés WITH et USE, vous devez lister les packages nécessaires.
  • Les instructions Put(), Put_line() et New_line() sont accessibles avec le package Ada.Text_IO. Elles permettent respectivement d'écrire du texte, d'écrire une ligne et de retourner à la ligne.
  • Les instructions doivent s'achever par un point virgule.
  • Prenez soin de bien présenter votre code. Pour cela, indentez-le en utilisant la tabulation et commentez-le en écrivant quelques indication après un double-tiret.
  • Les mots réservés, comme BEGIN, END, PROCEDURE, WITH ou USE, ont un sens bien précis et ne pourront pas être utilisés pour autre chose que ce pour quoi ils sont prévus.