Ada (langage de programmation) - Ada (programming language)

Ada
Paradigme Multi-paradigme : structuré , impératif , orienté objet
Famille Pascal
Conçu par
  • MIL-STD-1815, Ada 83 : Jean Ichbiah
  • Ada 95 : Tucker Taft
  • Ada 2005 : Tucker Taft
  • Ada 2012 : Tucker Taft
Première apparition février 1980 ; il y a 41 ans ( 1980-02 )
Version stable
Ada 2012 TC1
Discipline de frappe statique , fort , sûr , nominatif
Système d'exploitation Multi ou multiplateforme
Extensions de nom de fichier .adb, .ads
Site Internet www .adaic .org
Les principales mises en œuvre
AdaCore GNAT (téléchargement gratuit : https://www.adacore.com/download ), compilateur
Green Hills Software Optimizing Ada 95,
PTC, Inc. PTC ApexAda et PTC ObjectAda,
"MapuSoft Ada-C/C++ changer" ., anciennement connu sous le nom "AdaMagic with C Intermediate", Score
DDC-I
Dialectes
SPARK , profil Ravenscar
Influencé par
ALGOL 68 , Pascal , Simula 67 , C++ (Ada 95), Smalltalk (Ada 95), Modula-2 (Ada 95) Java (Ada 2005), Eiffel (Ada 2012)
Influencé
C++ , Chapel , Drago , D , Eiffel , Griffin, Java , Nim , ParaSail , PL/SQL , PL/pgSQL , Python , Ruby , Seed7 , SPARforte, Sparkel , SQL/PSM , VHDL

Ada est un langage de programmation de haut niveau structuré , statiquement typé , impératif et orienté objet , étendu de Pascal et d'autres langages. Il prend en charge le langage intégré pour la conception par contrat (DbC), le typage extrêmement fort , la concurrence explicite, les tâches, la transmission de messages synchrone, les objets protégés et le non-déterminisme . Ada améliore la sécurité et la maintenabilité du code en utilisant le compilateur pour trouver les erreurs en faveur des erreurs d' exécution . Ada est une norme technique internationale , définie conjointement par l' Organisation internationale de normalisation (ISO) et la Commission électrotechnique internationale (CEI). À partir de 2020, la norme, appelée de manière informelle Ada 2012, est ISO/IEC 8652:2012.

Ada a été conçu à l'origine par une équipe dirigée par l' informaticien français Jean Ichbiah de CII Honeywell Bull sous contrat avec le département américain de la Défense (DoD) de 1977 à 1983 pour remplacer plus de 450 langages de programmation utilisés par le DoD à cette époque. Ada a été nommé d'après Ada Lovelace (1815-1852), qui a été crédité comme le premier programmeur informatique.

Caractéristiques

Ada a été initialement conçu pour les systèmes embarqués et temps réel. La révision Ada 95, conçue par S. Tucker Taft d' Intermetrics entre 1992 et 1995, a amélioré la prise en charge des systèmes, de la programmation numérique, financière et orientée objet (OOP).

Les fonctionnalités d'Ada incluent : un typage fort , des mécanismes de programmation modulaires ( packages ), une vérification à l'exécution , un traitement parallèle ( tâches , transmission synchrone de messages , objets protégés et instructions select non déterministes ), gestion des exceptions et génériques . Ada 95 a ajouté la prise en charge de la programmation orientée objet , y compris la répartition dynamique .

La syntaxe d'Ada minimise les choix de manières d'effectuer les opérations de base et préfère les mots-clés anglais (tels que "or else" et "and then") aux symboles (tels que "||" et "&&"). Ada utilise les opérateurs arithmétiques de base "+", "-", "*" et "/", mais évite d'utiliser d'autres symboles. Les blocs de code sont délimités par des mots tels que "declare", "begin" et "end", où le "end" (dans la plupart des cas) est suivi de l'identifiant du bloc qu'il ferme (par exemple, si ... fin si , boucle ... fin de boucle ). Dans le cas des blocs conditionnels, cela évite un else pendant qui pourrait s'apparier avec la mauvaise expression if imbriquée dans d'autres langages comme C ou Java.

Ada est conçu pour développer de très grands systèmes logiciels. Les packages Ada peuvent être compilés séparément. Les spécifications du package Ada (l'interface du package) peuvent également être compilées séparément sans implémentation pour vérifier la cohérence. Cela permet de détecter les problèmes dès la phase de conception, avant le début de la mise en œuvre.

Un grand nombre de vérifications à la compilation sont prises en charge pour aider à éviter les bogues qui ne seraient pas détectables avant l'exécution dans certains autres langages ou qui nécessiteraient l'ajout de vérifications explicites au code source. Par exemple, la syntaxe nécessite une fermeture de blocs explicitement nommée pour éviter les erreurs dues à des jetons de fin non concordants. Le respect du typage fort permet de détecter de nombreuses erreurs logicielles courantes (paramètres erronés, violations de plage, références invalides, types incompatibles, etc.) soit pendant la compilation, soit pendant l'exécution. Comme la concurrence fait partie de la spécification du langage, le compilateur peut dans certains cas détecter des blocages potentiels. Les compilateurs vérifient également couramment les identifiants mal orthographiés, la visibilité des packages, les déclarations redondantes, etc. et peuvent fournir des avertissements et des suggestions utiles sur la façon de corriger l'erreur.

Ada prend également en charge les vérifications à l'exécution pour se protéger contre l'accès à la mémoire non allouée, les erreurs de dépassement de mémoire tampon , les violations de plage, les erreurs off-by-one , les erreurs d'accès au tableau et d'autres bogues détectables. Ces contrôles peuvent être désactivés dans l'intérêt de l'efficacité de l'exécution, mais peuvent souvent être compilés efficacement. Il comprend également des installations pour aider à la vérification du programme . Pour ces raisons, Ada est largement utilisé dans les systèmes critiques, où toute anomalie peut entraîner des conséquences très graves, par exemple, la mort accidentelle, des blessures ou de graves pertes financières. Des exemples de systèmes où Ada est utilisé comprennent l' avionique , le contrôle du trafic aérien , les chemins de fer, les banques, la technologie militaire et spatiale.

La gestion dynamique de la mémoire d' Ada est de haut niveau et de type sécurisé. Ada n'a pas de pointeurs génériques ou non typés ; il ne déclare pas non plus implicitement un type de pointeur. Au lieu de cela, toutes les allocations et désallocations dynamiques de mémoire doivent se produire via des types d'accès explicitement déclarés . Chaque type d'accès a un pool de stockage associé qui gère les détails de bas niveau de la gestion de la mémoire ; le programmeur peut soit utiliser le pool de stockage par défaut, soit en définir de nouveaux (ceci est particulièrement pertinent pour l' accès mémoire non uniforme ). Il est même possible de déclarer plusieurs types d'accès différents qui désignent tous le même type mais utilisent des pools de stockage différents. En outre, le langage fournit des contrôles d'accessibilité , à la fois au moment de la compilation et au moment de l'exécution, qui garantissent qu'une valeur d'accès ne peut pas survivre au type de l'objet vers lequel elle pointe.

Bien que la sémantique du langage autorise le ramasse-miettes automatique des objets inaccessibles, la plupart des implémentations ne le prennent pas en charge par défaut, car cela entraînerait un comportement imprévisible dans les systèmes temps réel. Ada prend en charge une forme limitée de gestion de la mémoire basée sur les régions ; en outre, l'utilisation créative des pools de stockage peut fournir une forme limitée de récupération automatique de la mémoire, car la destruction d'un pool de stockage détruit également tous les objets du pool.

Un double tiret ("--"), ressemblant à un tiret cadratin , indique le texte du commentaire. Les commentaires s'arrêtent à la fin de la ligne, pour empêcher les commentaires non fermés d'annuler accidentellement des sections entières du code source. La désactivation d'un bloc entier de code nécessite désormais le préfixe de chaque ligne (ou colonne) individuellement avec "--". Tout en désignant clairement le code désactivé avec une colonne de "--" répétés en bas de la page, cela rend la désactivation/réactivation expérimentale de gros blocs un processus plus long.

Le point-virgule (";") est un terminateur d'instruction et l' instruction null ou no-operation est null;. Un single ;sans instruction pour terminer n'est pas autorisé.

Contrairement à la plupart des normes ISO , la définition du langage Ada (appelée Ada Reference Manual ou ARM , ou parfois Language Reference Manual ou LRM ) est un contenu gratuit . Ainsi, c'est une référence commune pour les programmeurs Ada, pas seulement pour les programmeurs implémentant des compilateurs Ada. Outre le manuel de référence, il existe également un document de justification détaillé qui explique la conception du langage et l'utilisation de diverses constructions linguistiques. Ce document est également largement utilisé par les programmeurs. Lorsque le langage a été révisé, un nouveau document de justification a été rédigé.

Un outil logiciel libre notable qui est utilisé par de nombreux programmeurs Ada pour les aider à écrire le code source Ada est le GNAT Programming Studio , qui fait partie de la GNU Compiler Collection .

Histoire

Dans les années 1970, le département américain de la Défense (DoD) s'est inquiété du nombre de langages de programmation différents utilisés pour ses projets de systèmes informatiques embarqués, dont beaucoup étaient obsolètes ou dépendants du matériel, et aucun ne prenait en charge la programmation modulaire sûre. En 1975, un groupe de travail , le High Order Language Working Group (HOLWG), a été formé dans le but de réduire ce nombre en trouvant ou en créant un langage de programmation généralement adapté aux besoins du ministère et du ministère britannique de la Défense . Après de nombreuses itérations commençant par une proposition originale de l' homme de paille, le langage de programmation éventuel a été nommé Ada. Le nombre total de langages de programmation de haut niveau utilisés pour de tels projets est passé de plus de 450 en 1983 à 37 en 1996.

Le groupe de travail HOLWG a élaboré les exigences du langage Steelman , une série de documents énonçant les exigences qu'ils pensaient qu'un langage de programmation devrait satisfaire. De nombreuses langues existantes ont été formellement examinées, mais l'équipe a conclu en 1977 qu'aucune langue existante ne répondait aux spécifications.

Augusta Ada King , comtesse de Lovelace.

Des appels d'offres pour un nouveau langage de programmation ont été lancés et quatre entrepreneurs ont été embauchés pour développer leurs propositions sous les noms de Red ( Intermetrics dirigé par Benjamin Brosgol), Green ( CII Honeywell Bull , dirigé par Jean Ichbiah ), Blue ( SofTech , dirigé par John Goodenough) et Yellow ( SRI International , dirigé par Jay Spitzen). En avril 1978, après examen public, les propositions Rouge et Vert passèrent à la phase suivante. En mai 1979, la proposition Green, conçue par Jean Ichbiah au CII Honeywell Bull, a été choisie et a reçu le nom d'Ada—d'après Augusta Ada, comtesse de Lovelace . Cette proposition a été influencée par le langage LIS qu'Ichbiah et son groupe avaient développé dans les années 1970. Le manuel de référence préliminaire Ada a été publié dans ACM SIGPLAN Notices en juin 1979. Le manuel de référence Military Standard a été approuvé le 10 décembre 1980 ( anniversaire d' Ada Lovelace ) et a reçu le numéro MIL-STD-1815 en l'honneur de la naissance d'Ada Lovelace. année. En 1981, CAR Hoare a profité de son discours du prix Turing pour critiquer Ada pour sa complexité excessive et donc son manque de fiabilité, mais a par la suite semblé se rétracter dans l'avant-propos qu'il a écrit pour un manuel Ada.

Ada a attiré beaucoup d'attention de la communauté de programmation dans son ensemble à ses débuts. Ses partisans et d'autres ont prédit qu'il pourrait devenir un langage dominant pour la programmation à usage général et pas seulement pour les travaux liés à la défense. Ichbiah a déclaré publiquement que d'ici dix ans, il ne resterait que deux langages de programmation : Ada et Lisp . Les premiers compilateurs Ada ont eu du mal à implémenter ce langage volumineux et complexe, et les performances de compilation et d'exécution avaient tendance à être lentes et les outils primitifs. Les fournisseurs de compilateurs ont consacré la plupart de leurs efforts à réussir la suite de validation "ACVC" de test de conformité linguistique massive, requise par le gouvernement, qui était requise dans une autre nouvelle fonctionnalité de l'effort de langage Ada. Le Jargon File , un dictionnaire d'argot des pirates informatiques originaire de 1975-1983, note dans une entrée sur Ada que "c'est précisément ce à quoi on pourrait s'attendre étant donné ce genre d'approbation par décret; conçu par un comité ... difficile à utiliser, et dans l'ensemble, un cafouillage désastreux de plusieurs milliards de dollars... Ada Lovelace... blanchirait presque certainement à l'usage auquel son nom a été récemment fait ; la chose la plus gentille qui a été dite à ce sujet est qu'il y a probablement un bon petit langage criant pour sortir de sa masse immense et éléphantesque."

La première implémentation Ada validée était le traducteur NYU Ada/Ed, certifié le 11 avril 1983. NYU Ada/Ed est implémenté dans le langage de jeu de haut niveau SETL . Plusieurs sociétés commerciales ont commencé à proposer des compilateurs Ada et des outils de développement associés, notamment Alsys , TeleSoft , DDC-I , Advanced Computer Techniques , Tartan Laboratories , TLD Systems et Verdix .

En 1991, le département américain de la Défense a commencé à exiger l'utilisation d'Ada (le mandat Ada ) pour tous les logiciels, bien que des exceptions à cette règle aient souvent été accordées. Le mandat Ada du ministère de la Défense a été effectivement supprimé en 1997, lorsque le DoD a commencé à adopter la technologie commerciale sur étagère ( COTS ). Des exigences similaires existaient dans d'autres pays de l' OTAN : Ada était requis pour les systèmes de l'OTAN impliquant le commandement et le contrôle et d'autres fonctions, et Ada était la langue obligatoire ou préférée pour les applications liées à la défense dans des pays comme la Suède, l'Allemagne et le Canada.

À la fin des années 1980 et au début des années 1990, les performances des compilateurs Ada s'étaient améliorées, mais il existait encore des obstacles à l'exploitation complète des capacités d'Ada, notamment un modèle de tâches différent de celui auquel la plupart des programmeurs en temps réel étaient habitués.

En raison des fonctionnalités de support critiques pour la sécurité d'Ada , il est désormais utilisé non seulement pour des applications militaires, mais également dans des projets commerciaux où un bogue logiciel peut avoir de graves conséquences, par exemple, l' avionique et le contrôle du trafic aérien , les fusées commerciales telles que les Ariane 4 et 5 , satellites et autres systèmes spatiaux, transport ferroviaire et banque. Par exemple, l' Airplane Information Management System , le logiciel du système de pilotage électrique du Boeing 777 , a été écrit en Ada. Développé par Honeywell Air Transport Systems en collaboration avec des consultants de DDC-I , il est sans doute devenu le plus connu de tous les projets Ada, civils ou militaires. Le système canadien automatisé de la circulation aérienne a été écrit en 1 million de lignes d'Ada ( compte SLOC ). Il comportait un traitement distribué avancé , une base de données Ada distribuée et une conception orientée objet. Ada est également utilisé dans d'autres systèmes de trafic aérien, par exemple, le système de contrôle du trafic aérien de prochaine génération Interim Future Area Control Tools Support (iFACTS) du Royaume-Uni est conçu et mis en œuvre à l'aide de SPARK Ada. Il est également utilisé dans le français TVM de signalisation de la cabine du système sur le TGV système ferroviaire à grande vitesse et les trains de banlieue de métro à Paris, Londres, Hong Kong et New York.

Standardisation

La langue est devenue une norme ANSI en 1983 ( ANSI/MIL-STD 1815A ), et après traduction en français et sans autre modification en anglais est devenue une norme ISO en 1987 (ISO-8652:1987). Cette version du langage est communément appelée Ada 83, à partir de la date de son adoption par l'ANSI, mais est parfois également appelée Ada 87, à partir de la date de son adoption par l'ISO.

Ada 95, la norme commune ISO/ANSI ( ISO-8652:1995 ) a été publiée en février 1995, faisant d'Ada 95 le premier langage de programmation orienté objet de la norme ISO. Pour aider à la révision standard et à l'acceptation future, l' US Air Force a financé le développement du compilateur GNAT . Actuellement, le compilateur GNAT fait partie de la collection de compilateurs GNU .

Les travaux se sont poursuivis pour améliorer et mettre à jour le contenu technique du langage Ada. Un rectificatif technique à l'Ada 95 a été publié en octobre 2001, et un amendement majeur, ISO/IEC 8652:1995/Amd 1:2007 a été publié le 9 mars 2007. Lors de la conférence Ada-Europe 2012 à Stockholm, l'Ada Resource Association (ARA) et Ada-Europe ont annoncé l'achèvement de la conception de la dernière version du langage Ada et la soumission du manuel de référence à l'Organisation internationale de normalisation (ISO) pour approbation. ISO/IEC 8652:2012 a été publiée en décembre 2012.

D'autres normes connexes incluent ISO 8651 -3:1988 Systèmes de traitement de l'information—Infographie—Liaisons de langage GKS (Graphical Kernel System)—Partie 3 : Ada .

Constructions linguistiques

Ada est un langage de programmation de type ALGOL comportant des structures de contrôle avec des mots réservés tels que if , then , else , while , for , et ainsi de suite. Cependant, Ada dispose également de nombreuses fonctionnalités de structuration des données et d'autres abstractions qui n'étaient pas incluses dans l' ALGOL 60 d'origine , telles que les définitions de type , les enregistrements , les pointeurs et les énumérations . De telles constructions ont été en partie héritées ou inspirées de Pascal .

"Bonjour le monde!" à Ada

Un exemple courant de la syntaxe d'un langage est le programme Hello world : (hello.adb)

with Ada.Text_IO; use Ada.Text_IO;
procedure Hello is
begin
   Put_Line ("Hello, world!");
end Hello;

Ce programme peut être compilé en utilisant le compilateur open source disponible gratuitement GNAT , en exécutant

gnatmake hello.adb

Types de données

Le système de types d'Ada n'est pas basé sur un ensemble de types primitifs prédéfinis mais permet aux utilisateurs de déclarer leurs propres types. Cette déclaration à son tour n'est pas basée sur la représentation interne du type mais sur la description du but à atteindre. Cela permet au compilateur de déterminer une taille de mémoire appropriée pour le type et de vérifier les violations de la définition de type au moment de la compilation et de l'exécution (c'est-à-dire des violations de plage, des dépassements de mémoire tampon, la cohérence du type, etc.). Ada prend en charge les types numériques définis par une plage, les types modulo, les types d'agrégats (enregistrements et tableaux) et les types d'énumération. Les types d'accès définissent une référence à une instance d'un type spécifié ; les pointeurs non typés ne sont pas autorisés. Les types spéciaux fournis par le langage sont les types de tâches et les types protégés.

Par exemple, une date peut être représentée par :

type Day_type   is range    1 ..   31;
type Month_type is range    1 ..   12;
type Year_type  is range 1800 .. 2100;
type Hours is mod 24;
type Weekday is (Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday);

type Date is
   record
     Day   : Day_type;
     Month : Month_type;
     Year  : Year_type;
   end record;

Les types peuvent être affinés en déclarant des sous - types :

subtype Working_Hours is Hours range 0 .. 12;            -- at most 12 Hours to work a day
subtype Working_Day is Weekday range Monday .. Friday;   -- Days to work

Work_Load: constant array(Working_Day) of Working_Hours  -- implicit type declaration
   := (Friday => 6, Monday => 4, others => 10);           -- lookup table for working hours with initialization

Les types peuvent avoir des modificateurs tels que limited, abstract, private, etc. Les types privés sont uniquement accessibles et les types limités ne peuvent être modifiés ou copiés que dans le cadre du package qui les définit. Ada 95 ajoute des fonctionnalités supplémentaires pour l'extension orientée objet des types.

Structures de contrôle

Ada est un langage de programmation structuré , ce qui signifie que le flux de contrôle est structuré en instructions standard. Toutes les constructions standard et la sortie anticipée de niveau profond sont prises en charge, de sorte que l'utilisation des commandes " go to " également prises en charge est rarement nécessaire.

-- while a is not equal to b, loop.
while a /= b loop
  Ada.Text_IO.Put_Line ("Waiting");
end loop;

if a > b then
  Ada.Text_IO.Put_Line ("Condition met");
else
  Ada.Text_IO.Put_Line ("Condition not met");
end if;

for i in 1 .. 10 loop
  Ada.Text_IO.Put ("Iteration: ");
  Ada.Text_IO.Put (i);
  Ada.Text_IO.Put_Line;
end loop;

loop
  a := a + 1;
  exit when a = 10;
end loop;

case i is
  when 0 => Ada.Text_IO.Put ("zero");
  when 1 => Ada.Text_IO.Put ("one");
  when 2 => Ada.Text_IO.Put ("two");
  -- case statements have to cover all possible cases:
  when others => Ada.Text_IO.Put ("none of the above");
end case;

for aWeekday in Weekday'Range loop               -- loop over an enumeration
   Put_Line ( Weekday'Image(aWeekday) );         -- output string representation of an enumeration
   if aWeekday in Working_Day then               -- check of a subtype of an enumeration
      Put_Line ( " to work for " &
               Working_Hours'Image (Work_Load(aWeekday)) ); -- access into a lookup table
   end if;
end loop;

Packages, procédures et fonctions

Parmi les parties d'un programme Ada se trouvent des packages, des procédures et des fonctions.

Exemple : Spécification du package (example.ads)

package Example is
     type Number is range 1 .. 11;
     procedure Print_and_Increment (j: in out Number);
end Example;

Corps du package (exemple.adb)

with Ada.Text_IO;
package body Example is

  i : Number := Number'First;

  procedure Print_and_Increment (j: in out Number) is

    function Next (k: in Number) return Number is
    begin
      return k + 1;
    end Next;

  begin
    Ada.Text_IO.Put_Line ( "The total is: " & Number'Image(j) );
    j := Next (j);
  end Print_and_Increment;

-- package initialization executed when the package is elaborated
begin
  while i < Number'Last loop
    Print_and_Increment (i);
  end loop;
end Example;

Ce programme peut être compilé, par exemple, en utilisant le compilateur open-source disponible gratuitement GNAT , en exécutant

gnatmake -z example.adb

Les packages, les procédures et les fonctions peuvent s'imbriquer à n'importe quelle profondeur, et chacun peut également être le bloc logique le plus externe.

Chaque package, procédure ou fonction peut avoir ses propres déclarations de constantes, types, variables et autres procédures, fonctions et packages, qui peuvent être déclarés dans n'importe quel ordre.

Concurrence

Ada prend en charge la langue pour la concurrence basée sur les tâches. L'unité concurrente fondamentale dans Ada est une tâche , qui est un type limité intégré. Les tâches sont spécifiées en deux parties : la déclaration de tâche définit l'interface de la tâche (similaire à une déclaration de type), le corps de la tâche spécifie la mise en œuvre de la tâche. Selon l'implémentation, les tâches Ada sont soit mappées aux threads ou aux processus du système d'exploitation, soit planifiées en interne par le runtime Ada.

Les tâches peuvent avoir des entrées pour la synchronisation (une forme de transmission de message synchrone ). Les entrées de tâche sont déclarées dans la spécification de tâche. Chaque entrée de tâche peut avoir une ou plusieurs instructions d' acceptation dans le corps de la tâche. Si le flux de contrôle de la tâche atteint une instruction accept, la tâche est bloquée jusqu'à ce que l'entrée correspondante soit appelée par une autre tâche (de même, une tâche appelante est bloquée jusqu'à ce que la tâche appelée atteigne l'instruction accept correspondante). Les entrées de tâche peuvent avoir des paramètres similaires aux procédures, permettant aux tâches d'échanger des données de manière synchrone. En conjonction avec les instructions select , il est possible de définir des gardes sur les instructions accept (similaire aux commandes gardées de Dijkstra ).

Ada propose également des objets protégés pour l'exclusion mutuelle . Les objets protégés sont une construction de type moniteur , mais utilisent des gardes au lieu de variables conditionnelles pour la signalisation (similaire aux régions critiques conditionnelles). Les objets protégés combinent l'encapsulation des données et l'exclusion mutuelle sûre des moniteurs, ainsi que les gardes d'entrée des régions critiques conditionnelles. Le principal avantage par rapport aux moniteurs classiques est que les variables conditionnelles ne sont pas nécessaires pour la signalisation, évitant ainsi les blocages potentiels dus à une sémantique de verrouillage incorrecte. Comme les tâches, l'objet protégé est un type limité intégré, et il a également une partie déclaration et un corps.

Un objet protégé se compose de données privées encapsulées (qui ne sont accessibles qu'à partir de l'objet protégé) et de procédures, fonctions et entrées qui sont garanties mutuellement exclusives (à la seule exception des fonctions, qui doivent être exemptes d'effets secondaires et peut donc fonctionner en parallèle avec d'autres fonctions). Une tâche appelant un objet protégé est bloquée si une autre tâche est en cours d'exécution à l'intérieur du même objet protégé, et libérée lorsque cette autre tâche quitte l'objet protégé. Les tâches bloquées sont mises en file d'attente sur l'objet protégé classées par heure d'arrivée.

Les entrées d'objet protégé sont similaires aux procédures, mais ont en plus des gardes . Si une garde est évaluée à faux, une tâche appelante est bloquée et ajoutée à la file d'attente de cette entrée ; maintenant une autre tâche peut être admise dans l'objet protégé, car aucune tâche n'est actuellement en cours d'exécution à l'intérieur de l'objet protégé. Les gardes sont réévalués chaque fois qu'une tâche quitte l'objet protégé, car c'est le seul moment où l'évaluation des gardes peut avoir changé.

Les appels aux entrées peuvent être remis en file d' attente vers d'autres entrées avec la même signature. Une tâche remise en file d'attente est bloquée et ajoutée à la file d'attente de l'entrée cible ; cela signifie que l'objet protégé est libéré et permet l'admission d'une autre tâche.

L' instruction select dans Ada peut être utilisée pour implémenter des appels et des acceptations d'entrée non bloquants, une sélection non déterministe d'entrées (également avec des gardes), des délais d'attente et des abandons.

L'exemple suivant illustre certains concepts de programmation concurrente dans Ada.

with Ada.Text_IO; use Ada.Text_IO;

procedure Traffic is

   type Airplane_ID is range 1..10;             -- 10 airplanes

   task type Airplane (ID: Airplane_ID);        -- task representing airplanes, with ID as initialisation parameter
   type Airplane_Access is access Airplane;     -- reference type to Airplane

   protected type Runway is                     -- the shared runway (protected to allow concurrent access)
      entry Assign_Aircraft (ID: Airplane_ID);  -- all entries are guaranteed mutually exclusive
      entry Cleared_Runway (ID: Airplane_ID);
      entry Wait_For_Clear;
   private
      Clear: Boolean := True;                   -- protected private data - generally more than only a flag...
   end Runway;
   type Runway_Access is access all Runway;

   -- the air traffic controller task takes requests for takeoff and landing
   task type Controller (My_Runway: Runway_Access) is
      -- task entries for synchronous message passing
      entry Request_Takeoff (ID: in Airplane_ID; Takeoff: out Runway_Access);
      entry Request_Approach(ID: in Airplane_ID; Approach: out Runway_Access);
   end Controller;

   --  allocation of instances
   Runway1    : aliased Runway;              -- instantiate a runway
   Controller1: Controller (Runway1'Access); -- and a controller to manage it

   ------ the implementations of the above types ------
   protected body Runway is
      entry Assign_Aircraft (ID: Airplane_ID)
 when Clear is   -- the entry guard - calling tasks are blocked until the condition is true
      begin
       Clear := False;
       Put_Line (Airplane_ID'Image (ID) & " on runway ");
      end;

      entry Cleared_Runway (ID: Airplane_ID)
 when not Clear is
      begin
         Clear := True;
         Put_Line (Airplane_ID'Image (ID) & " cleared runway ");
      end;

      entry Wait_For_Clear
 when Clear is
      begin
         null;      -- no need to do anything here - a task can only enter if "Clear" is true
      end;
   end Runway;

   task body Controller is
   begin
      loop
         My_Runway.Wait_For_Clear;   -- wait until runway is available (blocking call)
         select                      -- wait for two types of requests (whichever is runnable first)
            when Request_Approach'count = 0 =>  -- guard statement - only accept if there are no tasks queuing on Request_Approach
             accept Request_Takeoff (ID: in Airplane_ID; Takeoff: out Runway_Access)
             do                                 -- start of synchronized part
               My_Runway.Assign_Aircraft (ID);  -- reserve runway (potentially blocking call if protected object busy or entry guard false)
               Takeoff := My_Runway;            -- assign "out" parameter value to tell airplane which runway
             end Request_Takeoff;               -- end of the synchronised part
         or
            accept Request_Approach (ID: in Airplane_ID; Approach: out Runway_Access) do
               My_Runway.Assign_Aircraft (ID);
               Approach := My_Runway;
            end Request_Approach;
         or                          -- terminate if no tasks left who could call
            terminate;
         end select;
      end loop;
   end;

   task body Airplane is
      Rwy : Runway_Access;
   begin
      Controller1.Request_Takeoff (ID, Rwy); -- This call blocks until Controller task accepts and completes the accept block
      Put_Line (Airplane_ID'Image (ID) & "  taking off...");
      delay 2.0;
      Rwy.Cleared_Runway (ID);               -- call will not block as "Clear" in Rwy is now false and no other tasks should be inside protected object
      delay 5.0; -- fly around a bit...
      loop
         select   -- try to request a runway
            Controller1.Request_Approach (ID, Rwy); -- this is a blocking call - will run on controller reaching accept block and return on completion
            exit; -- if call returned we're clear for landing - leave select block and proceed...
         or
            delay 3.0;  -- timeout - if no answer in 3 seconds, do something else (everything in following block)
            Put_Line (Airplane_ID'Image (ID) & "   in holding pattern");  -- simply print a message
         end select;
      end loop;
      delay 4.0;  -- do landing approach...
      Put_Line (Airplane_ID'Image (ID) & "            touched down!");
      Rwy.Cleared_Runway (ID);  -- notify runway that we're done here.
   end;

   New_Airplane: Airplane_Access;

begin
   for I in Airplane_ID'Range loop  -- create a few airplane tasks
      New_Airplane := new Airplane (I); -- will start running directly after creation
      delay 4.0;
   end loop;
end Traffic;

Pragmas

Un pragma est une directive de compilateur qui transmet des informations au compilateur pour permettre une manipulation spécifique de la sortie compilée. Certains pragmas sont intégrés au langage, tandis que d'autres sont spécifiques à l'implémentation.

Des exemples d'utilisation courante des pragmas du compilateur seraient de désactiver certaines fonctionnalités, telles que la vérification du type à l'exécution ou la vérification des limites des indices de tableau, ou de demander au compilateur d'insérer du code objet au lieu d'un appel de fonction (comme C/C++ le fait avec les fonctions en ligne ).

Génériques

Ada a eu des génériques depuis qu'il a été conçu pour la première fois en 1977-1980. La bibliothèque standard utilise des génériques pour fournir de nombreux services. Ada 2005 ajoute une bibliothèque de conteneurs génériques complète à la bibliothèque standard, inspirée de la bibliothèque de modèles standard de C++ .

Une unité générique est un package ou un sous-programme qui prend un ou plusieurs paramètres formels génériques .

Un paramètre formel générique est une valeur, une variable, une constante, un type, un sous-programme ou même une instance d'une autre unité générique désignée. Pour les types formels génériques, la syntaxe fait la distinction entre les types discrets, à virgule flottante, à virgule fixe, d'accès (pointeur), etc. Certains paramètres formels peuvent avoir des valeurs par défaut.

Pour instancier une unité générique, le programmeur passe des paramètres réels pour chaque formel. L'instance générique se comporte alors comme n'importe quelle autre unité. Il est possible d'instancier des unités génériques au moment de l' exécution , par exemple à l'intérieur d'une boucle.

Voir également

  • APSE - une spécification pour un environnement de programmation pour prendre en charge le développement de logiciels dans Ada
  • Profil Ravenscar - un sous-ensemble des fonctionnalités de tâches Ada conçues pour le calcul en temps réel dur critique pour la sécurité
  • SPARK (langage de programmation) - un langage de programmation composé d'un sous-ensemble très restreint d'Ada, annoté avec des méta-informations décrivant le comportement souhaité des composants et les exigences d'exécution individuelles

Les références

Normes internationales

Raisonnement

Ces documents ont été publiés sous diverses formes, y compris sur papier.

Livres

  • Booch, Grady (1987). Génie logiciel avec Ada . Californie : The Benjamin/Cummings Publishing Company. ISBN 0-8053-0604-8.
  • Skansholm, Jan (1996). Ada 95 depuis le début . Addison-Wesley. ISBN 0-201-40376-5.
  • Gilpin, Geoff (1985). Ada : Une visite guidée et un didacticiel . Prentice Hall. ISBN 978-0-13-004045-9.
  • Barnes, John (2006). Programmation en Ada 2005 . Addison-Wesley. ISBN 0-321-34078-7.
  • Barnes, John (1991). Programmation en langage Ada plus Manuel de référence . Addison-Wesley. ISBN 0-201-56539-0.
  • Barnes, John (1998). Programmation en Ada 95 . Addison-Wesley. ISBN 0-201-34293-6.
  • Barnes, John (1997). Ada à haute intégrité : l'approche SPARK . Addison-Wesley. ISBN 0-201-17517-7.
  • Barnes, John (2003). Logiciel à haute intégrité : l'approche SPARK de la sûreté et de la sécurité . Addison-Wesley. ISBN 0-321-13616-0.
  • Beidler, John (1997). Structures de données et algorithmes : une approche orientée objet utilisant Ada 95 . Springer-Verlag. ISBN 0-387-94834-1.
  • Gonzalez, Dean W. (1991). Manuel du programmeur Ada . Maison d'édition Benjamin Cummings. ISBN 0-8053-2529-8.
  • Ben-Ari, M. (1998). Ada pour les ingénieurs logiciels . John Wiley & Fils. ISBN 0-471-97912-0.
  • Cohen, Normand (1996). Ada comme langue seconde . McGraw-Hill Science/Ingénierie/Math. ISBN 0-07-011607-5.
  • Burns, Alain ; Welling, Andy (2001). Systèmes temps réel et langages de programmation. Ada 95, Java temps réel et POSIX temps réel . Addison-Wesley. ISBN 0-201-72988-1.
  • Burns, Alain ; Welling, Andy (1995). Concurrence dans Ada . La presse de l'Universite de Cambridge. ISBN 0-521-62911-X.
  • Atkinson, Colin (1991). Réutilisation, concurrence et distribution orientées objet : une approche basée sur Ada . Addison-Wesley. ISBN 0-201-56527-7.
  • Booch, Grady ; Bryan, Doug (1994). Génie logiciel avec Ada . Addison-Wesley. ISBN 0-8053-0608-0.
  • Jones, Do-While (1989). Ada en action : avec des exemples de programmation pratiques . John Wiley & Fils. ISBN 0-471-60708-8.
  • Stubbs, Daniel; Webre, Neil W. (1993). Structures de données avec types de données abstraits et Ada . Brooks Cole. ISBN 0-534-14448-9.
  • Ledru, Pascal (décembre 1998). Programmation distribuée dans Ada avec des objets protégés . Dissertation.com. ISBN 1-58112-034-6.
  • Culwin, Fintan (1997). Ada, une approche développementale . Prentice Hall. ISBN 0-13-264680-3.
  • anglais, John ; Culwin, Fintan (janvier 1997). Ada 95 l'art de la programmation orientée objet . Prentice Hall. ISBN 0-13-230350-7.
  • Musser, David R.; Stepanov, Alexandre (24 octobre 1989). La bibliothèque générique Ada : packages de traitement de liste linéaire . Springer-Verlag. ISBN 0-387-97133-5.
  • Feldman, Michael B. (1997). Construction de logiciels et structures de données avec Ada 95 . Addison-Wesley. ISBN 0-201-88795-9.
  • Johnston, Simon (1997). Ada 95 pour les programmeurs C et C++ . Addison-Wesley. ISBN 0-201-40363-3.
  • Feldman, Michael B. ; Koffman, Elliot B. (1992-1993). Ada : Résolution de problèmes et conception de programmes . Addison-Wesley. ISBN 0-201-52279-9. 795 pages.
  • Feldman, Michael B. ; Koffman, Elliot B. (1999). Ada 95 . Addison-Wesley. ISBN 0-201-36123-X.
  • Dale, Nell B. ; Weems, puce ; McCormick, John (août 1996). Programmation et résolution de problèmes avec Ada 95 . Éditions Jones & Bartlett. ISBN 0-7637-0293-5.
  • Dale, Nell B. ; McCormick, John (2007). Structures de données Ada Plus : une approche orientée objet, 2e édition . Éditions Jones & Bartlett. ISBN 978-0-7637-3794-8.
  • Krell, Bruce C. (1992). Développer avec Ada : méthodes de cycle de vie . Groupe Bantam Dell Pub. ISBN 0-553-09102-6.
  • Bishop, Judy (10 mai 1990). Ada distribué : développements et expériences . La presse de l'Universite de Cambridge. ISBN 0-521-39251-9.
  • Sanden, Bo (1994). Construction de systèmes logiciels avec des exemples dans Ada . Prentice Hall. ISBN 0-13-030834-X.
  • Hillam, Bruce (1994). Introduction aux types de données abstraits à l'aide d'Ada . Prentice Hall. ISBN 0-13-045949-6.
  • Rudd, David (1994). Introduction à la conception et au développement de logiciels avec Ada . Brooks Cole. ISBN 0-314-02829-3.
  • Pyle, Ian C. (1991). Développer des systèmes de sécurité : un guide utilisant Ada . Prentice Hall. ISBN 0-13-204298-3.
  • Boulanger, Louis (1989). Intelligence Artificielle avec Ada . McGraw-Hill. ISBN 0-07-003350-1.
  • Burns, Alain ; Welling, Andy (1995). HRT-HOOD : Une méthode de conception structurée pour les systèmes Ada temps réel durs . Hollande du Nord. ISBN 0-444-82164-3.
  • Savitch, Walter ; Peterson, Charles (1992). Ada : Une introduction à l'art et à la science de la programmation . Maison d'édition Benjamin Cummings. ISBN 0-8053-7070-6.
  • Weiss, Mark Allen (1993). Structures de données et analyse d'algorithmes dans Ada . Maison d'édition Benjamin Cummings. ISBN 0-8053-9055-3.
  • Ledgard, Henri (1983). Ada : Une introduction (deuxième éd.). Springer-Verlag. ISBN 0-387-90814-5.
  • Bjørner, Dines ; Oest, Ole N., éd. (1980). Vers une description formelle d'Ada . Londres : Springer-Verlag. ISBN 3-540-10283-3.

Les archives

  • Matériel de langage de programmation Ada, 1981-1990 . Institut Charles Babbage , Université du Minnesota. Comprend de la documentation sur les produits logiciels conçus pour la langue Ada ; Publications du gouvernement américain, y compris les rapports du projet Ada 9X, les rapports techniques, les documents de travail, les bulletins d'information ; et des informations sur les groupes d'utilisateurs.

Liens externes