Programmation : Notions sur le langage ADA

Le langage ADA est un langage à part parmi tous les dialectes informatiques. Défini comme la réponse à un appel d’offre du ministère américain à la défense (DoD), norme ISO, il présente une richesse fonctionnelle étonnante (ceci dès sa première version en 1983) tout en mettant en oeuvre des mécanismes stricts garantissant la conformité des programmes à l’exécution. Aujourd’hui ce langage peu mis en avant est utilisé dans l’industrie aéronautique et de défense dans le monde entier. Le nom du langage fut choisi en hommage à Lady Ada Byron, comtesse de Lovelace, assistante de Babbage et considérée comme le premier programmeur de l’histoire.

Structure d’un programme

La base syntaxique d’ADA est le langage Pascal. Rien d’original en la matière donc. Le langage distingue procédures et fonctions comme il se doit et toute procédure peut être choisie pour sous-programme principal (en C il s’agit de main).

— mon premier programme ada
— hello world !
with text_io; use text_io;
procedure exemple1 is
begin
  put(« hello world! »);
end;

Par défaut et contrairement aux langages fondés sur C, les arguments de la ligne de commande ne sont pas associés au sous-programme principal. Il convient pour en disposer de faire appel à une bibliothèque spécifique. Ce fonctionnement est compréhensible pour un langage dont la vocation est le plus souvent de réaliser des systèmes embarqués.

Sous-programmes

Concernant les sous-programme en général, ADA propose un mécanisme de passage des paramètres indépendant du compilateur. Traditionnellement c’est au contraire au développeur de choisir entre passage par copie ou par référence. Le langage ADA offre une approche différente en proposant de choisir entre un mode en lecture seul, un mode en écriture seule, ou un mode mixte. La réalité du mode de passage choisi incombant au seul compilateur, probablement mieux à même de déterminer pour une architecture donnée la solution la plus efficace.

— définition d’une procédure et d’une fonction —
with Ada.text_io; procedure Exemple2 ; is
  Package int_io is new Ada.Text_Io.integer_io(Integer); use
Int_Io; — idem
  value : integer;
  procedure Bar(a: in integer) is
   i: integer := 1;
  begin
   i := 4;
  end Bar;
  function Foo(B: in Integer) return integer is
   I: integer := 3;
  begin
   return i;
  end Foo;
begin
  bar(Value);
  Value := foo(4);
  put(« hello world! »); new_line;
  put(value); new_line;
end;

Il faut noter que les fonctions n’acceptent que des paramètres en lecture seule. Ceci afin de limiter les effets de bord. Enfin, en ADA, toutes les procédures et fonctions sont surchargeables, sous réserve d’avoir des signatures (prototypes) différentes, valeurs par défaut exclues.

with ada.text_io;
procedure exemple3 is
  package int_io is new ada.text_io.integer_io(integer);
  procedure foo(i : integer) is
  begin
      int_io.put(i);
  end foo;
  procedure foo(i : integer; j: integer) is
  begin
      int_io.put(i);
      ada.text_io.put(« , »);
      int_io.put(j);
      ada.text_io.new_line;
  end;
begin
  foo(3,4);
end exemple3;

Le langage ADA prend parfois à contrepied certaines bonnes vieilles habitudes, en matière de syntaxe comme de contraintes.

Utilisation d’attributs

Il s’agit d’un des éléments probablement parmi les plus perturbants à première vue. ADA définit un ensemble d’attributs, qui appliqués à des données ou des types, vont permettre d’obtenir des informations souvent élémentaires ou intimement liées à la donnée.

L’appel à ces attributs, on parle de qualification, se fait au moyen du caractère « ‘ » (apostrophe ou quote). Ainsi sur un type de données on pourra obtenir la borne inférieure, la précision maximale.

Pour les objets il sera possible d’obtenir la classe ou le type. Sur un tableau les différents indexes. En réalité ses attributs sont tous simples, il suffit de les imaginer comme de simples méthodes appelées non pas avec la notation pointée habituelle mais avec la quote.

— un exemple de type enuméré, avec utilisation de la qualification with Ada.text_io;
use Ada.text_io;
procedure exemple4 is
      type couleur is ( blanc, bleu, jaune, rouge, vert, orange);
      package couleur_io is new ada.Text_io.enumeration_io(couleur);
      use couleur_io;
      c : couleur := bleu;
begin
      put(c); new_line;
      put(Couleur’pred(C)); New_line;
end exemple4;

Les tableaux : intervalles et agrégats

Contrairement au langage C, un tableau peut être indexé par tout intervalle d’un type discret, cela inclut donc les types énumérés, les entiers, et les types dérivés. Les bornes de l’intervalle sont librement fixables. Enfin il est possible d’utiliser la notion d’agrégat (un équivalent à { … } en C) pour initialiser un tableau en une seule fois.

En ADA l’agrégat est donné entre parenthèses, on peut initialiser les valeurs par position, par nom (notamment pour les index de types énumérés), enfin la clause others permet de donner une valeur par défaut à tous les éléments non encore initialisés du tableau.

with ada.text_io;
procedure exemple5 is
      type couleur is ( bleu, rouge, vert, jaune , blanc );
      package int_io is new ada.text_io.integer_io(integer);
    t1 : array (rouge..blanc) of integer;
    type mytab is array (couleur’range) of integer;
    t2 : mytab;
    procedure put(a : mytab) is
    begin
      ada.text_io.put (« (« );
      for c in a’range loop
      int_io.put(a(c));
      if c /= a’last then
      ada.text_io.put(« , « );
    end if;
    end loop;
    ada.text_io.put(« ) »);
    end put;
begin
    t2 := ( bleu | vert => 5, others => 3 );
    put(t2);
end exemple5
error: Contenu protégé