Ada (programovací jazyk) - Ada (programming language)

Ada
Paradigma Multi-paradigma : strukturované , imperativní , objektově orientované
Rodina Pascal
Navrhl
  • MIL-STD-1815, Ada 83: Jean Ichbiah
  • Ada 95: Tucker Taft
  • Ada 2005: Tucker Taft
  • Ada 2012: Tucker Taft
Poprvé se objevil Únor 1980 ; Před 41 lety ( 1980-02 )
Stabilní uvolnění
Ada 2012 TC1
Kázeň při psaní statický , silný , bezpečný , nominativní
OS Více nebo více platforem
Rozšíření názvu souboru .adb, .ads
webová stránka www .adaic .org
Hlavní implementace
AdaCore GNAT (zdarma ke stažení: https://www.adacore.com/download ),
Green Hills Software Optimalizace Ada 95 překladač,
PTC, Inc. PTC ApexAda a PTC ObjectAda,
"MapuSoft Ada-C / C ++ měnič" ., dříve známý jako „AdaMagic s C Intermediate“, skóre
DDC-I
Nářečí
SPARK , profil Ravenscar
Ovlivněn
ALGOL 68 , Pascal , Simula 67 , C ++ (Ada 95), Smalltalk (Ada 95), Modula-2 (Ada 95) Java (Ada 2005), Eiffel (Ada 2012)
Ovlivněn
C ++ , Chapel , Drago , D , Eiffel , Griffin, Java , Nim , ParaSail , PL/SQL , PL/pgSQL , Python , Ruby , Seed7 , SPARforte, Sparkel , SQL/PSM , VHDL

Ada je strukturovaný , staticky typovaný , imperativní a objektově orientovaný programovací jazyk na vysoké úrovni , rozšířený z jazyka Pascal a dalších. Má vestavěnou jazykovou podporu pro návrh podle smlouvy (DbC), extrémně silné psaní , explicitní souběžnost, úkoly, synchronní předávání zpráv, chráněné objekty a nedeterminismus . Ada zlepšuje bezpečnost a udržovatelnost kódu pomocí kompilátoru k vyhledání chyb ve prospěch chyb za běhu . Ada je mezinárodní technická norma , společně definovaná Mezinárodní organizací pro normalizaci (ISO) a Mezinárodní elektrotechnickou komisí (IEC). Od roku 2020 je standard, neformálně nazývaný Ada 2012, ISO/IEC 8652: 2012.

Ada byl původně navržen týmem vedeným francouzským počítačovým vědcem Jeanem Ichbiahem z CII Honeywell Bull na základě smlouvy s Ministerstvem obrany USA (DoD) v letech 1977 až 1983, aby nahradil více než 450 programovacích jazyků používaných v té době DoD. Ada byla pojmenována po Ada Lovelace (1815–1852), která byla připsána jako první počítačový programátor.

Funkce

Ada byl původně určen pro vložené a real-time systémů. Revize Ada 95, kterou navrhl S. Tucker Taft of Intermetrics v letech 1992 až 1995, zlepšila podporu systémů, numerického, finančního a objektově orientovaného programování (OOP).

Mezi funkce Ada patří: silné psaní , modulární programovací mechanismy (balíčky), kontrola běhu , paralelní zpracování ( úkoly , synchronní předávání zpráv , chráněné objekty a nedeterministické příkazy select ), zpracování výjimek a generika . Ada 95 přidala podporu pro objektově orientované programování , včetně dynamického odesílání .

Syntaxe Ada minimalizuje výběr způsobů provádění základních operací a upřednostňuje anglická klíčová slova (například „nebo jinak“ a „a potom“) před symboly (například „||“ a „&&&“). Ada používá základní aritmetické operátory „+“, „-“, „*“ a „/“, ale vyhýbá se používání jiných symbolů. Bloky kódu jsou odděleny slovy jako „deklarace“, „začátek“ a „konec“, kde za „koncem“ (ve většině případů) následuje identifikátor bloku, který zavírá (např. Pokud ... konec, pokud , smyčka ... koncová smyčka ). V případě podmíněných bloků se tím zabrání visícímu jinému, který by se mohl spárovat se špatným vnořeným výrazem if v jiných jazycích, jako je C nebo Java.

Ada je určena pro vývoj velmi rozsáhlých softwarových systémů. Balíčky Ada lze sestavit samostatně. Specifikace balíčku Ada (rozhraní balíčku) lze také zkompilovat samostatně bez implementace a zkontrolovat konzistenci. To umožňuje detekovat problémy brzy během fáze návrhu, než začne implementace.

Je podporován velký počet kontrol při kompilaci, aby se předešlo chybám, které by nebyly detekovatelné do běhu v některých jiných jazycích nebo by vyžadovaly přidání explicitních kontrol do zdrojového kódu. Syntaxe například vyžaduje explicitně pojmenované zavírání bloků, aby se předešlo chybám kvůli neshodným koncovým tokenům. Dodržování silného psaní umožňuje detekovat mnoho běžných softwarových chyb (špatné parametry, narušení rozsahu, neplatné reference, neshodné typy atd.) Buď během kompilace, nebo jinak během běhu. Jelikož souběžnost je součástí specifikace jazyka, kompilátor může v některých případech detekovat potenciální zablokování. Kompilátory také běžně kontrolují chybně napsané identifikátory, viditelnost balíků, nadbytečná prohlášení atd. A mohou poskytovat varování a užitečné návrhy, jak chybu opravit.

Ada také podporuje běhové kontroly, které chrání před přístupem k nepřidělené paměti, chybám přetečení vyrovnávací paměti , narušení rozsahu, chybám mimo provoz, chybám přístupu k poli a dalším zjistitelným chybám. Tyto kontroly lze deaktivovat v zájmu efektivity běhu, ale často je lze efektivně kompilovat. Obsahuje také zařízení, která pomáhají při ověřování programu . Z těchto důvodů je Ada široce používána v kritických systémech, kde jakákoli anomálie může vést k velmi vážným následkům, např. Náhodnému úmrtí, zranění nebo vážné finanční ztrátě. Mezi příklady systémů, kde se používá Ada, patří avionika , řízení letového provozu , železnice, bankovní, vojenské a vesmírné technologie.

Ada dynamická správa paměti je na vysoké úrovni a bezpečná pro daný typ. Ada nemá žádná obecná ani nezadaná ukazatele ; ani implicitně nedeklaruje žádný typ ukazatele. Místo toho musí všechny dynamické alokace paměti a zrušení přidělení probíhat prostřednictvím explicitně deklarovaných typů přístupu . Každý typ přístupu má přidružený fond úložišť, který zpracovává detaily nízké úrovně správy paměti; programátor může buď použít výchozí fond úložišť, nebo definovat nové (to je zvláště důležité pro přístup k nejednotné paměti ). Je dokonce možné deklarovat několik různých typů přístupu, které všechny označují stejný typ, ale používají různé fondy úložiště. Jazyk také zajišťuje kontroly přístupnosti , a to jak v době kompilace, tak za běhu, což zajišťuje, že přístupová hodnota nemůže přežít typ objektu, na který ukazuje.

Ačkoli sémantika jazyka umožňuje automatické uvolňování paměti nepřístupných objektů, většina implementací jej ve výchozím nastavení nepodporuje, protože by to způsobilo nepředvídatelné chování v systémech v reálném čase. Ada podporuje omezenou formu správy paměti založené na regionech ; Kreativní využití fondů úložiště také může zajistit omezenou formu automatického shromažďování odpadků, protože zničení fondu úložiště také zničí všechny objekty ve fondu.

Dvojitá pomlčka („-“), připomínající pomlčku em , označuje text komentáře. Komentáře se zastaví na konci řádku, aby se zabránilo neuzavřeným komentářům v neúmyslném zrušení celých částí zdrojového kódu. Deaktivace celého bloku kódu nyní vyžaduje předponu každého řádku (nebo sloupce) jednotlivě „-“. I když je jasně označen deaktivovaný kód se sloupcem opakovaného „-“ na stránce dolů, experimentální deaktivace/opětovné povolení velkých bloků se stává mnohem delší.

Středník (";") je ukončovač příkazů a příkaz null nebo no-operation je null;. Jediný ;bez příkazu k ukončení není povolen.

Na rozdíl od většiny norem ISO je definice jazyka Ada (známá jako Ada Reference Manual nebo ARM , někdy také jako Language Reference Manual nebo LRM ) bezplatný obsah . Je to tedy běžná reference pro programátory Ada, nejen pro programátory implementující kompilátory Ada. Kromě referenčního manuálu existuje také rozsáhlý odůvodněný dokument, který vysvětluje jazykový design a použití různých jazykových konstrukcí. Tento dokument je také široce používán programátory. Když byl jazyk revidován, byl sepsán nový odůvodněný dokument.

Jeden pozoruhodný bezplatný softwarový nástroj, který používá mnoho programátorů Ada, aby jim pomohl při psaní zdrojového kódu Ada, je GNAT Programming Studio , součást kolekce kompilátorů GNU .

Dějiny

V sedmdesátých letech se americké ministerstvo obrany (DoD) začalo zajímat o počet různých programovacích jazyků používaných pro jeho projekty vestavěných počítačových systémů, z nichž mnohé byly zastaralé nebo závislé na hardwaru a žádný z nich nepodporoval bezpečné modulární programování. V roce 1975 byla vytvořena pracovní skupina , High Order Language Working Group (HOLWG), se záměrem snížit tento počet nalezením nebo vytvořením programovacího jazyka, který je obecně vhodný pro požadavky ministerstva a ministerstva obrany Spojeného království . Po mnoha iteracích začínajících původním návrhem Straw Man byl eventuální programovací jazyk pojmenován Ada. Celkový počet programovacích jazyků na vysoké úrovni používaných pro takové projekty klesl z více než 450 v roce 1983 na 37 do roku 1996.

Pracovní skupina HOLWG vytvořila jazykové požadavky Steelman , což je řada dokumentů uvádějících požadavky, které by podle nich měl programovací jazyk splňovat. Mnoho stávajících jazyků bylo formálně přezkoumáno, ale tým v roce 1977 dospěl k závěru, že žádný stávající jazyk nesplňuje specifikace.

Augusta Ada King , hraběnka z Lovelace.

Byly vydány žádosti o návrhy nového programovacího jazyka a najati čtyři dodavatelé, kteří vyvíjeli své návrhy pod názvy Red ( Intermetrics vedl Benjamin Brosgol), Green ( CII Honeywell Bull , vedl Jean Jean Ichbiah ), Blue ( SofTech , vedl John Goodenough) a Yellow ( SRI International , vedená Jayem Spitzenem). V dubnu 1978, po veřejné kontrole, návrhy Red and Green přešly do další fáze. V květnu 1979 byl vybrán Zelený návrh, který navrhl Jean Ichbiah z CII Honeywell Bull, a dostal jméno Ada - podle Augusty Ada, hraběnky z Lovelace . Tento návrh byl ovlivněn jazykem LIS, který Ichbiah a jeho skupina vyvinuli v 70. letech minulého století. Předběžný referenční manuál Ada byl publikován v ACM SIGPLAN Notices v červnu 1979. Referenční manuál Military Standard byl schválen 10. prosince 1980 ( narozeniny Ady Lovelaceové ) a dostal číslo MIL-STD-1815 na počest narození Ady Lovelaceové. rok. V roce 1981, CAR Hoare využil svého projevu Turing Award kritizovat Ada za to, že je příliš složitý, a proto nespolehlivý, ale následně se zdálo, že se zřekl v předmluvě, kterou napsal pro učebnici Ada.

Ada během svých počátků přitahovala velkou pozornost programovací komunity jako celku. Jeho podporovatelé a další předpovídali, že by se to mohlo stát dominantním jazykem pro všeobecné programování a nejen pro práci související s obranou. Ichbiah veřejně prohlásil, že do deseti let zůstanou pouze dva programovací jazyky: Ada a Lisp . Rané kompilátory Ada se snažily implementovat velký a složitý jazyk a výkon při kompilaci i běhu byl pomalý a nástroje primitivní. Prodejci kompilátorů vynaložili většinu svého úsilí na absolvování rozsáhlé sady ověřování jazykové shody a vládou vyžadované ověřovací sady „ACVC“, která byla vyžadována v další nové funkci jazykového úsilí Ada. The Jargon File , slovník počítačového hackerského slangu pocházejícího z let 1975–1983, v záznamu o Adě uvádí, že „je to přesně to, co by se dalo očekávat vzhledem k takovému schválení fiatem; navrženo výborem ... obtížně použitelné a celkově katastrofální, mnohamiliardový boondoggle ... Ada Lovelace ... by se téměř jistě zbledla při použití jejího jména, které bylo v poslední době uvedeno; nejlaskavější věc, která o tom byla řečeno, je, že pravděpodobně existuje dobrý malý jazyk křičící, aby se dostal ven z jeho obrovské, sloní části. "

První ověřenou implementací Ada byl překladač NYU Ada/Ed, certifikovaný 11. dubna 1983. NYU Ada/Ed je implementován ve vysoce nastaveném jazyce SETL . Několik komerčních společností začalo nabízet kompilátory Ada a související vývojové nástroje, včetně Alsys , TeleSoft , DDC-I , Advanced Computer Techniques , Tartan Laboratories , TLD Systems a Verdix .

V roce 1991 začalo americké ministerstvo obrany vyžadovat použití Ada ( mandát Ada ) pro veškerý software, i když se často udělovaly výjimky z tohoto pravidla. Mandát ministerstva obrany Ada byl v roce 1997 účinně odstraněn, protože DoD začalo využívat komerční off-the-shelf ( COTS ) technologii. Podobné požadavky existovaly v jiných zemích NATO : Ada byla vyžadována pro systémy NATO zahrnující velení a řízení a další funkce a Ada byl pověřený nebo preferovaný jazyk pro obranné aplikace v zemích, jako je Švédsko, Německo a Kanada.

Koncem osmdesátých a začátkem devadesátých let se Ada kompilátory zlepšily ve výkonu, ale stále existovaly překážky pro plné využití Adových schopností, včetně modelu úkolování, který byl odlišný od toho, na co byla většina programátorů v reálném čase zvyklá.

Díky podpůrným funkcím, které jsou kritické pro bezpečnost Ada , se nyní používá nejen pro vojenské aplikace, ale také v komerčních projektech, kde může mít softwarová chyba vážné důsledky, např. Avionika a řízení letového provozu , komerční rakety jako Ariane 4 a 5 , satelity a další vesmírné systémy, železniční doprava a bankovnictví. Například Ada napsal systém pro správu informací o letadle , softwarový systém fly-by-wire v Boeingu 777 . Vyvinutý společností Honeywell Air Transport Systems ve spolupráci s konzultanty z DDC-I se stal pravděpodobně nejznámějším z jakéhokoli civilního nebo vojenského projektu Ada. Kanadský automatizovaný systém letového provozu byl napsán v 1 milionu řádků Ada ( počet SLOC ). Představoval pokročilé distribuované zpracování , distribuovanou databázi Ada a objektově orientovaný design. Ada se také používá v jiných systémech letového provozu, např. Britský systém další generace Interim Future Area Control Tools Support (iFACTS) je navržen a implementován pomocí systému SPARK Ada. Používá se také ve francouzském palubním signalizačním systému TVM na vysokorychlostním železničním systému TGV a příměstských vlacích metra v Paříži, Londýně, Hongkongu a New Yorku.

Standardizace

Jazyk se stal standardem ANSI v roce 1983 ( ANSI/MIL-STD 1815A ) a po překladu do francouzštiny a bez dalších změn v angličtině se stal normou ISO v roce 1987 (ISO-8652: 1987). Tato verze jazyka je běžně známá jako Ada 83, od data jejího přijetí ANSI, ale někdy je také označována jako Ada 87, od data jejího přijetí ISO.

V únoru 1995 byla vydána společná norma ISO/ANSI ( ISO-8652: 1995 ) Ada 95, čímž se Ada 95 stal prvním objektově orientovaným programovacím jazykem standardu ISO. Aby pomohlo při standardní revizi a budoucím přijetí, americké letectvo financovalo vývoj kompilátoru GNAT . V současné době je překladač GNAT součástí kolekce kompilátorů GNU .

Pokračovaly práce na vylepšení a aktualizaci technického obsahu jazyka Ada. Technická oprava k Ada 95 byla zveřejněna v říjnu 2001 a hlavní změna, ISO/IEC 8652: 1995/Amd 1: 2007, byla zveřejněna 9. března 2007. Na konferenci Ada-Europe 2012 ve Stockholmu, Ada Resource Association (ARA) a Ada-Europe oznámily dokončení návrhu nejnovější verze jazyka Ada a předložení referenční příručky Mezinárodní organizaci pro normalizaci (ISO) ke schválení. ISO/IEC 8652: 2012 byla zveřejněna v prosinci 2012.

Mezi další související normy patří ISO 8651 -3: 1988 Systémy zpracování informací -Počítačová grafika -Vazby jazyků Graphical Kernel System (GKS) -Část 3: Ada .

Jazykové konstrukce

Ada je ALGOL like programovací jazyk představovat řídicí struktury s vyhrazených slov, například v případě , poté , jinde , zatímco , pro , a tak dále. Ada však má také mnoho zařízení pro strukturování dat a další abstrakce, které nebyly zahrnuty v původním ALGOL 60 , jako jsou definice typů , záznamy , ukazatele , výčty . Takové konstrukce byly částečně zděděny nebo inspirovány Pascalem .

"Ahoj světe!" v Adě

Běžným příkladem syntaxe jazyka je program Hello world : (hello.adb)

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

Tento program lze kompilovat pomocí volně dostupného open source překladače GNAT spuštěním

gnatmake hello.adb

Typy dat

Typový systém Ada není založen na sadě předdefinovaných primitivních typů, ale umožňuje uživatelům deklarovat své vlastní typy. Toto prohlášení zase není založeno na vnitřní reprezentaci typu, ale na popisu cíle, kterého by mělo být dosaženo. To umožňuje kompilátoru určit vhodnou velikost paměti pro daný typ a zkontrolovat porušení definice typu v době kompilace a době běhu (tj. Narušení rozsahu, přetečení vyrovnávací paměti, konzistence typu atd.). Ada podporuje číselné typy definované rozsahem, typy modulo, agregační typy (záznamy a pole) a typy výčtů. Typy přístupu definují odkaz na instanci zadaného typu; netypové ukazatele nejsou povoleny. Zvláštní typy poskytované jazykem jsou typy úkolů a chráněné typy.

Datum může být například reprezentováno jako:

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;

Typy lze upřesnit deklarováním podtypů :

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

Typy mohou mít modifikátory, jako jsou omezené, abstraktní, soukromé atd. K soukromým typům lze přistupovat pouze a omezené typy lze upravovat nebo kopírovat pouze v rámci balíčku, který je definuje. Ada 95 přidává další funkce pro objektově orientované rozšíření typů.

Řídicí struktury

Ada je strukturovaný programovací jazyk, což znamená, že tok řízení je strukturován do standardních příkazů. Jsou podporovány všechny standardní konstrukce a předčasné ukončení hluboké úrovně, takže použití také podporovaných příkazů „ přejít “ je zřídka nutné.

-- 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;

Balíčky, postupy a funkce

Mezi části programu Ada patří balíčky, procedury a funkce.

Příklad: Specifikace balíčku (example.ads)

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

Tělo balíčku (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;

Tento program lze zkompilovat, např. Pomocí volně dostupného open-source překladače GNAT , spuštěním

gnatmake -z example.adb

Balíčky, procedury a funkce mohou být vnořeny do libovolné hloubky a každý může být také logickým nejvzdálenějším blokem.

Každý balíček, procedura nebo funkce může mít vlastní deklarace konstant, typů, proměnných a dalších procedur, funkcí a balíků, které lze deklarovat v libovolném pořadí.

Konkurence

Ada má jazykovou podporu pro souběžnost založenou na úkolech. Základní souběžnou jednotkou v Ada je úkol , který je vestavěným omezeným typem. Úkoly jsou specifikovány ve dvou částech - deklarace úkolu definuje rozhraní úkolu (podobně jako deklarace typu), orgán úkolu specifikuje implementaci úkolu. V závislosti na implementaci jsou úlohy Ada buď mapovány na vlákna nebo procesy operačního systému, nebo jsou interně naplánovány za běhu Ada.

Úkoly mohou mít položky pro synchronizaci (forma synchronního předávání zpráv ). Záznamy úkolů jsou deklarovány ve specifikaci úkolu. Každá položka úkolu může mít v těle úkolu jedno nebo více příkazů pro přijetí . Pokud řídicí tok úkolu dosáhne příkazu přijetí, je úkol blokován, dokud není odpovídající záznam vyvolán jiným úkolem (podobně je volající úkol blokován, dokud volaný úkol nedosáhne příslušného příkazu přijetí). Záznamy úkolů mohou mít parametry podobné postupům, což umožňuje úkolům synchronně vyměňovat data. Ve spojení s příkazy select je možné definovat stráže pro příkazy přijetí (podobné hlídaným příkazům Dijkstry ).

Ada také nabízí chráněné objekty pro vzájemné vyloučení . Chráněné objekty jsou konstrukcí podobnou monitoru , ale pro signalizaci používají namísto podmíněných proměnných stráže (podobné podmíněným kritickým oblastem). Chráněné objekty kombinují zapouzdření dat a bezpečné vzájemné vyloučení z monitorů a vstupní stráže z podmíněných kritických oblastí. Hlavní výhodou oproti klasickým monitorům je, že pro signalizaci nejsou vyžadovány podmíněné proměnné, čímž se zabrání potenciálním zablokování v důsledku nesprávné sémantiky zamykání. Stejně jako úkoly je chráněný objekt vestavěným omezeným typem a má také deklarační část a tělo.

Chráněný objekt se skládá ze zapouzdřených soukromých dat (ke kterým lze přistupovat pouze z chráněného objektu) a procedur, funkcí a záznamů, u nichž je zaručeno, že se budou vzájemně vylučovat (s jedinou výjimkou funkcí, u nichž se požaduje, aby byly bez vedlejších účinků) a proto může běžet souběžně s jinými funkcemi). Úkol volající chráněný objekt je blokován, pokud se uvnitř stejného chráněného objektu aktuálně provádí jiný úkol, a uvolní se, když tento jiný úkol opustí chráněný objekt. Blokované úkoly jsou zařazeny do fronty na chráněný objekt seřazené podle času příjezdu.

Vstupy chráněných objektů jsou podobné postupům, ale navíc mají stráže . Pokud strážný vyhodnotí hodnotu false, volající úloha je zablokována a přidána do fronty tohoto záznamu; nyní lze do chráněného objektu přijmout další úkol, protože uvnitř chráněného objektu se aktuálně neprovádí žádný úkol. Stráže jsou přehodnoceny vždy, když úkol opustí chráněný objekt, protože toto je jediný okamžik, kdy lze vyhodnocení strážců změnit.

Hovory na položky lze požadovat na jiné položky se stejným podpisem. Znovu zadaný úkol je blokován a přidán do fronty cílového záznamu; to znamená, že chráněný objekt je uvolněn a umožňuje přijetí dalšího úkolu.

Příkaz select v Ada lze použít k implementaci neblokujících vstupních volání a přijímá, nedeterministický výběr záznamů (také se strážci), časových limitů a přerušení.

Následující příklad ukazuje některé koncepty souběžného programování v 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

Pragma je směrnice kompilátoru, která přenáší informace do kompilátoru, aby umožnila konkrétní manipulaci se zkompilovaným výstupem. Některá pragmas jsou integrována do jazyka, zatímco jiná jsou specifická pro implementaci.

Běžné použití pragmas kompilátoru by mohlo být například zakázání určitých funkcí, jako je kontrola typu za běhu nebo kontrola hranic dolního indexu pole, nebo pokyn kompilátoru, aby místo volání funkce vložil kód objektu (jako to dělá C/C ++ s vloženými funkcemi ).

Generika

Ada má generika od svého prvního návrhu v letech 1977–1980. Standardní knihovna používá k poskytování mnoha služeb generika. Ada 2005 přidává do standardní knihovny komplexní generickou kontejnerovou knihovnu, která byla inspirována standardní knihovnou šablon C ++ .

Generická jednotka je balíček nebo podprogram, který má jeden nebo více generických formální parametry .

Obecný formální parametr je hodnota, proměnná, konstanta, typ, podprogram, nebo dokonce instancí další, označený, generické jednotka. U generických formálních typů rozlišuje syntaxe mezi typy diskrétní, s plovoucí desetinnou čárkou, s pevnou řádovou čárkou, přístupové (pointer) atd. Některé formální parametry mohou mít výchozí hodnoty.

Chcete -li vytvořit instanci obecné jednotky, programátor předá skutečné parametry pro každý formální. Obecná instance se pak chová stejně jako každá jiná jednotka. Je možné generovat generické jednotky za běhu , například uvnitř smyčky.

Viz také

  • APSE - specifikace pro programovací prostředí pro podporu vývoje softwaru v Ada
  • Profil Ravenscar -podmnožina funkcí Ada pro práci s úkoly navržená pro bezpečné kritické výpočetní prostředky v reálném čase
  • SPARK (programovací jazyk) - programovací jazyk skládající se z vysoce omezené podmnožiny Ada, anotovaných meta informacemi popisujícími požadované chování komponent a individuální runtime požadavky

Reference

Mezinárodní standardy

Zdůvodnění

Tyto dokumenty byly publikovány v různých formách, včetně tisku.

Knihy

  • Booch, Grady (1987). Softwarové inženýrství s Adou . Kalifornie: Benjamin/Cummings Publishing Company. ISBN 0-8053-0604-8.
  • Skansholm, leden (1996). Ada 95 od začátku . Addison-Wesley. ISBN 0-201-40376-5.
  • Gilpin, Geoff (1985). Ada: Komentovaná prohlídka a návod . Hala Prentice. ISBN 978-0-13-004045-9.
  • Barnes, John (2006). Programování v Ada 2005 . Addison-Wesley. ISBN 0-321-34078-7.
  • Barnes, John (1991). Programování v příručce Ada plus Language Reference Manual . Addison-Wesley. ISBN 0-201-56539-0.
  • Barnes, John (1998). Programování v Ada 95 . Addison-Wesley. ISBN 0-201-34293-6.
  • Barnes, John (1997). Vysoká integrita Ada: Přístup SPARK . Addison-Wesley. ISBN 0-201-17517-7.
  • Barnes, John (2003). Software s vysokou integritou: Přístup SPARK k bezpečnosti a zabezpečení . Addison-Wesley. ISBN 0-321-13616-0.
  • Beidler, John (1997). Datové struktury a algoritmy: Objektově orientovaný přístup pomocí Ada 95 . Springer-Verlag. ISBN 0-387-94834-1.
  • Gonzalez, Dean W. (1991). Příručka programátora Ada . Benjamin-Cummings Publishing Company. ISBN 0-8053-2529-8.
  • Ben-Ari, M. (1998). Ada pro softwarové inženýry . John Wiley & Sons. ISBN 0-471-97912-0.
  • Cohen, Norman (1996). Ada jako druhý jazyk . McGraw-Hill Science/Engineering/Math. ISBN 0-07-011607-5.
  • Burns, Alan ; Wellings, Andy (2001). Systémy a programovací jazyky v reálném čase. Ada 95, Java v reálném čase a POSIX v reálném čase . Addison-Wesley. ISBN 0-201-72988-1.
  • Burns, Alan ; Wellings, Andy (1995). Souběžnost v Ada . Cambridge University Press. ISBN 0-521-62911-X.
  • Atkinson, Colin (1991). Objektově orientované opětovné použití, souběžnost a distribuce: přístup založený na Ada . Addison-Wesley. ISBN 0-201-56527-7.
  • Booch, Grady ; Bryan, Doug (1994). Softwarové inženýrství s Adou . Addison-Wesley. ISBN 0-8053-0608-0.
  • Jones, Do-While (1989). Ada v akci: S praktickými příklady programování . John Wiley & Sons. ISBN 0-471-60708-8.
  • Stubbs, Daniel; Webre, Neil W. (1993). Datové struktury s abstraktními datovými typy a Ada . Brooks Cole. ISBN 0-534-14448-9.
  • Ledru, Pascal (prosinec 1998). Distribuované programování v Ada s chráněnými objekty . Dizertační práce.com. ISBN 1-58112-034-6.
  • Culwin, Fintan (1997). Ada, vývojový přístup . Sál Prentice. ISBN 0-13-264680-3.
  • Angličtina, John; Culwin, Fintan (leden 1997). Ada 95 Craft of Object-Oriented Programming . Sál Prentice. ISBN 0-13-230350-7.
  • Musser, David R .; Stepanov, Alexander (24. října 1989). Obecná knihovna Ada: Balíčky pro zpracování lineárního seznamu . Springer-Verlag. ISBN 0-387-97133-5.
  • Feldman, Michael B. (1997). Softwarová konstrukce a datové struktury s Ada 95 . Addison-Wesley. ISBN 0-201-88795-9.
  • Johnston, Simon (1997). Ada 95 pro programátory C a C ++ . Addison-Wesley. ISBN 0-201-40363-3.
  • Feldman, Michael B .; Koffman, Elliot B. (1992–1993). Ada: Řešení problémů a návrh programu . Addison-Wesley. ISBN 0-201-52279-9. 795 stran.
  • Feldman, Michael B .; Koffman, Elliot B. (1999). Ada 95 . Addison-Wesley. ISBN 0-201-36123-X.
  • Dale, Nell B .; Weems, Chip; McCormick, John (srpen 1996). Programování a řešení problémů s Ada 95 . Vydavatelé Jones & Bartlett. ISBN 0-7637-0293-5.
  • Dale, Nell B .; McCormick, John (2007). Datové struktury Ada Plus: Objektově orientovaný přístup, 2. vydání . Vydavatelé Jones & Bartlett. ISBN 978-0-7637-3794-8.
  • Krell, Bruce C. (1992). Vývoj s Adou: Metody životního cyklu . Bantam Dell Pub Group. ISBN 0-553-09102-6.
  • Bishop, Judy (10. května 1990). Distribuovaná Ada: Vývoj a zkušenosti . Cambridge University Press. ISBN 0-521-39251-9.
  • Sanden, Bo (1994). Konstrukce softwarových systémů s příklady v Ada . Sál Prentice. ISBN 0-13-030834-X.
  • Hillam, Bruce (1994). Úvod do abstraktních datových typů pomocí Ada . Sál Prentice. ISBN 0-13-045949-6.
  • Rudd, David (1994). Úvod do návrhu a vývoje softwaru s Adou . Brooks Cole. ISBN 0-314-02829-3.
  • Pyle, Ian C. (1991). Rozvoj bezpečnostních systémů: Průvodce pomocí Ada . Sál Prentice. ISBN 0-13-204298-3.
  • Baker, Louis (1989). Umělá inteligence s Adou . McGraw-Hill. ISBN 0-07-003350-1.
  • Burns, Alan ; Wellings, Andy (1995). HRT-HOOD: Strukturovaná metoda návrhu pro tvrdé systémy Ada v reálném čase . Severní Holandsko. ISBN 0-444-82164-3.
  • Savitch, Walter; Peterson, Charles (1992). Ada: Úvod do umění a vědy programování . Benjamin-Cummings Publishing Company. ISBN 0-8053-7070-6.
  • Weiss, Mark Allen (1993). Datové struktury a analýza algoritmů v Ada . Benjamin-Cummings Publishing Company. ISBN 0-8053-9055-3.
  • Ledgard, Henry (1983). Ada: Úvod (druhé vydání.). Springer-Verlag. ISBN 0-387-90814-5.
  • Bjørner, večeře; Oest, Ole N., eds. (1980). Směrem k formálnímu popisu Ada . Londýn: Springer-Verlag. ISBN 3-540-10283-3.

Archiv

externí odkazy