Voir la source de Ada

[[Catégorie:Développement]]

= Introduction au langage Ada =

par [[Utilisateur:Jiel|Jiel]]

== Avant propos ==

=== Avertissement ===

Ceci n'est qu'une introduction au langage Ada, car il existe des livres entiers avec des centaines de pages sur ce sujet ! Par conséquent ne vous attendez pas à faire le tour de la question... Ce n'est pas non plus un cours de programmation : cet article s'adresse à des personnes possédant des bases de programmation et voulant se mettre à Ada. Cela dit, le langage est relativement simple à comprendre et pourrait constituer un bon choix pour se lancer dans le merveilleux monde du développement. :-)

=== Téléchargement ===
GNAT GPL 2006 : https://libre2.adacore.com/

=== Présentation du langage ===

Ada est un langage de programmation conçu en réponse à un cahier des charges établi par le département de la Défense des Etats-Unis. Son développement a commencé au début des années 1980 (Ada 83). Il a été ensuite repris et amélioré au milieu des années 1990, pour donner Ada 95, 2006, le premier langage objet standardisé de manière internationale.

Le nom Ada a été choisi en honneur d'Ada Lovelace. Ada est un langage à typage statique, modulaire et offrant une syntaxe claire non ambigûe inspirée de Pascal. Il est souvent utilisé dans des systèmes temps-réel et/ou embarqués nécessitant un haut niveau de fiabilité (armée, transports ferroviaires, technologies aéronautiques, technologies spatiales...). Ada est un langage assez strict qui oblige à coder proprement, il est souvent enseigné pour des raisons pédagogiques.

== Bases du langage ==

=== Fonction et procédures ===

==== Fonctions ====

En Ada, les arguments d'une fonction sont accessibles uniquement en lecture: il n'est donc pas question de modifier leur valeur lors de l'exécution de la fonction. Les fonctions retournent toujours quelque chose. Voici un exemple:

<div class="code"> function ''Nom_fonction''(''arg1''<nowiki>:</nowiki>''type1''<nowiki>;</nowiki>''arg2''<nowiki>:</nowiki>''type 2''...) return ''type_resultat'' is<br />''déclarations''<br /> begin<br />''instructions''<br /> return ...;<br /> end ''Nom_fonction''<nowiki>;</nowiki><br /> </div>

==== Procédures ====

Les procédures peuvent être définies comme des fonctions qui ne renvoient rien; elles peuvent néanmoins produire un résultat de sortie. Pour chaque paramètre de la procédure, on peut préciser la modalité de passage :

- <span class="code">in</span> : lecture du paramètre, comme pour l'argument d'une fonction.<br /> - <span class="code">out</span> : écriture du paramètre uniquement (correspond à un résultat de sortie).<br /> - <span class="code">in out</span> : lecture et écriture: la valeur du paramètre est prise en compte et peut être modifiée.<br />

Voici la structure d'une procédure:

<div class="code"> procedure ''Nom_procedure''(''arg1''<nowiki>:</nowiki>''mode1'' ''type1''<nowiki>; </nowiki>''arg2''<nowiki>:</nowiki>''mode2'' ''type 2''...) is<br />''déclarations''<br /> begin<br />''instructions''<br /> end ''Nom_procedure''<nowiki>; </nowiki><br /> </div>

==== Syntaxe et opérateurs de comparaison ====

Chaque instruction est terminée par un point virgule <span class="code"><nowiki>;</nowiki></span>. L'affectation se fait en utilisant <span class="code"> := </span>. Une ligne de commentaires est préfixée par deux tirets <span class="code">--</span>. Les opérateurs de comparaison sont les suivants:

{|
| <span class="code"> = </span>
| égalité
|-
| <span class="code"> /= </span>
| inégalité
|-
| <span class="code"> < </span>
| strictement inférieur à
|-
| <span class="code"> > </span>
| strictement supérieur à
|-
| <span class="code"> <= </span>
| inférieur à
|-
| <span class="code"> >= </span>
| supérieur à
|-
| <span class="code"> in </span>
| appartenance à un intervalle
|-
| <span class="code"> not in </span>
| non appartenance à un intervalle
|}

==== Déclarations ====

La partie déclarative doit contenir:

- Les types et les sous-types.<br /> - Les variables sous la forme <span class="code"> ''Nom_variable''<nowiki>:</nowiki>''Nom_type''[:= ''Valeur_Initiale''];</span><br>
- Les constantes telles que <span class="code">Pi:constant FLOAT:= 3.14159;</span><br>
- Des procédures et des fonctions qu'on utilisera ensuite dans le corps.<br />

=== Les types ===

==== Types discrets ====

Pour commencer, un peu de vocabulaire: les "types discrets" sont les types ordonnés où chaque élément a un successeur et un prédécesseur. Ils sont munis d'attributs, des fonctions exprimant les propriétés courantes du type. La syntaxe est <span class="code">T'nom_attribut</span>, où T est un type discret. Ces attributs sont les suivants:

- <span class="code">T'FIRST</span><br />

Borne inférieure du type T.

<br /> - <span class="code">T'LAST</span><br />

Borne supérieure du type T.

<br /> - <span class="code">T'POS(X)</span><br />

X est de type T et <span class="code">T'POS(X)</span> renvoie la position de X dans le type T.

<br /> -<span class="code">T'VAL(N)</span><br />

N est de type entier et <span class="code">T'VAL(N)</span> est l'élément de position N dans le type T.

<br /> - <span class="code">T'SUCC(X)</span><br />

X est de type T et <span class="code">T'SUCC(X)</span> est le successeur de X dans T, ainsi <span class="code">T'SUCC(X)= T'VAL(T'POS(X)+1)</span>.

<br /> - <span class="code">T'PREC(X)</span><br />

X est de type T et <span class="code">T'PREC(X)</span> est le prédécesseur de X dans T, ainsi <span class="code">T'SUCC(X)= T'VAL(T'POS(X)-1)</span>.

<br /> - <span class="code">T'IMAGE(X)</span><br />

X est de type T et <span class="code">T'IMAGE(X)</span> est une chaîne de caractères qui contient l'image de X.

<br /> - <span class="code">T'WIDTH</span><br />

Donne le nombre maximal de caractères pour une image d'une valeur de T.

- <span class="code">T'VALUE(S)</span><br />

S est une chaîne de caractères qui est l'image d'un élément de type T; <span class="code">T'VALUE(S)</span> est l'élément en question.

==== Types prédéfinis ====

Le type discret entier <span class="code">INTEGER</span>. Il possède deux sous-types prédéfinis: <span class="code">NATURAL</span> pour les entiers naturels et <span class="code">POSITIVE</span> pour les entiers strictement positifs. Certains opérateurs sont prédéfinis, ce sont l'addition <span class="code">+</span>, la multiplication <span class="code"><nowiki>*</nowiki></span>, la soustraction <span class="code">-</span>, la division <span class="code">/</span>, le reste de la division <span class="code">mod</span>, l'exponentiation <span class="code"><nowiki>**</nowiki></span>.

Le type discret caractère <span class="code">CHARACTER</span>. Pour représenter un caractère, on utilise les apostrophes : 'a'.

Le type discret booléen <span class="code">BOOLEAN</span>, composé de <span class="code">TRUE</span> et de <span class="code">FALSE</span>. Les opérateurs logiques sont <span class="code">and</span>, <span class="code">and then</span>, <span class="code">or</span>, <span class="code">or else</span> et <span class="code">not</span>.

le type <span class="code">FLOAT</span> pour représenter les nombres réels.

le type <span class="code">STRING</span> pour les chaînes de caractères. Pour représenter une chaîne de caractères, on utilise les guillemets, par exemple: "La petite Léa est très jolie".

==== Type énumérés ====

On peut définir un type énuméré, qui est un type discret fini (comme le type booléen), par exemple le type Jour:

<span class="code">type Jour is (lunae_dies, martis_dies, mercurii_dies, jovis_dies, veneris_dies, saturnus_dies, solis_dies);</span>

L'ordre d'énumération définit un ordre. On a ainsi dans notre exemple ''lunae_dies'' < ''martis_dies'' < ... < ''solis_dies''.

==== Sous-types ====

Un sous-type est défini comme la restriction d'un type parent discret, sous la forme:

<span class="code">subtype ''nom_sous_type'' is ''nom_type'' range ''val1'' .. ''val2''<nowiki>;</nowiki></span>

où ''val1'' et ''val2'' sont deux éléments de type nom_type tels que val1 < val2. . Par exemple:

<span class="code">subtype Chiffre is INTEGER range 0..9;
subtype Alphabet is CHARACTER range 'a'..'z';</span>

On peut appliquer à un sous-type les fonctions prévues pour son type parent, mais il faut faire attention à ce que le résultat reste dans l'intervalle.

==== Types privés ====

Les types en Ada peuvent être divisés en deux catégories. Il y a d'une part types énumératifs, types tableaux etc. sans oublier les types prédéfinis, c'est à dire les types dont la structure est connue des utilisateurs. Ils sont dits publiques. D'autre part les types privés permettent de cacher les détails de structure afin de respecter le principe d'abstraction des données en masquant la représentation interne des données, exportant les opérations de manipulation de ce type, empêchant un usage non contrôlé.

La syntaxe d'une déclaration d'un type privé est: <span class="code">type T_NOM_DU_TYPE is private;</span>.

==== Types limités ====

Si pour un type, on ne peut pas utiliser l'affectation et l'égalité prédéfinies, alors ce type est appelé un type limité. Attention, un type composé qui contient un composant limité doit obligatoirement être déclaré limité. Exemple:

<div class="code"> type Rationnel is limited record<br />   numérateur : POSITIVE := 1;<br />   dénominateur : POSITIVE := 1;<br /> end record;<br /> </div>

==== Types privés limités ====

Les types privés limités sont comme les types privés, mais où l'utilisation est encore plus limitée; logique, non? Ils ne possèdent plus ni la comparaison ni l'affectation. Avec un type privé limité on ne peut que déclarer des variables et utiliser les sous-programmes fournis par le paquetage (sans affectation ni comparaison). Ces techniques permettent un contrôle total sur leur utilisation. Un type privé limité se déclare de la façon suivante : <span class="code">type T_EXEMPLE is limited private ;</span>

Ouf! C'en est fini pour les types ;-)
Les types privés limités sont des types privés dont l'utilisation est encore plus restreinte; ils ne possèdent plus ni la comparaison ni l'affectation.

=== Branchements conditionnels ===

==== Si, alors, sinon ====

Comme dans la majorité des langages on trouve une structure conditionnelle de type "si, alors, sinon" , elle se construit comme suit:

<span class="code"> if ''condition'' then ... else ... end if;</span><br><span class="code"> if ''condition'' then ... elsif ''condition2'' ... elsif ''condition3'' ... end if;</span>

==== Choix multiples ====

Il existe également une structure permettant de faire des choix multiples.

<span class="code"> case ''expression'' is
     when ''choix1'' => ...
     when ''choix2'' => ...
     ...
     when others => ...
 end case; </span>

=== Les boucles ===

Attention, l'indice d'une boucle est de type discret et c'est une variable muette. Cela signifie que cette variable n'a pas à être déclarée et que sa valeur ne peut pas être modifiée par des instructions explicites.

==== Pour ====

les boucles "pour" se construisent comme suit:

<span class="code"> for ''indice'' in [reverse] ''debut .. fin'' loop ... end loop; </span>

Si on veut préciser que l'intervalle doit être parcouru en sens inverse, on utilise le mot clef <span class="code">reverse</span>.

==== Tant que ====

Les boucles "tant que" se construisent comme suit:

<span class="code"> while ''condition'' loop ... end loop; </span>

=== Les tableaux ===

==== Tableaux contraints ====

La taille des tableaux est précisée lors de la définition du type :

<span class="code">type ''Nom_Type_Tableau'' is array(''Intervalle_fini_d'un_type_discret'') of ''Type_Element''<nowiki>;</nowiki></span>

Les bornes d'un tableau ne sont pas nécessairement statiques. Exemple:

<div class="code"> type T is array (1..5) of INTEGER ;<br /> tab1 : T;<br /> type MATRICE is array(1..4, 1..4) of INTEGER;<br /> ma_matrice : M;<br /> </div>

On accède au i-ème élément d'un tableau ''tab'' en tapant <span class="code">tab(i)</span>. On peut manipuler les cases d'un tableau avec des agrégats, par exemple <span class="code">Tab1:Tableau(1..6):=(1|2=>3, others=>4);</span> ou <span class="code">Tab2:Tableau:=(1..10=>3);</span>.

L'opérateur <span class="code">&</span> permet de concaténer deux tableaux de même type. Ainsi, <span class="code">T1 & T2</span> donne un tableau de taille T1'length+T2'length, contenant les éléments de T1 suivis de ceux de T2. <span class="code">&</span> permet également de concaténer un élément à un tableau. Attention aux erreurs de dépassements, un tableau en Ada a une taille fixe une fois pour toutes lorsqu'il est déclaré.

==== Tableaux non contraints ====

Le type des indices et du type des éléments est précisé lors de la définition du type mais pas la taille du tableau. On peut faire sur les tableaux non contraints toutes les manipulations qu'on peut faire sur les tableaux contraints. Voici l'exemple d'un tableau de nombres naturels indexé par des entiers:

<span class="code"> type T is array (INTEGER range <>) of NATURAL ; </span>

Un objet de type T doit alors être contraint lors de sa déclaration, soit en précisant l'intervalle d'indexation, soit en lui affectant un autre tableau.

==== Chaînes de caractères ====

Le type STRING est un type pré-défini du paquetage STANDARD. Il est défini comme un tableau non contraint de caractères et indexé d'entiers strictement positifs. Les chaînes de caractères se manipulent donc exactement comme des tableaux, ainsi : <span class="code">S:STRING(1..18);</span>. Quand on ne connait pas la longueur d'une chaîne de caractères, on est obligé de fixer lors de la déclaration une taille maximum et de gérer ensuite explicitement la vraie longueur.

==== Attributs de tableaux ====

Les tableaux bénéficient d'attributs spécifiques. Soit T un objet de type tableau, on a:

- <span class="code">T'FIRST</span> indice du premier élément. <span class="code">T(T'FIRST)</span> nous donne la première valeur.<br /><br /> - <span class="code">T'FIRST(n)</span> indice du premier élément de la dimension ''n''.<br /><br /> - <span class="code">T'LAST</span> indice du dernier élément de la première dimension.<br /><br /> - <span class="code">T'LAST(n)</span> indice du dernier élément de la dimension ''n''.<br /><br /> - <span class="code">T'RANGE</span> intervalle d'indexation de la première dimension de T.<br /><br /> - <span class="code">T'RANGE(n)</span> intervalle d'indexation de la dimension ''n'' de T.<br /><br /> - <span class="code">T'LENGTH</span> longueur de la première dimension du tableau.<br /><br /> - <span class="code">T'LENGTH(n)</span> longueur de la dimension n du tableau.<br />

=== Les structures ===

Une structure, ou enregistrement, est un objet composé d'une séquence de membres de types divers, portant des noms. On la construit comme suit:

<div class="code"> type ''Nom_structure'' is record<br />   ''champ1''<nowiki>: </nowiki>''type1''<nowiki>;</nowiki><br />   ''champ2''<nowiki>: </nowiki>''type2''<nowiki>;</nowiki><br />   ''champ3''<nowiki>: </nowiki>''type3''<nowiki>;</nowiki><br /> end record; </div>

On peut donner des valeurs initiales aux champs des structures, en mettant <span class="code"><nowiki>:= </nowiki>''valeur''</span> après le nom du type.

On accède aux champs d'une structure avec un point <span class="code">.</span> : <span class="code">S: Nom_structure; ... Nom_structure.champ1 Nom_structure.champ2 Nom_structure.champ3</span>

Pour affecter une valeur complète à une structure, on peut utiliser des agrégats:

<div class="code"> type ''Date'' is record<br />   ''jour''<nowiki>: POSITIVE range 1..31;</nowiki><br />   ''mois''<nowiki>: STRING(1..9);</nowiki><br />   ''annee''<nowiki>: POSITIVE;</nowiki><br /> end record;<br /><br /> D:=(18, "février", 1983);<br /> D:=(mois=>"février", jour=>18, annee=>1983);<br /> </div>

Il est possible de passer des paramètres à une structure. Dans l'exemple suivant, le recours à une structure avec paramètres permet d'avoir des chaînes de caractères variables, et on mettra les dimensions que lors de la déclaration:

<div class="code"> type ''Adresse_Manchot''(I, B: Natural) is record<br />   ''Igloo''<nowiki>: STRING(1..I);</nowiki><br />   ''Banquise''<nowiki>: STRING(1..B);</nowiki><br /> end record;<br /><br /> A: Adresse_Manchot(10,20);<br /> </div>

=== Traitement des exceptions ===

Ada possède des exceptions prédéfinies, dont le nom est explicite: <span class="code">CONSTRAINT_ERROR</span>, <span class="code">STORAGE_ERROR</span>, <span class="code">PROGRAM_ERROR</span>, <span class="code">NUMERIC_ERROR</span>, <span class="code">TASKING_ERROR</span>. Il y a également des exceptions prédéfinies liées aux entrées-sorties que l'on trouve dans la bibliothèque <span class="code">ADA.IO_EXCEPTIONS</span>. Une exception, lorsqu'elle est déclenchée, interrompt l'exécution des blocs qu'elle traverse.

On peut lancer une exception grâce au mot clef <span class="code">raise</span>. On peut aussi capturer les exceptions avec <span class="code">when</span>. En Ada, le traitement des exceptions doit se faire dans les instructions bloc, les sous-programmes, les paquetages, les tâches ou les unités génériques. Ces traitements sont regroupés sous la rubrique <span class="code">exception</span> comme dans l'exemple suivant:

<span class="code"> exception when CONSTRAINT_ERROR => put_line("une contrainte n'a pas été respectée"); raise CONSTRAINT_ERROR; </span>

Il est possible de définir une exception, de la même manière que l'on définit un type ou déclare une variable. On la manipule ensuite comme une exception prédéfinie.

=== Entrées-sorties ===

Les fonctionnalités d'entrées-sorties sont disponibles dans le paquetage <span class="code">ADA.TEXT_IO</span> pour les chaînes de caractères et <span class="code">ADA.INTEGER_TEXT_IO</span> pour les entiers. Les procédures les plus utiles sont <span class="code">get(...)</span>, <span class="code">put(...)</span>, <span class="code">put_line(...)</span> et <span class="code">new_line</span>.

=== Les pointeurs ===

Les pointeurs sont sans doute la notion la moins explicite du langage. Pas de panique! Il se peut que vous mettiez quelques temps à les prendre en main.

==== Déclaration ====

Les pointeurs en Ada s'utilisent grâce au mot clef <span class="code">access</span>. Soit T_Quelconque un type quelconque, un type "pointeur sur un objet de type T_Quelconque" se déclare comme ceci: <span class="code">type ''T_Pointeur_T_Quelconque'' is access ''T_Quelconque'' ;</span>. Désormais, toute variable (ou instance) de ce nouveau type ''T_Pointeur_T_Quelconque'' sera considérée comme pouvant pointer sur un objet de type ''T_Quelconque''. On notera que le "type pointeur" n'existe pas en soi, seul un type "pointeur sur un type donné" peut être défini. On déclare deux pointeurs de ce type de la façon suivante: <span class="code">Pointeur_1, Pointeur_2 : T_Pointeur_T_Quelconque ;</span>. Ils pourront ainsi désigner chacun un objet de type ''T_Quelconque''. A ce moment là , ils ne pointent sur rien : leur valeur est automatiquement initialisée à NULL lors de la déclaration.

==== Création et accès à  l'objet pointé ====

A tout moment l'utilisateur peut créer des objets dans le corps d'un sous-programme au moyen de l'allocateur <span class="code">new</span> portant sur le type de l'objet qui doit être pointé. La valeur de retour est l'adresse mémoire dynamique que le système lui a allouée:

<div class="code"> Pointeur_1 := new T_Quelconque ;<br /> Pointeur_2 := new T_Quelconque ; </div>

Les zones mémoire pour chaque objet pointé sont réservées; cependant elles n'ont toujours pas de valeurs. Celles-ci vont pouvoir leur être données comme suit, avec <span class="code">.all</span><nowiki>:</nowiki>

<div class="code"> Pointeur_1.all := XXX ;<br /> Pointeur_2.all := YYY ; </div>

La permutation des deux valeurs s'obtient par permutation des valeurs des deux pointeurs (les valeurs ne changeront pas de place):

<div class="code"> Pointeur_3 := Pointeur_1 ;<br /> Pointeur_1 := Pointeur_2 ;<br /> Pointeur_2 := Pointeur_3 ; </div>

==== Opérations sur les pointeurs ====

Les seules opérations de comparaison sur les pointeurs sont l'égalité et la non-égalité. Le type pointeur est donc un type private. Cela est dû au fait que les valeurs d'un pointeur représentent des adresses mémoires (virtuelles), elles n'appartiennent pas à  un ensemble ordonné. La représentation des adresses dépend de l'implémentation, et ce ne sont à priori pas forcément des entiers.

== Ecrire un programme ==

=== Les paquetages ===

Le programme principal Ada utilise en général des paquetages, qui correspondent à des bibliothèques ou d'autres programmes. Pour cela, La clause <span class="code">with ''nom_paquetage''</span> au début d'un programme permet d'accéder aux fonctionnalités du paquetage ''nom_paquetage''. On peut ajouter une clause <span class="code">use ''nom_paquetage''</span> qui permet d'invoquer les fonctionnalités de ''nom_paquetage'' directement, sans préfixer l'appel de ''nom_paquetage''.

Un paquetage se partage en deux fichiers :

- ''nom_paquetage.ads'' qui contient la spécification du paquetage (fonctionnalités visibles): énumération des types, entête des fonctions et procédures proposées par le paquetage.

<div class="code"> package ''nom_paquetage'' is<br />''déclarations des types, fonctions, procédures...''<br /> end ''nom_paquetage''<nowiki>; </nowiki></div>

- ''nom_paquetage.adb'' qui contient l'implémentation du paquetage. Cette partie peut également définir des procédures ou des fonctions cachées à l'utilisateur.

<div class="code"> package body ''nom_paquetage'' is<br />''définitions des fonctions, procédures...''<br /> end ''nom_paquetage''<nowiki>; </nowiki></div>

=== Programme source ===

Le code écrit par un programmeur est constitué d'unités de bibliothèques qui doivent être placées dans des fichiers sources. Ces fichiers ont un suffixe <u>obligatoire</u> qui est pour la partie spécification <span class="code">.ads</span> et pour l'implémentation <span class="code">.adb</span>.

Le point d'entrée d'un programme Ada est la procédure principale par laquelle doit commencer l'exécution. Cette procédure peut porter un nom quelconque mais ne doit pas avoir d'arguments.

=== Exemple de programme ===

Après toutes ces présentations nous sommes pleinement capables d'écrire un petit programme. Voici un exemple de petit programme Ada que l'on stockera dans le fichier "bonjour.adb":

<div class="code"> with Ada.Text_io;<br /><br /> procedure bonjour is<br /> begin<br /> Ada.Text_io.put_line ("bonjour le monde");<br /> end bonjour;<br /> </div>

== Quels outils utiliser ? ==

=== Compilateurs ===

Il existe plusieurs compilateurs pour Ada. Dans ce qui va suivre, nous ne parlerons que de GNAT (GNU Ada Translator) qui fait partie de [http://gcc.gnu.org/ GCC] (GNU Compiler Collection). C'est actuellement le meilleur compilateur, et il est entièrement libre. GNAT est installé par défaut dans la plupart des distributions GNU/Linux; si ce n'est pas le cas, il faut chercher le paquet qui s'appelle en général ''gcc-gnat''.

=== Débuggueurs ===

Pour les programmes compilés avec GNAT, l'outil approprié est [http://www.gnu.org/software/gdb/ GDB] (GNU Project Debugger). Eh oui, le projet GNU est partout :-). De plus, GDB possède une interface graphique, appelée [http://libre.act-europe.fr/gvd/main.html GVD] (GNU Visual Debugger), qui a été développée entièrement en Ada. Si GDB n'est pas installé, il faut chercher le paquet éponyme auprès de sa distribution.

=== Générateurs de documentation ===

Deuis quelques années on s'intéresse beaucoup aux outils qui permettent de générer facilement de la documentation à partir d'un code source, tels que JavaDoc pour le Java. Il existe des outils similaires pour Ada, mais ils sont peu connus. Pour n'en citer que deux, nous pourrions parler de [http://adadoc.sourceforge.net/ AdaDoc] et [http://home.tiscalinet.ch/t_wolf/tw/ada95/adabrowse/ AdaBrowse]. Puisqu'ils sont peu connus, il y a fort à parier que vous soyez obligés de les compiler.

=== Environnements de développements ===

La lecture d'un code en Ada étant très explicite, n'importe quel éditeur de texte fera l'affaire. On notera cependant qu'[http://lea-linux.org/software/emacs.html Emacs] possède un mode Ada très abouti avec un menu et des raccourcis bien adaptés au langage, comme on peut le voir sur la capture d'écran ci-dessous:

<center>[[Image:ada-ada_emacs.png]]</center>

=== Créations d'applications graphiques ===

C'est possible aussi grâce à [http://libre.act-europe.fr/ GtkAda], une bibliothèque permettant de créer des applications graphiques portables en Gtk+. On peut également créer une application graphiquement. GtkAda est interfacé avec [http://glade.gnome.org/ Glade], le logiciel de [[GNOME]] permettant de construire des interfaces graphiques.

== Compilation ==

=== Compilation et édition de liens d'un programme ===

La façon la plus simple de compiler un programme est d'utiliser ''gnatmake''. Ainsi, la commande <span class="code">gnatmake prog</span> compilera le fichier ''prog.adb'' et donnera un exécutable ''./prog''. En fait, ''gnatmake'' réalise trois opérations. Il remplace les instructions suivantes:

<div class="code"> $ gcc -c prog.adb # compilation du source<br /> $ gnatbind # test de cohérence des différentes unités<br /> $ gnatlink # édition des liens<br /> </div>

L'étape de compilation produit un fichier objet .o et un fichier .ali par unité. Les fichiers .ali (pour Ada Library Information) contiennent les informations nécessaires ensuite à gnatbind et gnatlink.

=== Compilation de paquetages ===

La compilation de paquetage est simple, elle aussi. Prenons le cas d'un programme constitué d'un fichier contenant la procédure principale (''principal.adb'') et de deux autres fichiers contenant la spécification (''paq.ads'') et le corps (''paq.adb'') d'un paquetage. Il suffit simplement de taper <span class="code">gnatmake principal</span> et ''gnatmake'' s'occupera de compiler automatiquement tous les fichiers auxiliares. Il va en fait procéder de la sorte:

<div class="code"> $ gcc -c principal.adb<br /> $ gcc -c paq.adb<br /> $ gnatbind principal<br /> $ gnatlink principal<br /> </div>

== Mêler Ada et d'autres langages ==

Ada est peu utilisé. Qu'à cela ne tienne! On peut mêler du code Ada avec un autre langage normalisé. Actuellement, on peut par exemple interfacer Ada avec les langages C, C++, Cobol et Fortran. Cela est possible par le biais du paquetage <span class="code">Interfaces</span> et de ses fils (<span class="code">Interfaces.C</span>, <span class="code">Interfaces.C.STRINGs</span>, <span class="code">Interfaces.C.Pointers</span>, <span class="code">Interfaces.Fortran</span>...). Ce paquetage <span class="code">Interfaces</span> définit les types élémentaires de la machine. Il est muni d'enfants qui définissent la vue Ada des types des autres langages. Par exemple, le paquetage Interfaces.C définit un type int, un type C_Float, etc. dont on garantit qu'ils correspondent aux types de C.

== Conclusion ==

=== En savoir plus ===

- Association Ada-France: [http://www.ada-france.org/ http://www.ada-france.org]<br /> - Les groupes français et anglais: [http://www.ada-france.org/mailman/listinfo/comp.lang.ada fr.comp.lang.ada] et [http://www.ada-france.org/mailman/listinfo/fr.comp.lang.ada comp.lang.ada].<br /> - Le manuel de référence sur GNAT (en anglais): http://gcc.gnu.org/onlinedocs/gcc-3.3.5/gnat_rm/.<br /> - Le guide de l'utilisateur de GNAT pour UNIX (en anglais): http://gcc.gnu.org/onlinedocs/gcc-3.3.5/gnat_ug_unx/.<br /> - Le manuel de GCC: <span class="code">man gcc</span> vous dira tous les secrets de la compilation.<br /> - Le [http://lea-linux.org/pho/list/7 forum Développement] de Léa-Linux.<br />

=== C'est parti ! ===

Ada est un langage facile, il peut s'apprendre en quelques heures! Cependant, rien n'est mieux que la pratique. Osez faire de petits exercices pour vous entraîner! Bon courage :-)


<br/>
<br/>
'''<b>[[Dev-index|@ Retour à la rubrique Développement]]</b>'''
<br/>

<div class="merci">Cette page est issue de la documentation 'pré-wiki' de Léa a été convertie avec HTML::WikiConverter. Elle fut créée par Jiel Beaumadier le 12/02/2005.</div>

{{Copy|12/02/2005|[[Utilisateur:Jiel|Jiel Beaumadier]]|FDL}}