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


Un article de Wikipédia, l'encyclopédie libre
Ada
Paradigme Multiparadigme
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 38 ans ( 1980-02 )
Version stable
Ada 2012 TC1 / 1 Février, 2016 ; il y a 2 ans ( 01/02/2016 )
préversion
Ada 2012 TC1 / Avril ici à 2015 ; il y a 3 ans ( 2015-04 )
discipline de frappe statique , forte , sûre , Nominatif
OS Multi-plateforme (multi-plate - forme)
Nom du fichier extensions .adb, .ads
Site Internet www .adaic .org
Les principales mises en œuvre
AdaCore GNAT (téléchargement gratuit: http://libre.adacore.com/download ),
Green Hills Software Optimizing compilateur Ada 95,
PTC, Inc. PTC et PTC ApexAda ObjectAda,
"MapuSoft Ada-C / C ++ changeur" ., Précédemment connu sous le nom "AdaMagic avec C intermédiaire",
DDC-I Score
parlers
SPARK , profil Ravenscar
Influencé par
ALGOL 68 , Pascal , C ++ (Ada 95), Smalltalk (Ada 95), Modula-2 (Ada 95) Java (Ada 2005), Eiffel (Ada 2012)
Influencé
C ++ , chapelle , "Drago" ., Eiffel , "Griffin" ., Java , Nim , PARASAIL , PL / SQL , PL / pgSQL , Ruby , Seed7 , "SPARforte" ., Sparkel , SQL / PSM , VHDL

Ada est un structuré , statiquement typé , impératif et orienté objet de haut niveau ordinateur langage de programmation , étendu de Pascal et d' autres langues. Il a intégré un soutien linguistique pour la conception par contrat , frappe très fort, explicite la simultanéité, les tâches, le passage de messages synchrone, des objets protégés et non-déterminisme . Ada améliore la sécurité et la maintenabilité du code en utilisant le compilateur pour trouver des erreurs en faveur des erreurs d'exécution. Ada est une norme internationale; la version actuelle (connue sous le nom Ada 2012) est défini par la norme ISO / IEC 8652: 2012.

Ada a été conçu par une équipe dirigée par Jean Ichbiah de CII Honeywell Bull sous contrat avec le Département américain de la Défense (DoD) 1977-1983 pour remplacer plus de 450 langages de programmation utilisés par le Département de la défense à ce moment - là. 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é ciblé à embarqués et en temps réel des systèmes. La révision Ada 95, conçu par S. Tucker Taft de Intermetrics entre 1992 et 1995, un support amélioré pour les systèmes, numériques, financiers, et la programmation orientée objet (POO).

Caractéristiques de Ada comprennent: typage fort , des mécanismes de modularité (packages), vérification de la gestion du temps , le traitement parallèle ( tâches , synchrone transmission de messages , objets protégés , et non déterministes instructions select ), la gestion des exceptions et génériques . Ada 95 a ajouté le support pour la programmation orientée objet , y compris l' envoi dynamique .

La syntaxe de Ada minimise les choix de moyens pour effectuer des opérations de base, et préfère les mots clés anglais (tels que « ou bien » et « puis ») 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 « déclarer », « begin » et « fin », où la « fin » (dans la plupart des cas) est suivi par l'identifiant du bloc se ferme (par exemple, si ... end if , boucle ... boucle d'extrémité ). Dans le cas des blocs conditionnels cela évite un ballants d' autre qui pourrait jumeler avec le mauvais imbriquée si l' expression dans d' autres langages comme C ou Java.

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

Un grand nombre de contrôles de compilation sont pris en charge pour éviter des bugs qui ne seraient pas détectables jusqu'à l'exécution dans d'autres langues ou nécessiteraient des contrôles explicites à ajouter au code source. Par exemple, la syntaxe exige explicitement nommée la fermeture des blocs afin d'éviter les erreurs dues à des jetons de fin ne concordent pas. L'adhésion à typage fort permet la détection de nombreuses erreurs logicielles communes (paramètres erronés, les violations de la gamme, les références invalides, types dépareillées, etc.) soit au cours de la compilation, ou autre cours d'exécution. Comme fait partie de la concurrence la spécification du langage, le compilateur peut dans certains cas, détecter les blocages potentiels. Compilateurs aussi souvent vérifier les identifiants mal orthographiés, visibilité des paquets, des 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 contrôles en temps courir pour se protéger contre l' accès à la mémoire non allouée, débordement de tampon erreurs, violations de portée, des erreurs hors par une , des erreurs d'accès au tableau, et d' autres bugs 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ées 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 pourrait conduire à des conséquences très graves, par exemple, la mort accidentelle, perte financière ou des blessures graves. Des exemples de systèmes où Ada est utilisé comprennent l' avionique , l' ATC , les chemins de fer, la banque, militaire et de la technologie spatiale.

Dynamique Ada gestion de la mémoire est de haut niveau et le type de sécurité. Ada n'a pas générique ou non typées pointeurs ; ni déclarer implicitement tout type de pointeur. Au lieu de cela, toute allocation dynamique de mémoire et désallocation doit avoir lieu par le biais explicitement déclarés types d'accès . Chaque type d'accès est associé à un pool de stockage qui gère les détails de bas niveau de gestion de la mémoire; le programmeur peut utiliser soit le pool de stockage par défaut ou définir de nouvelles (ce qui est particulièrement pertinent pour l' accès mémoire non uniforme ). Il est même possible de déclarer plusieurs différents types d'accès que tous désignent le même type mais utilisent des pools de stockage. En outre, la langue prévoit des contrôles d'accessibilité , tant au moment de la compilation et au moment de l' exécution, qui assure qu'une valeur d'accès ne peut pas survivre le type de l'objet il pointe.

Bien que la sémantique de la langue permettent automatiquement la collecte des ordures des objets inaccessibles, la plupart des implémentations ne prennent pas en charge par défaut, car elle entraînerait un comportement imprévisible dans les systèmes en temps réel. Ada prend en charge une forme limitée de gestion de la mémoire à base de région ; En outre, l' utilisation créative des pools de stockage peut prévoir une forme limitée de la collecte des ordures automatique, depuis la destruction d' un pool de stockage détruit également tous les objets de la piscine.

Un double tiret ( « - »), qui ressemble à un tableau de bord em , indique le texte de commentaire. Commentaires arrêt à la fin de la ligne, afin d' éviter les commentaires non fermées accidentellement de vider des pans entiers du code source. La désactivation d' un bloc entier de code exige maintenant afficher le nom de chaque ligne (ou colonne) individuellement « - ». Tout en indiquant clairement le code désactivé avec une colonne de répétition « - » bas de la page ce qui rend le dis expérimental / re-activation des grands blocs , un processus plus étiré.

Le point - virgule ( « ») est un terminateur de la déclaration , et l'état zéro ou de non-fonctionnement est null;. Une seule ;sans une déclaration de fin n'est pas autorisé.

Contrairement à la plupart des ISO normes, la définition du langage Ada (connu sous le nom Manuel Ada référence ou ARM , ou parfois le manuel de référence du langage ou LRM ) est contenu gratuit . Ainsi, il est une référence commune pour les programmeurs Ada et pas seulement les programmeurs d' application compilateurs Ada. Mis à part le manuel de référence, il y a aussi un vaste document de justification qui explique la conception du langage et l'utilisation de diverses constructions linguistiques. Ce document est également largement utilisé par les programmeurs. Lorsque la langue a été révisée, un nouveau document de justification a été écrit.

Un remarquable logiciel libre outil qui est utilisé par de nombreux programmeurs Ada pour les aider à écrire le code source Ada est le studio de programmation GNAT .

L'histoire

Dans les années 1970, le département américain de la Défense (DoD) a été préoccupé par le nombre de différents langages de programmation utilisé pour ses projets de systèmes informatiques embarqués, dont beaucoup étaient obsolètes ou dépendant du matériel, et dont aucune prise en charge la programmation modulaire en toute sécurité. En 1975, un groupe de travail , le haut ordre Langue Groupe de travail (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é au ministère et le ministère britannique de la Défense exigences. Après de nombreuses itérations commençant par un original proposition de l' homme de paille le langage de programmation finale a été nommée 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 de 1996.

Le groupe de travail conçu HOLWG les exigences linguistiques Steelman , une série de documents faisant état des exigences auxquelles ils se sentaient un langage de programmation devrait satisfaire. De nombreuses langues existantes ont été examinés officiellement, mais l'équipe a conclu en 1977 que aucun texte existant sont conformes aux spécifications.

Les demandes de propositions pour un nouveau langage de programmation ont été émises et quatre entrepreneurs ont été engagés pour développer leurs propositions sous les noms de Red ( Intermetrics dirigé par Benjamin Brosgol), Vert ( CII Honeywell Bull , dirigé par Jean Ichbiah ), Bleu ( Softech , dirigé par John Goodenough) et jaune ( SRI international , dirigé par Jay Spitzen). En Avril 1978, après l' examen du public, les propositions rouge et vert passent à la phase suivante. En mai 1979, la proposition verte, conçue par Jean Ichbiah à Honeywell Bull Cil, a été choisi et donné le nom Ada-après Augusta Ada, comtesse de Lovelace . Cette proposition a été influencée par la langue programmation LIS qui Ichbiah et son groupe avaient mis au point dans les années 1970. Le manuel de référence Ada préliminaire a été publiée dans les avis ACM SIGPLAN en Juin 1979. Le manuel de référence standard militaire a été approuvé le 10 Décembre 1980 ( Ada Lovelace de anniversaire), et vu le nombre MIL-STD-1815 en l' honneur de la naissance de Ada Lovelace année. En 1981, la RCA Hoare a profité de son Turing Award discours pour critiquer Ada pour être trop complexe et donc peu fiable, mais par la suite semblait abjurer dans l'avant - propos , il écrit pour un manuel Ada.

Ada a attiré beaucoup d' attention de la communauté de programmation dans son ensemble au cours de ses premiers jours. Ses bailleurs de fonds et d' autres ont prédit qu'il pourrait devenir une langue dominante pour la programmation à usage général et non seulement le travail lié à la défense. Ichbiah a publiquement déclaré que , dans dix ans, seulement deux langages de programmation demeureraient, Ada et Lisp . Les premiers compilateurs Ada luttaient pour mettre en œuvre le grand langage complexe, et à la fois la compilation et les performances d' exécution étaient généralement lents et des outils primitifs. Les fournisseurs de compilateur la plupart de leurs dépensés efforts pour passer le massif-conformité-évaluation des connaissances linguistiques, le gouvernement requis suite de validation « ACVC » qui était nécessaire dans une autre nouvelle caractéristique de l'effort de langage Ada.

La première mise en œuvre validé Ada était le traducteur Ada Université de New York / Ed, certifié le 11 Avril 1983. Université de New York Ada / Ed est mis en œuvre dans la langue de jeu de haut niveau SETL . Un certain nombre de sociétés commerciales a commencé à offrir des compilateurs Ada et des outils de développement associés, y compris Alsys , TeleSoft , DDC-I , Techniques avancées informatiques , Laboratoires Tartan , TLD Systems , Verdix , et d' autres.

Augusta Ada roi , comtesse de Lovelace.

En 1991, le département américain de la Défense a commencé à exiger l'utilisation d'Ada (le du mandat Ada ) pour tous les logiciels, bien que des exceptions à cette règle étaient souvent accordées. Le ministère de la Défense mandat Ada a été effectivement supprimée en 1997, le Département de la défense a commencé à embrasser COTS technologie. Des exigences similaires existent dans d' autres OTAN pays: Ada a été nécessaire pour les systèmes de l' OTAN impliquant commandement et de 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 les pays tels que la Suède, l' Allemagne et le Canada.

Fin des années 1980 et début des années 1990, les compilateurs Ada se sont améliorés dans la performance, mais il y avait encore des obstacles à la pleine exploitation des capacités de Ada, y compris un modèle qui était différent tasking de ce que la plupart des programmeurs ont été utilisés en temps réel.

En raison de d'Ada critiques pour la sécurité des fonctions de soutien, il est maintenant utilisé non seulement pour des applications militaires, mais aussi dans des projets commerciaux où un bug logiciel peut avoir des conséquences graves, par exemple, l' avionique et le contrôle du trafic aérien , des fusées commerciales telles que l' Ariane 4 et 5 , satellites et autres systèmes spatiaux, le transport ferroviaire et bancaires. Par exemple, le système de gestion de l' information Avion , le fly-by-wire logiciel système dans le Boeing 777 , a été écrit en Ada. Développé par Honeywell Air Transport Systems en collaboration avec des consultants de DDC-I , il est devenu sans doute le plus connu de tout projet Ada, civil ou militaire. Le système automatisé de circulation aérienne du Canada a été écrit dans 1 million de lignes d'Ada ( SLOC nombre). Il a présenté le traitement avancé distribué, une base de données Ada distribuée, et la conception orientée objet. Ada est également utilisé dans d' autres systèmes de la circulation aérienne, par exemple, la zone provisoire de la prochaine génération du Royaume - Uni Future Control Tools Support (iFACTS) système de contrôle du trafic aérien est conçu et mis en œuvre à l' aide SPARK Ada. Il est également utilisé dans le français TVM in- signalisation en cabine 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 norme en 1983 ( ANSI / MIL-STD 1815A ), et après la traduction en français et sans autre modification en anglais est devenu une norme ISO en 1987 (ISO-8652: 1987). Cette version de la langue est communément appelé Ada 83, à partir de la date de son adoption par l' ANSI, mais est parfois aussi comme Ada 87, à partir de la date de son adoption par l' ISO.

Ada 95, l'articulation norme ISO / ANSI ( ISO-8652: 1995 ) a été publié en Février 1995, ce qui Ada 95 la première langue de programmation orientée objet standard ISO. Pour aider à la révision de la norme et l' acceptation future, l' US Air Force a financé le développement du GNAT compilateur . À l' heure actuelle, le compilateur GNAT fait partie de la collection du compilateur GNU .

Les travaux se poursuivent sur l' amélioration et la mise à jour du contenu technique du langage de programmation Ada. Un rectificatif technique à 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'Association des ressources Ada (ARA) et Ada-Europe a annoncé l'achèvement de la conception de la dernière version du langage de programmation Ada et la présentation du manuel de référence à l'Organisation internationale de normalisation (ISO) pour approbation. ISO / IEC 8652: 2012 a été publié en Décembre 2012.

D' autres normes connexes comprennent ISO 8651 -3: 1988 consolidations-Partie du langage graphique-graphique du noyau système Traitement de l' information des systèmes informatiques (GKS) 3: Ada .

Les constructions de langage

Ada est un ALGOL langage de programmation -comme avec les structures de contrôle avec des mots réservés tels que si , alors , d' autre , alors que , pour , et ainsi de suite. Cependant, Ada a également de nombreux équipements structurants de données et d' autres abstractions qui ne figurent pas dans l'original Algol 60 , tels que les définitions de type , les enregistrements , les pointeurs , les énumérations . Ces constructions ont été en partie hérités ou inspirés par Pascal .

"Bonjour le monde!" Ada

Un exemple courant de la langue d'une syntaxe est le programme Bonjour tout le monde : (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 type d'Ada ne repose pas sur un ensemble de prédéfinis types primitifs mais permet aux utilisateurs de déclarer leurs propres types. Cette déclaration est à son tour ne repose pas sur la représentation interne du type , mais à décrire l'objectif qui devrait être atteint. 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 à la compilation et le temps d' exécution (c. -à- violations de plage, des dépassements de mémoire tampon, la cohérence de type, etc.). Ada supporte les types numériques correspondant à une gamme, les types, les types d' agrégats modulo (fiches et tableaux) et les types d'énumération. Type d'accès définissent une référence à une instance d'un type spécifié; pointeurs non typés ne sont pas autorisés. Types spéciaux fournis par la langue sont les types de tâches et types protégés.

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

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 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 limités, abstraits, privés , etc. types privés ne sont accessibles et types limités ne peuvent être modifiés ou copiés dans le cadre du paquet qui les définit. Ada 95 ajoute des fonctionnalités supplémentaires pour l' extension orientée objet de types.

Structures de contrôle

Ada est une programmation structurée langue, ce qui signifie que le flux de contrôle est structuré en déclarations standard. Toutes les constructions standard et niveau profond sortie précoce sont pris en charge si l'utilisation de la prise en charge aussi « aller » des commandes 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;

Forfaits, procédures et fonctions

Parmi les parties d'un programme Ada sont les paquets, les procédures et les fonctions.

Exemple: spécification de paquet (example.ads)

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

corps de boîtier (de example.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 paquets, les procédures et les fonctions peuvent nid à toute profondeur et chacune peut également être le bloc logique le plus externe.

Chaque paquet, procédure ou une fonction peut avoir ses propres déclarations de constantes, types, variables et autres procédures, fonctions et packages, qui peuvent être déclarées dans un ordre quelconque.

Concurrency

Ada a prise en charge linguistique pour tâche concurrency base. L'unité concurrente fondamentale Ada est une tâche , qui est un type limité intégré. Les tâches sont précisées dans deux parties - la déclaration de tâche définit l'interface de tâche (similaire à une déclaration de type), le corps de tâche précise la mise en œuvre de la tâche. En fonction de la mise en œuvre, les tâches Ada sont soit mis en correspondance avec threads du système d'exploitation ou de processus, ou sont programmés en interne par le moteur d' exécution Ada.

Les tâches peuvent avoir des entrées de synchronisation (une forme de passage de messages synchrone ). Les entrées de tâches sont déclarées dans la spécification des tâches. Chaque entrée de tâche peut avoir un ou plusieurs accepter des déclarations 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 est appelée par une autre tâche ( de même, une tâche d'appel est bloqué jusqu'à ce que la tâche appelée atteint l'instruction correspondante accepter). Les entrées de tâches peuvent avoir des paramètres similaires à des procédures, ce qui permet d'échanger des tâches données de manière synchrone. En collaboration avec sélectionner les déclarations , il est possible de définir des gardes sur accepter des déclarations (semblables à Dijkstra les commandes gardées ).

Ada offre également des objets protégés pour l' exclusion mutuelle . Objets protégés sont un moniteur comme construction, mais utilisent des gardes au lieu des variables conditionnelles pour la signalisation (similaire à condition régions critiques). Objets protégés combinent l'encapsulation de données et de l' exclusion mutuelle en toute sécurité des moniteurs et des gardes d'entrée de régions conditionnelles critiques. Le principal avantage par rapport aux moniteurs classiques est que les variables conditionnelles ne sont pas nécessaires pour la signalisation, ce qui évite les blocages potentiels en raison de la sémantique de verrouillage incorrect. Tout comme les tâches, l'objet protégé est un type limité intégré, et il a également une partie de déclaration et d' un corps.

Un objet protégé est constitué de données privées encapsulées (qui ne peuvent être accessibles à partir de l'objet protégé), et les procédures, les fonctions et les entrées qui sont garantis pour être mutuellement exclusifs (à la seule exception des fonctions, qui sont nécessaires pour être des effets secondaires libre et peut donc fonctionner simultanément avec d'autres fonctions). Une tâche d'appeler un objet protégé est bloqué si une autre tâche est en train d'exécuter dans le même objet protégé et libéré lorsque cette autre tâche quitte l'objet protégé. tâches bloquées sont mises en attente sur l'objet protégé selon l'heure d'arrivée.

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

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

La sélection déclaration Ada peut être utilisé pour mettre en œuvre des appels d'entrée non-blocage et accepte, sélection non-déterministe des entrées (également avec des gardes), les délais d'attente et avorte.

L'exemple suivant illustre certains concepts de la programmation concurrente en 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 just 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 sortie compilée. Certains pragmas sont intégrés dans la langue tandis que d' autres sont spécifiques à la mise en œuvre.

Des exemples de l'utilisation commune des pragmas du compilateur serait de désactiver certaines caractéristiques, telles que l'exécution de type contrôle ou une matrice de vérification de limite de l'indice, ou de demander au compilateur d'insérer le code objet en lieu et place d'un appel de fonction (C / C ++ fait avec inline les fonctions).

Voir également

  • APSE - un cahier des charges pour un environnement de programmation pour soutenir le développement de logiciels Ada
  • Profil Ravenscar - un sous - ensemble des fonctions d'attribution des tâches Ada conçus pour les disques à sécurité critique de calcul en temps réel
  • SPARK (langage de programmation) - un langage de programmation composé d'un sous - ensemble très restreint d'Ada, avec les méta - informations annotée décrivant le comportement souhaité des composants et des exigences d'exécution individuelles

Références

Normes internationales

Raisonnement

(Ces documents ont été publiés sous diverses formes, y compris l'impression.)

Livres

  • Booch, Grady (1987), génie logiciel avec Ada , Californie: The Benjamin / Cummings Publishing Company, Inc., ISBN  0-8053-0604-8
  • Jan Skansholm: Ada 95 Depuis le début , Addison-Wesley, ISBN  0-201-40376-5
  • Geoff Gilpin: Ada: Visite guidée et didacticiel , Prentice Hall, ISBN  978-0-13-004045-9
  • John Barnes : Programmation en Ada 2005 , Addison-Wesley, 2006, ISBN  0-321-34078-7
  • John Barnes: Programmation en Ada , plus Langue Manuel de référence , Addison-Wesley, ISBN  0-201-56539-0
  • John Barnes: Programmation en Ada 95 , Addison-Wesley, ISBN  0-201-34293-6
  • John Barnes: High Integrity Ada: L'approche SPARK , Addison-Wesley, 1997, ISBN  0-201-17517-7
  • John Barnes: Logiciel de haute intégrité: La SPARK approche de la sécurité et de la sécurité , Addison-Wesley, 2003, ISBN  0-321-13616-0
  • John Beidler: Structures de données et algorithmes: Une approche orientée objet L' utilisation Ada 95 , Springer-Verlag, 1997, ISBN  0-387-94834-1
  • Dean W. Gonzalez : Manuel de Ada programmeur , Benjamin-Cummings Publishing Company, 1991, ISBN  0-8053-2529-8
  • M. Ben-Ari : Ada pour les ingénieurs logiciels , John Wiley & Sons, 1998, ISBN  0-471-97912-0
  • Norman Cohen: Ada comme langue seconde , McGraw-Hill Science / Engineering / Math, ISBN  0-07-011607-5
  • Alan Burns a , Andy Wellings : Systèmes temps réel et langages de programmation. Ada 95, en temps réel Java et temps réel POSIX. , Addison-Wesley, ISBN  0-201-72988-1
  • Alan Burns a , Andy Wellings : Concurrency Ada , Cambridge University Press, 1995, ISBN  0-521-62911-X
  • Colin Atkinson: La réutilisation orientée objet, et la distribution Concurrency: une approche fondée sur Ada , Addison-Wesley, ISBN  0-201-56527-7
  • Grady Booch , Doug Bryan: génie logiciel avec Ada , Addison-Wesley, ISBN  0-8053-0608-0
  • Alors que Do-Jones: Ada en action: avec des exemples pratiques de programmation , John Wiley & Sons Inc, ISBN  0-471-60708-8
  • Daniel Stubbs, Neil W. Webre: Structures de données avec les types de données Résumé et Ada , Brooks Cole, ISBN  0-534-14448-9
  • Pascal Ledru: Programmation distribuée en Ada avec des objets protégés , Dissertation.com, ISBN  1-58112-034-6
  • Fintan Culwin: Ada, une approche du développement , Prentice Hall, ISBN  0-13-264680-3
  • John English, Fintan Culwin: Ada 95 l'art de la programmation orientée objet , Prentice Hall, ISBN  0-13-230350-7
  • David A. Wheeler : Ada 95 , Springer-Verlag, ISBN  0-387-94801-5
  • David R. Musser, Alexander Stepanov : La bibliothèque générique Ada: Liste linéaire Traitement des paquets , Springer-Verlag, ISBN  0-387-97133-5
  • Michael B. Feldman: Construction de logiciels et de données avec Ada Structures 95 , Addison-Wesley, ISBN  0-201-88795-9
  • Simon Johnston : Ada 95 C et programmeurs C ++ , Addison-Wesley, ISBN  0-201-40363-3
  • " Ada. Problem Solving et la conception du programme " Feldman, Michael B. & Koffman, Elliot B., ISBN  0-201-52279-9 . Addison-Wesley Publishing Company; 1992 et 1993. 795 pages.
  • Michael B. Feldman, Elliot B. Koffman : Ada 95 , Addison-Wesley, ISBN  0-201-36123-X
  • Nell B. Dale , Chip Weems, John McCormick: Programmation et résolution de problèmes avec Ada 95 , Jones & Bartlett Publishers, ISBN  0-7637-0293-5
  • Nell B. Dale, John McCormick: Structures Ada données plus: une approche orientée objet, 2e édition , Jones & Bartlett Publishers, ISBN  0-7637-3794-1
  • Bruce C. Krell: développement avec Ada: Méthodes du cycle de vie , Dell bantam Pub Group, ISBN  0-553-09102-6
  • Judy Bishop: Distributed Ada: Développements et expériences , Cambridge University Press, ISBN  0-521-39251-9
  • Bo Sanden: Logiciels Systèmes de construction avec des exemples à Ada , Prentice Hall, ISBN  0-13-030834-X
  • Bruce Hillam: Introduction à Résumé des types de données Utilisation Ada , Prentice Hall, ISBN  0-13-045949-6
  • David Rudd: Introduction au logiciel de conception et de développement avec Ada , Brooks Cole, ISBN  0-314-02829-3
  • Ian C. Pyle: Développement de systèmes de sécurité: Guide L' utilisation Ada , Prentice Hall, ISBN  0-13-204298-3
  • Louis Baker: Intelligence artificielle avec Ada , McGraw-Hill, ISBN  0-07-003350-1
  • Alan Burns a , Andy Wellings : HRT-HOOD: Une méthode de conception structurée pour les disques en temps réel Ada Systems , North-Holland, ISBN  0-444-82164-3
  • Walter Savitch, Charles Peterson: Ada: Introduction à l'art et la science de la programmation , Benjamin-Cummings Publishing Company, ISBN  0-8053-7070-6
  • Mark Allen Weiss: Structures de données et l' algorithme d' analyse en Ada , Benjamin-Cummings Publishing Company, ISBN  0-8053-9055-3
  • Henry Ledgard: ADA: Introduction (deuxième édition), Springer-Verlag, ISBN  0-387-90814-5
  • Dines Bjørner; Ole N. Oest (dir.): Vers une description formelle d'Ada , London: Springer-Verlag, 1980. ISBN  3-540-10283-3

Les archives

  • Ada langage de programmation des matériaux, 1981-1990 . Charles Babbage Institute , Université du Minnesota. Comprend la documentation sur les produits logiciels conçus pour la langue Ada; Les publications du gouvernement des États - Unis, y compris les rapports de projet Ada 9X, rapports techniques, documents de travail, des bulletins d' information; et les informations de groupe d'utilisateurs.

Liens externes